Bei einem String s aus Kleinbuchstaben bestehen, wie zum Beispiel

aabaaababbbbaaba

und eine positive ganze Zahl n , wie der 4Ausgang A längen- n Zeichenfolge t , dass , wenn t auf die Länge der wiederholt s , sie haben so viele Zeichen wie möglich gemeinsam. Für das gegebene Beispiel wäre die optimale Ausgabe aaba, da es dreizehn Zeichen gemeinsam mit der Zielzeichenfolge hat:

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

und kein mögliches t hat mehr. Es aaaaaabgibt jedoch zwei mögliche Ausgaben: aaaaund aaba, die jeweils 6 Zeichen gemeinsam mit der Zielzeichenfolge haben:

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

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

Entweder aaaaoder aabakann ausgegeben werden, oder beides, wenn Sie möchten. Beachten Sie, dass s nie wiederholt wird. Das Nachlaufen abeider Wiederholungswerte von t wird einfach ignoriert.

Testfälle

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

Regeln

• Sie können davon ausgehen, dass die Eingabe immer nur eine nicht leere Zeichenfolge aus Kleinbuchstaben und eine positive Ganzzahl ist, die nicht länger als die Zeichenfolge ist.
• Sie können die Eingaben in jedem Standardformat und in jeder Reihenfolge vornehmen.
• Sie können eine einzelne Zeichenfolge oder mehrere Zeichenfolgen in Form eines Arrays ausgeben, die durch Zeilenumbrüche, Leerzeichen usw. getrennt sind.
• Auf einem modernen Computer muss Ihr Code für jeden Testfall in weniger als 1 Minute fertig sein.
• Das ist Code-Golf , also mach deinen Code so kurz wie möglich.

Jelly , 11 Bytes

sZµṢŒrUṀṪµ€

Probieren Sie es online!

Ich hatte nicht damit gerechnet, Dennis in diesem Spiel zu schlagen, also habe ich versucht, es mit FGITW zu versuchen (nachdem ich mehrere Möglichkeiten ausprobiert hatte; es gibt mehr als einen Weg, 11 zu machen). Ich kam zu meiner Überraschung kürzer herein.

Übernimmt die Zeichenfolge dann die Zählung als Kommandozeilenargumente. Ausgänge auf Standardausgang.

Erläuterung

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)

Dies basiert auf der Erkenntnis, dass der Buchstabe an jeder Position des Musters der häufigste Buchstabe sein muss, der dieser Position entspricht. Wir können die Buchstaben finden, die einem bestimmten Muster entsprechen, indem wir sie in mustergroße Gruppen aufteilen und transponieren. Der Hauptgrund, warum diese Lösung so lang ist, besteht darin, dass Jelly anscheinend keinen kurzen Weg hat, um den Modus einer Liste zu finden (ich habe mehrere Versuche unternommen, aber sie sind alle mindestens sechs Bytes lang).

Jelly , 10 Bytes, basierend auf der @ Tennis-Lösung

⁸ċ$ÞṪ
sZÇ€

Probieren Sie es online!

Dies ist eine Kombination aus @Dennis 'und meiner eigenen Lösung. In dieser Lösung gab es einen Fünf-Byte-Modus, den ich für diese Lösung gestohlen habe. (Ich hatte bereits Lösungen basierend auf ⁸ċ, konnte aber nicht unter sechs Bytes damit kommen. Ich hatte nicht daran gedacht, sie zu verwenden Þ.)

Erläuterung

µ…µ€und Ç€(mit der …in der vorherigen Zeile) sind beide drei Bytes lang (die letztere benötigt eine neue Zeile) und äquivalent. Normalerweise verwende ich das erstere, aber das letztere ist flexibler, da Sie damit ⁸das Argument erwähnen können.

Dies ermöglicht es, ( Þ) nach der Anzahl der Vorkommen in ⁸( ⁸ċ) zu sortieren und dann das letzte Element ( Ṫ) zu nehmen, um den Modus in nur fünf Zeichen zu finden.

Mathematica, 51 Bytes

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

Eingabe und Ausgabe sind Listen von Zeichen.

Auch basierend auf den Modi der Linien der Transponierung. Ich glaube, sie nannten das eingebaute Programm für den Modus einer Liste Commonest nur, um Code-Golfern zu trotzen.

Python 3, 99, 73, 61 Bytes

-12, danke an @Rod

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

Dieselbe Idee, aber umgeschrieben, um die Importanweisung zu entfernen.

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

Original

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

Erläuterung:

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

Jetzt ist es eine andere Antwort! Ich habe von Anfang an an einen (fast) Liner gedacht. Jetzt noch kürzer, basierend auf der Zip-Nutzung von @Rod.

Vielen Dank an @ L3viathan und @Rod für die Erläuterung der Verwendung von Lambdas als Antwort

Probieren Sie es online aus

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*

Erläuterung:

combinations(S,N) Erzeugt alle Kombinationen der Länge N aus den Zeichen von S

max()Argument, keydas als Eingabefunktion zum Vergleichen von Elementen verwendet wird

lambda s:sum(x==y for x,y in zip(S,s*len(S))) als solche Funktion übergeben

Dieses Lambda zählt die Anzahl der übereinstimmenden Zeichen in der Liste der Tupel, die von erzeugt werden zip(S,s*len(S))

s- eine der Kombinationen und es wird multipliziert, len(S)wodurch eine Saite entsteht, die garantiert länger als S ist

zipErstellt Tupel von Zeichen jeder Zeichenfolge Sund s*len(S)ignoriert alle Zeichen, die nicht übereinstimmen können (falls eine Zeichenfolge länger als eine andere ist).

Also maxwählt man eine Kombination, die maximale Summe ergibt

JavaScript (ES6), 104 101 94 Byte

(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)

Dank @Arnauld wurden zweimal 3 Bytes gespeichert. 97-Byte-Lösung, die mit allen Nicht-Newline-Zeichen funktioniert:

(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)

Die vorherige 104-Byte-Lösung funktioniert auch mit Zeilenumbrüchen:

(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``

Jelly , 12 11 Bytes

s@ZċþZMḢ$€ị

Probieren Sie es online!

Wie es funktioniert

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 Bytes

meo/dNd.TcF

Nimmt Eingaben als s,nund Ausgaben als Liste von Zeichen.

Erläuterung

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 Bytes

1 Byte dank @obarakon gespeichert

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

14 Byte Code + 1 Byte für das -PFlag. Probieren Sie es online!

Ungolfed und Erklärung

 Ç   =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 Bytes

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

Probieren Sie es online!

05AB1E , 17 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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));

Online Version

Nervenzusammenbruch

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 Bytes

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

Anwendungsbeispiel:

f 10 "bbbbacacbcedecdbbbdebdaedcecdabcebddbdcecebbeeaacdebdbebaebcecddadeeedbbdbbaeaaeebbedbeeaeedadeecbcd"
"ebbbdbeece"

nTeilen Sie die Eingabezeichenfolge in Abschnitte mit einer Länge auf , transponieren Sie und finden Sie für jede Unterliste das häufigste Element.

Röda , 68 Bytes

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

Probieren Sie es online!

Diese Funktion druckt die Ausgabe ohne Zeilenumbruch.

Dies wurde durch diese Antwort inspiriert .