รับสายsประกอบด้วยตัวอักษรตัวพิมพ์เล็กเช่น

aabaaababbbbaaba

และเป็นจำนวนเต็มบวกnเช่น4, เอาท์พุท length- nสตริงทีดังกล่าวว่าเมื่อเสื้อซ้ำแล้วซ้ำอีกกับความยาวของsพวกเขามีตัวอักษรเป็นจำนวนมากในการร่วมกันเป็นไปได้ สำหรับตัวอย่างที่กำหนดเอาต์พุตที่ดีที่สุดจะเป็นaabaเพราะมีสิบสามตัวอักษรร่วมกันกับสตริงเป้าหมาย:

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

และไม่มีความเป็นไปได้ทีมีมากขึ้น อย่างไรก็ตามaaaaaabมีสองเอาต์พุตที่เป็นไปได้: aaaaและaabaแต่ละรายการมี 6 ตัวอักษรร่วมกันกับสตริงเป้าหมาย:

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

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

อย่างใดอย่างหนึ่งaaaaหรือaabaสามารถเอาท์พุทหรือทั้งสองอย่างถ้าคุณต้องการ โปรดทราบว่าsจะไม่เคยซ้ำ; การลากaในค่าทั้งสองซ้ำของtจะถูกละเว้น

กรณีทดสอบ

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

กฎระเบียบ

• คุณอาจคิดว่าการป้อนข้อมูลจะเป็นสตริงที่ไม่ว่างเปล่าของตัวอักษรตัวเล็กและจำนวนเต็มบวกไม่เกินความยาวของสตริง
• คุณสามารถรับอินพุตในรูปแบบมาตรฐานและในลำดับใดก็ได้
• คุณสามารถส่งออกสายเดียวหรือมากกว่าหนึ่งในรูปแบบของอาร์เรย์คั่นด้วยการขึ้นบรรทัดใหม่หรือช่องว่าง ฯลฯ
• รหัสของคุณจะต้องเสร็จสิ้นในแต่ละกรณีทดสอบในเวลาน้อยกว่า 1 นาทีในคอมพิวเตอร์ที่ทันสมัยพอสมควร
• นี่คือรหัสกอล์ฟดังนั้นให้เขียนรหัสของคุณให้สั้นที่สุด

เยลลี่ 11 ไบต์

sZµṢŒrUṀṪµ€

ลองออนไลน์!

ไม่ได้คาดหวังว่าจะเอาชนะเดนนิสในเกมนี้ได้ดังนั้นลอง FGITW (หลังจากลองหลาย ๆ วิธี; มีมากกว่าหนึ่งวิธีในการสร้าง 11) ฉันเข้ามาในระยะเวลาอันสั้นทำให้ประหลาดใจมาก

รับสายแล้วนับเป็นอาร์กิวเมนต์บรรทัดคำสั่ง เอาต์พุตเมื่อ stdout

คำอธิบาย

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)

สิ่งนี้ใช้ความเข้าใจที่ว่าจดหมายในแต่ละตำแหน่งของรูปแบบต้องเป็นตัวอักษรทั่วไปที่สอดคล้องกับตำแหน่งนั้นมากที่สุด เราสามารถค้นหาตัวอักษรที่สอดคล้องกับรูปแบบเฉพาะโดยแยกออกเป็นกลุ่มขนาดรูปแบบและการแปลง เหตุผลหลักที่วิธีแก้ปัญหานี้ยาวนานก็คือ Jelly ดูเหมือนจะไม่มีทางลัดในการค้นหาโหมดของรายการ (ฉันพยายามหลายครั้ง แต่พวกมันทั้งหมดยาวอย่างน้อยหกไบต์)

เยลลี่ขนาด 10 ไบต์ขึ้นอยู่กับโซลูชันของ @Dennis

⁸ċ$ÞṪ
sZÇ€

ลองออนไลน์!

นี่คือการรวมกันของวิธีการแก้ปัญหา @Dennis และของฉันเอง; มีโหมดห้าไบต์ในโซลูชันนั้นซึ่งฉันขโมยไปสำหรับวิธีนี้ (ฉันมีวิธีแก้ไขอยู่⁸ċแล้วแต่ไม่สามารถมีขนาดต่ำกว่าหกไบต์ได้ฉันไม่ได้คิดจะใช้Þ)

คำอธิบาย

µ…µ€และÇ€(ด้วย…บนบรรทัดก่อนหน้า) มีความยาวทั้งสามไบต์ (หลังต้องขึ้นบรรทัดใหม่) และเทียบเท่า ปกติฉันจะใช้ตัวแรก แต่ตัวที่สองนั้นจะยืดหยุ่นกว่าเพราะมันช่วยให้คุณ⁸สามารถพูดถึงการโต้เถียงได้

