Verilen küçük harflerden oluşan bir dize s

aabaaababbbbaaba

ve pozitif bir tam sayı , n gibi 4, çıkış uzunluk- n dize t zaman bu tür T uzunluğuna tekrarlanır s , mümkün olduğu ortak birçok karakter olarak var. Verilen örnek için, en uygun çıktı aaba, çünkü hedef dizeyle ortak on üç karaktere sahip olacaktır:

s: aabaaababbbbaaba
t: aabaaabaaabaaaba (aaba)
   ^^^^^^^^  ^ ^^^^

ve hiçbir t daha mümkün değildir . Ancak, aaaaaabbunun için iki olası çıkış vardır: aaaave aababunların her biri, hedef dizeyle ortak 6 karaktere sahiptir:

s: aaaaaab
t: aaaaaaaa (aaaa)
   ^^^^^^ 

s: aaaaaab
t: aabaaaba (aaba)
   ^^ ^^^^

Ya aaaaya aabaoutputted veya her ikisi İsterseniz edilebilir. Not s şimdiye tekrarlanan değildir; aHer iki tekrarlanan t değerindeki iz basitçe yoksayılır.

Test durumları

Inputs -> Valid outputs
1 a -> a
1 aa -> a
2 aa -> aa
1 ab -> a b
2 ab -> ab
1 abb -> b
2 abb -> ab bb
2 ababa -> ab
2 abcba -> ab
2 aabbbbb -> bb  (ab is not a valid output here)
3 aababba -> aab abb
3 aababbaa -> aab
3 asdasfadf -> asf
3 asdasfadfsdf -> asf adf
2 abcdefghijklmnopqrstuvwxyzyx -> yx
2 supercalifragilisticexpialidocious -> ic ii
3 supercalifragilisticexpialidocious -> iri ili ioi
4 supercalifragilisticexpialidocious -> scii
5 supercalifragilisticexpialidocious -> iapic
2 eeeebaadbaecaebbbbbebbbbeecacebdccaecadbbbaceebedbbbddadebeddedbcedeaadcabdeccceccaeaadbbaecbbcbcbea -> bb be
10 bbbbacacbcedecdbbbdebdaedcecdabcebddbdcecebbeeaacdebdbebaebcecddadeeedbbdbbaeaaeebbedbeeaeedadeecbcd -> ebbbdbeece ebdbdbeece
20 aabbbaaabaaabaaaabbbbabbbbabbbabbbbbabbaaaababbbaababbbaababaaaabbaaabbaabbbabaaabbabbaaabbaaaaaaaba -> aabbbbaaabbabbbaabba

kurallar

• Girişin yalnızca boş olmayan küçük harfli bir dize ve dizenin uzunluğundan büyük olmayan pozitif bir tamsayı olacağını varsayabilirsiniz.
• Girişleri herhangi bir standart formatta ve her iki sırada da alabilirsiniz.
• Tek bir dize veya bir dizi biçiminde, yeni satırlarla veya boşluklarla vb. Ayırarak birden fazla çıktı aktarabilirsiniz.
• Oldukça modern bir bilgisayarda her sınama için kodunuz 1 dakikadan daha az bir sürede bitmelidir.
• Bu kod golf , kodunuzu mümkün olduğunca kısa tutun.

Jöle , 11 bayt

sZµṢŒrUṀṪµ€

Çevrimiçi deneyin!

Bu konuda Dennis'i yenmeyi beklemiyordum, bu yüzden FGITW'yi denemeye çalıştım (birkaç olasılık denedikten sonra, 11 yapmanın birden fazla yolu var). Sürprizime kısaca kısaldım.

Dizeyi daha sonra komut satırı argümanları olarak say. Stdout'ta çıktılar.

açıklama

sZµṢŒrUṀṪµ€
s            Split {the first input} into {the second input}-sized groups
 Z           Transpose
  µ      µ€  On each of the transposed groups:
   Ṣ           Sort it;
    Œr         Run-length encode it;
      U        Rearrange it to the form {count, letter};
       Ṁ       Take the largest element (i.e. largest count)
        Ṫ      Take the second element of the pair (i.e. just the letter)

Bu, desenin her pozisyonundaki harfin, o pozisyona karşılık gelen en yaygın harf olması gerektiği görüşünü kullanır. Belirli bir desene karşılık gelen harfleri, desen büyüklüğünde gruplara ayırarak ve transposing yoluyla bulabiliriz. Bu çözümün bu kadar uzun olmasının ana nedeni, Jelly'in bir listenin modunu bulmak için kısa bir yolunun görünmemesi (birkaç denemede bulundum, ancak hepsi en az altı bayt uzunluğunda).