สิ่งนี้ทำให้สามารถเรียงลำดับ ( Þ) ตามจำนวนการเกิดใน⁸( ⁸ċ) จากนั้นใช้องค์ประกอบสุดท้าย ( Ṫ) เพื่อค้นหาโหมดด้วยอักขระห้าตัว

Mathematica, 51 ไบต์

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

อินพุตและเอาต์พุตเป็นรายการของอักขระ

ยังขึ้นอยู่กับโหมดของเส้นของทรานสโพส ฉันเชื่อว่าพวกเขาเรียกตัวในตัวสำหรับโหมดของรายการCommonest เพียงอย่างเดียวถึงแม้ว่านักกอล์ฟรหัส

Python 3, 99, 73 61 ไบต์

-12, ขอบคุณไปยัง @Rod

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

แนวคิดเดียวกัน แต่เขียนใหม่เพื่อกำจัดคำสั่งการนำเข้า

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

เป็นต้นฉบับ

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

คำอธิบาย:

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

ตอนนี้มันเป็นคำตอบที่แตกต่าง! ฉันคิดเกี่ยวกับหนึ่ง (เกือบ) - ผู้กำกับจากการขอร้อง ตอนนี้ยิ่งสั้นลงตามการใช้งาน zip โดย @Rod

ขอบคุณ @ L3viathan และ @Rod สำหรับคำชี้แจงเกี่ยวกับการใช้ lambdas เป็นคำตอบ

ลองออนไลน์

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*

คำอธิบาย:

combinations(S,N) สร้างชุดค่าผสมทั้งหมดความยาว N จากอักขระของ S

max()มีการโต้แย้งkeyซึ่งใช้เป็นฟังก์ชั่นการป้อนข้อมูลเพื่อใช้ในการเปรียบเทียบองค์ประกอบ

lambda s:sum(x==y for x,y in zip(S,s*len(S))) ผ่านเป็นฟังก์ชั่นดังกล่าว

แลมบ์ดานี้นับจำนวนอักขระที่ตรงกันในรายการของ tuples ที่สร้างโดย zip(S,s*len(S))

s- หนึ่งในชุดค่าผสมและมันถูกคูณด้วยlen(S)ซึ่งสร้างสตริงที่รับประกันนานกว่า S

zip สร้าง tuples ของตัวละครของแต่ละสาย Sและs*len(S)ละเว้นอักขระทั้งหมดที่ไม่สามารถจับคู่ได้ (ในกรณีที่มีหนึ่งสตริงยาวกว่าอีกสตริงหนึ่ง)

ดังนั้นmaxเลือกชุดค่าผสมที่ให้ผลรวมสูงสุด

JavaScript (ES6), 104 101 94 ไบต์

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

บันทึก 3 ไบต์สองครั้งด้วย @Arnauld โซลูชัน 97 ไบต์ที่ทำงานกับอักขระที่ไม่ใช่บรรทัดใหม่ทั้งหมด:

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

โซลูชัน 104 ไบต์ก่อนหน้านี้ทำงานร่วมกับอักขระขึ้นบรรทัดใหม่ด้วย:

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

เจลลี่ , 12 11 ไบต์

s@ZċþZMḢ$€ị

ลองออนไลน์!

มันทำงานอย่างไร

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 ไบต์

meo/dNd.TcF

ใช้อินพุตเป็น s,nและเอาต์พุตเป็นรายการของอักขระ

คำอธิบาย

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 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @obarakon

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

โค้ด 14 ไบต์ + 1 ไบต์สำหรับ-Pแฟล็ก ลองออนไลน์!

Ungolfed และคำอธิบาย

 Ç   =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 ไบต์

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

ลองออนไลน์!

05AB1E , 17 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

เวอร์ชั่นออนไลน์

ทำให้พังถล่ม

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 ไบต์

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

ตัวอย่างการใช้งาน:

f 10 "bbbbacacbcedecdbbbdebdaedcecdabcebddbdcecebbeeaacdebdbebaebcecddadeeedbbdbbaeaaeebbedbeeaeedadeecbcd"
"ebbbdbeece"

แยกสตริงอินพุตให้เป็นส่วนหนึ่งของความยาวnแปลงและหาสำหรับแต่ละรายการย่อยองค์ประกอบที่พบบ่อยที่สุด

Röda , 68 ไบต์

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

ลองออนไลน์!

มันเป็นฟังก์ชั่นที่พิมพ์เอาต์พุตโดยไม่ขึ้นบรรทัดใหม่

นี่คือแรงบันดาลใจจากคำตอบนี้