Jelly , @Dennis çözeltisine dayanan 10 byte

⁸ċ$ÞṪ
sZÇ€

Çevrimiçi deneyin!

Bu @Dennis'in çözümü ile kendimin bir birleşimidir; Bu çözümde beş baytlık bir mod vardı ve bu çözüm için çaldım. (Ben zaten dayalı çözümler vardı ⁸ċ, ancak onunla altı bayt altına alamadım; kullanmayı düşünmemiştim Þ.)

açıklama

µ…µ€ve Ç€( …önceki satırda) ikisi de bayt uzunluğundadır (ikincisi yeni bir satıra ihtiyaç duyar) ve eşdeğeridir. Normalde eskiyi kullanıyorum, ancak ikincisi daha esnektir, çünkü ⁸tartışmayı belirtmek için kullanmanıza izin verir .

Bu sayede (sıralamak için yapar Þiçinde oluş sayısına göre) ⁸( ⁸ċ(son öğe almak, sonra) Ṫsadece beş karakterden modunda bulmak için).

Mathematica, 51 bayt

#&@@@Commonest/@(PadRight@Partition[#2,UpTo@#])&

Giriş ve çıkış karakterlerin listesidir.

Ayrıca devrik çizgilerin modlarını da temel alır. Ben Commonest sadece kod golfçüler spite bir liste modu için yerleşik çağırdı inanıyorum .

Python 3, 99, 73 61 bayt

-12, thx ila @Rod

lambda s,n:''.join(max(s,key=s[i::n].count)for i in range(n))

Aynı fikir, ancak import deyimini ortadan kaldırmak için yeniden yazdı.

lambda s,n:''.join(max(s,key=lambda c:s[i::n].count(c))for i in range(n))

orijinal

from collections import*
lambda s,n:''.join(Counter(s[i::n]).most_common(1)[0][0]for i in range(n))

Açıklama:

s[i::n]                  a slice of every nth character of s, starting at position i

Counter(s[i::n])         counts the characters in the slice
  .most_common()         returns a list of (character, count) pairs, sorted by decreasing count
    [0][0]               grabs the letter from the first pair (i.e., the most common letter
      for i in range(n)  repeat for all starting positions

''.join                  combines the most common letters into a single string

Python 2, 106

Şimdi farklı bir cevap! Başlangıçtan bir (neredeyse) -liner düşünüyorum. Artık @Rod tarafından zip kullanımına bağlı olarak daha da kısa.

@ L3viathan ve @Rod'a lambdas'ın cevap olarak kullanımıyla ilgili açıklama için teşekkür ederiz.

Çevrimiçi deneyin

lambda S,N:max(combinations(S,N),key=lambda s:sum(x==y for x,y in zip(S,s*len(S))))
from itertools import*

Açıklama:

combinations(S,N) S karakterinden tüm kombinasyon uzunluklarını N oluşturur

max()keyelemanları karşılaştırmak için girdi işlevi olarak kullanılan argümanlara sahip olur.

lambda s:sum(x==y for x,y in zip(S,s*len(S))) böyle bir işlev olarak geçti

Bu lambda tuples listesindeki eşleşen karakter sayısını sayar, zip(S,s*len(S))

s- kombinasyonlardan biri ve len(S)S’den daha uzun garantili olan bir dize oluşturan

zipHer dize karakter tuples oluşturur Sve s*len(S)eşleştirilemeyen tüm karakterleri yok sayar (bir dize diğerinden daha uzunsa)

Bu yüzden maxmaksimum toplamı üreten kombinasyonu seçer

JavaScript (ES6), 104 101 94 bayt

(n,s)=>s.replace(/./g,(_,i)=>[...s].map((c,j,a)=>j%n-i||(a[c]=-~a[c])>m&&(m++,r=c),m=r=``)&&r)

@Arnauld sayesinde 3 byte iki kez kaydedildi. Tüm newline olmayan karakterlerle çalışan 97 baytlık çözüm:

(n,s)=>s.replace(/./g,(_,i)=>[...s].map((c,j)=>j%n-i||(o[c]=-~o[c])>m&&(m++,r=c),m=r=``,o={})&&r)

Önceki 104 baytlık çözüm de yeni satır karakterleriyle çalışıyor:

(n,s)=>[...Array(n)].map((_,i)=>[...s].map((c,j)=>j%n-i||(o[c]=-~o[c])>m&&(m++,r=c),m=0,o={})&&r).join``

Jöle , 12 11 bayt

s@ZċþZMḢ$€ị

Çevrimiçi deneyin!

Nasıl çalışır

s@ZċþZMḢ$€ị  Main link. Arguments: n (integer), s (string)

s@           Split swapped; split s into chunks of length n.
  Z          Zip/transpose, grouping characters that correspond to repetitions.
   ċþ        Count table; for each slice in the previous result, and each character
             in s, count the occurrences of the character in the group.
             This groups by character.
     Z       Zip/transpose to group by slice.
        $€   Map the two-link chain to the left over the groups.
      M        Find all maximal indices.
       Ḣ       Head; pick the first.
          ị  Index into s to retrieve the corresponding characters.

Pyth, 11 bayt

meo/dNd.TcF

Giriş olarak alır s,nve karakter listesi olarak çıkar.

açıklama

meo/dNd.TcF
         cFQ   Split s into chunks of length n.
       .T      Transpose.
m o/dNd        Sort characters in each string by frequency.
 e             Take the most common.

Japt , 16 15 bayt

@Obarakon sayesinde 1 bayt kaydedildi

Ç=VëUZ)¬ñ!èZ o

-PBayrak için 14 bayt kod + 1 bayt . Çevrimiçi deneyin!

Ungolfed ve açıklama

 Ç   =VëUZ)¬ ñ!èZ o
UoZ{Z=VëUZ)q ñ!èZ o}
                          Implicit: U = input number, V = input string
Uo                        Create the range [0...U).
  Z{               }      Map each item Z by this function:
      VëUZ                  Take every U'th char of V, starting at index Z.
    Z=    )                 Call the result Z.
           q                Split the result into chars.
             ñ!èZ           Sort each char X by the number of occurrences of X in Z.
                  o         Pop; grab the last item (the most common char).
                      -P  Join the results (array of most common chars) into a string.

Python 2,132 bayt

from itertools import*
p,k=input()
b=l=len(p)
for i in combinations(p,k):
 x=sum(x!=y for x,y in zip(p,i*l))
 if x<b:b,o=x,i
print o

Çevrimiçi deneyin!

05AB1E , 17 bayt

Iôð«øvy{.¡é®èÙJðÜ

Çevrimiçi deneyin!

açıklama

Iô                 # split 2nd input in chunks of 1st input size
  ð«               # append a space to each
    ø              # zip
     vy            # for each y in the zipped list
       {           # sort the string
        .¡         # group into chunks of consecutive equal elements
          é        # sort by length
           ®è      # pop the last element (the longest)
             Ù     # remove duplicate characters from the string
              J    # join the stack into one string
               ðÜ  # remove any trailing spaces

PHP, 245 Bayt

function p($c,$s,$r=""){global$a;if(($c-strlen($r)))foreach(str_split(count_chars($s,3))as$l)p($c,$s,$r.$l);else{for($v=str_pad("",$w=strlen($s),$r);$z<$w;)$t+=$v[$z]==$s[$z++];$a[$t][]=$r;}}p($argv[1],$argv[2]);ksort($a);echo join(" ",end($a));

Çevrimiçi sürüm

Yıkmak

function p($c,$s,$r=""){
    global$a;
    if(($c-strlen($r)))  # make permutation
        foreach(str_split(count_chars($s,3))as$l)
            p($c,$s,$r.$l); #recursive
    else{
        for($v=str_pad("",$w=strlen($s),$r);$z<$w;) 
        $t+=$v[$z]==$s[$z++]; #compare strings
        $a[$t][]=$r; # insert value in array
    }
}
p($argv[1],$argv[2]); #start function with the input parameter
ksort($a); # sort result array 
echo join(" ",end($a)); #Output

Haskell, 84 bayt

import Data.Lists
f n=map(argmax=<<(length.).flip(filter.(==))).transpose.chunksOf n

Kullanım örneği:

f 10 "bbbbacacbcedecdbbbdebdaedcecdabcebddbdcecebbeeaacdebdbebaebcecddadeeedbbdbbaeaaeebbedbeeaeedadeecbcd"
"ebbbdbeece"

Giriş dizgisini uzunluğa nayırın, en sık kullanılan her bir alt liste için transpoze ve ffind.

Röda , 68 bayt

f s,n{seq 0,n-1|{|i|sort s/"",key={|c|x=s[i::n]x~=c,"";[#x]}|head}_}

Çevrimiçi deneyin!

Çıktıyı newline izlemeden basan bir fonksiyondur.

Bu, bu cevaptan ilham aldı .