33

दिए गए एक स्ट्रिंग एस के निचले अक्षरों से बना है, जैसे कि

aabaaababbbbaaba

और एक धनात्मक पूर्णांक n , जैसे कि 4, एक लंबाई- n स्ट्रिंग t जैसे कि जब t को s की लंबाई में दोहराया जाता है , तो उनके पास संभव के रूप में कई चार्ट होते हैं। दिए गए उदाहरण के लिए, इष्टतम उत्पादन होगा aaba, क्योंकि इसमें लक्ष्य स्ट्रिंग के साथ सामान्य रूप से तेरह वर्ण हैं:

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

और कोई भी संभावित टी अधिक नहीं है। हालाँकि, aaaaaabदो संभावित आउटपुट हैं: aaaaऔर aaba, जिनमें से प्रत्येक में लक्ष्य स्ट्रिंग के साथ 6 वर्ण हैं:

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

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

या तो aaaaया aabaआउटपुट किया जा सकता है, या यदि आप चाहें तो दोनों। ध्यान दें कि एस कभी दोहराया नहीं जाता है; टी केa दोनों दोहराया मूल्यों में अनुगामी बस की अनदेखी की है।

परीक्षण के मामलों

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 मिनट से कम समय में समाप्त होना चाहिए।
यह कोड-गोल्फ है , इसलिए अपने कोड को यथासंभव छोटा बनाएं।

code-golf string

— ETHproductions
स्रोत

2

यह चुनौती है ज़गारब-गुणवत्ता। अच्छा काम!

— मार्टिन एंडर

मैं मान रहा हूँ कि केवल अनुगामी पात्रों को अनदेखा किया गया है? इसलिए आपको इस तरह के प्रमुख पात्रों को अनदेखा करने की अनुमति नहीं है: 2 abb -> baजहां इसे बनाया गया है (b)[ab]a: अग्रणी (b)को अनदेखा किया जाता है, [ab]मिलान कर रहे हैं।

— केविन क्रूज़सेन

@ केविनक्रूजसेन राइट, पैटर्न को शुरुआत में दोहराना होगा।

— ETHproductions

11

जेली , 11 बाइट्स

sZµṢŒrUṀṪµ€

इसे ऑनलाइन आज़माएं!

इस पर डेनिस को हराने की उम्मीद नहीं थी, इसलिए इसे FGITW करने की कोशिश की (कई संभावनाओं को आजमाने के बाद; 11 बनाने का एक से अधिक तरीका है)। मैं अपने आश्चर्य से बहुत कम आया था।

स्ट्रिंग को तब कमांड-लाइन तर्क के रूप में गिनता है। स्टडआउट पर आउटपुट।

व्याख्या

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)

यह इस अंतर्दृष्टि का उपयोग करता है कि पैटर्न की प्रत्येक स्थिति का अक्षर उस स्थिति के अनुरूप सबसे सामान्य अक्षर होना चाहिए। हम पैटर्न-आकार के समूहों में विभाजित करके और ट्रांसपोज़िंग के माध्यम से एक विशेष पैटर्न के अनुरूप अक्षरों को पा सकते हैं। इस समाधान का मुख्य कारण इतना लंबा है कि जेली को एक सूची का मोड खोजने के लिए एक छोटा रास्ता नहीं लगता है (मैंने कई प्रयास किए, लेकिन वे सभी कम से कम छह बाइट्स लंबे हैं)।

जेली , 10 बाइट्स, @ डेनिस के समाधान पर आधारित है

⁸ċ$ÞṪ
sZÇ€

इसे ऑनलाइन आज़माएं!

यह @ डेनिस के समाधान और मेरे अपने का एक संयोजन है; उस समाधान में एक पांच-बाइट मोड था, जिसे मैंने इस समाधान के लिए चुरा लिया था। (मेरे पास पहले से ही समाधान आधारित था ⁸ċ, लेकिन इसके साथ छह बाइट्स से नीचे नहीं जा सकता था; मैंने उपयोग करने के बारे में नहीं सोचा था Þ।)

व्याख्या

µ…µ€और Ç€( …पिछली पंक्ति के साथ) दोनों तीन बाइट्स लंबी हैं (बाद वाली को एक नई रेखा की आवश्यकता है), और समकक्ष। आम तौर पर मैं पूर्व का उपयोग करता हूं, लेकिन बाद का अधिक लचीला है, क्योंकि यह आपको ⁸तर्क का उल्लेख करने के लिए उपयोग करने की अनुमति देता है।

यह यह संभव (सॉर्ट करने के लिए बनाता है Þ) में घटनाओं की संख्या से ⁸( ⁸ċ), तो पिछले तत्व ले ( Ṫ), सिर्फ पांच अक्षरों में मोड खोजने के लिए।

5

डेनिस अपनी ही भाषा के साथ अच्छा काम करता है! : पी

— हाइपरनेट्रिनो

10

गणितज्ञ, 51 बाइट्स

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

इनपुट और आउटपुट पात्रों की सूची है।

ट्रांज़ोज़ की लाइनों के मोड के आधार पर भी। मेरा मानना है कि वे कोड गोल्फरों के बावजूद Commonest पूरी तरह से एक सूची के मोड के लिए अंतर्निहित कहते हैं ।

— मार्टिन एंडर
स्रोत

कम से कम यह एक बाइट से कम है MostCommon...

— ETHproductions

7

पायथन 3, 99, 73 61 बाइट्स

-12, thx से @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

— RootTwo
स्रोत

आप python2.7 पर स्विच कर सकते हैं और ''.join()स्ट्रिंग्स की एक सूची वापस करने के लिए ड्रॉप कर सकते हैं

— रॉड

@Rod ड्रोपिंग ''.join(...)इसे जेनरेटर लौटा देगा, निश्चित नहीं कि अगर यह आउटपुट की अनुमति है।

— L3viathan

@ L3viathan को काम करने के लिए python2.7 होना आवश्यक है, अन्य टिप्पणी में जोड़ा गया

— Rod

क्या आप कुछ स्पष्टीकरण लिख सकते हैं कि यह कैसे काम करता है?

— मृत पोस्सम

2

@Rod स्ट्रिंग की एक सूची केवल इस सवाल के लिए अनुमति दी जाती है कि क्या आप सभी संभव समाधान लौटाते हैं। यही मैंने इसका मतलब निकाला।

— mbomb007

5

अजगर 2, 106

अब इसका अलग जवाब है! मैं एक (लगभग) -कलर के बारे में सोच रहा था। अब और भी छोटा, @Rod द्वारा ज़िप के उपयोग पर आधारित है।

उत्तर के रूप में लंबोदा का उपयोग करने के बारे में स्पष्टीकरण के लिए @ L3viathan और @Rod का धन्यवाद

इसे ऑनलाइन आज़माएं

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) S के वर्णों से सभी संयोजन लंबाई N बनाता है

max()keyतत्वों की तुलना करने के लिए उपयोग करने के लिए इनपुट फ़ंक्शन के रूप में तर्क है

lambda s:sum(x==y for x,y in zip(S,s*len(S))) इस तरह के समारोह के रूप में पारित कर दिया

यह लंबोदर टुपल्स की सूची में मेल खाने वाले पात्रों की संख्या को गिनाता है zip(S,s*len(S))

s- संयोजनों में से एक और यह कई गुणा है len(S)जो स्ट्रिंग बनाता है जो एस की तुलना में लंबे समय तक गारंटी देता है

zipप्रत्येक स्ट्रिंग के पात्रों में से tuples बनाता है Sऔर s*len(S)और (अन्य की तुलना में लंबे समय तक एक स्ट्रिंग के मामले में) सभी वर्णों कि मिलान नहीं किया जा सकता है पर ध्यान नहीं देता

तो maxसंयोजन चुनता है, जो अधिकतम राशि का उत्पादन करता है

— मृत पोसुम
स्रोत

1

आप उपयोग की जरूरत नहीं है [], यह भी आप उपयोग कर रहे कार्यों के अंदर सूची समझ पर 1 for ... if <cond>आप सीधे उपयोग कर सकते हैं <cond> for ...के बाद से उस पर इस्तेमाल किया जाएगा sum, अजगर ले जाएगा Trueके रूप में 1और Falseके रूप में0

— रॉड

@Rod धन्यवाद! अगर मैं अपने उत्तर को और अधिक निचोड़ दूंगा, तो यह आपके उत्तर में बदल जाएगा, दृष्टिकोण समान है: इसलिए मैं अभी कुछ अलग करने की कोशिश कर रहा हूं

— डेड पोसुम

हां, यह कहते हुए कि आप अपने भविष्य के उत्तरों पर उपयोग कर सकते हैं: 3

— रॉड

1

एक लैम्ब्डा पर स्विच करने से 7 बाइट्स बचेंगे।

— 193 में L3viathan

1

@DeadPossum उनका यह मतलब था (पाद लेख और शीर्ष लेख पर ध्यान दें) और हाँ, एक फ़ंक्शन एक मान्य उत्तर है , यदि इसका एक लंबो आपको इसकी आवश्यकता भी नहीं हैf= (जब तक कि यह पुनरावर्ती न हो)

— रॉड

5

जावास्क्रिप्ट (ईएस 6), 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``

— नील
स्रोत

बहुत अच्छा। मैंने परीक्षण के मामलों को जोड़ते समय संदर्भ के लिए एक समाधान तैयार किया और 122 बाइट्स पर आया, हर चार के माध्यम से लूपिंग, वस्तुओं की एक सरणी में मायने रखता है, फिर उस सरणी से स्ट्रिंग का निर्माण किया।

— ETHproductions

oएक नई वस्तु को शुरू करने के बजाय , क्या आप केवल mapइसके 3 पैरामीटर का उपयोग करके पारित सरणी का पुन: उपयोग कर सकते हैं ?

— अरनौलद

@Arnauld हम्म, मुझे लगता है कि काम करता है क्योंकि सवाल लोअरकेस अक्षरों की गारंटी देता है, इसलिए मैं गिनती के साथ सरणी तत्वों को भ्रमित नहीं करूंगा ...

— नील

मुझे लगता है कि (n,s)=>s.replace(/./g,(_,i)=>i<n?[...s].map((c,j,a)=>j%n-i||(a[c]=-~a[c])>m&&(m++,r=c),m=0)&&r:'')3 और बाइट्स बचाना चाहिए। (Currying सिंटेक्स के उपयोग से या 4 बाइट।)

— Arnauld

@Arnauld बुरा नहीं है, लेकिन मैंने एक और दो बाइट्स काट दीं। (और मेरी बाइट की गिनती भी तय की; एक अनुगामी न्यूलाइन उन्हें फेंक रही थी।)

— नील

3

जेली , 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.

— डेनिस
स्रोत

क्या जेली की टिप्पणी है?

— caird coinheringaahing

नहीं, यह नहीं है।

— डेनिस

2

अजगर, 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.

2

जाप , 16 15 बाइट्स

@ ब्योराकोन को 1 बाइट धन्यवाद दिया

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

-Pध्वज के लिए कोड + 1 बाइट के 14 बाइट्स । इसे ऑनलाइन आज़माएं!

अपुष्ट और व्याख्या

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

— ETHproductions
स्रोत

मुझे लगता है कि आप की जगह ले सकता gJसाथo

— ओलिवर

@obarakon यह प्रतिभाशाली है, धन्यवाद!

— ETHproductions

1

पायथन 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

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

1

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

— Emigna
स्रोत

1

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

— जार्ग हुल्सरमन
स्रोत

1

हास्केल, 84 बाइट्स

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

उपयोग उदाहरण:

f 10 "bbbbacacbcedecdbbbdebdaedcecdabcebddbdcecebbeeaacdebdbebaebcecddadeeedbbdbbaeaaeebbedbeeaeedadeecbcd"
"ebbbdbeece"

विभाजन की स्ट्रिंग में इनपुट स्ट्रिंग को विभाजित करें n, प्रत्येक बार-बार होने वाले तत्व के लिए स्थानांतरित करें और फ़िफ़िश करें।

— nimi
स्रोत

1

रोदा , 68 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह एक ऐसा फंक्शन है जो न्यूलाइन को पीछे किए बिना आउटपुट प्रिंट करता है।

यह इस उत्तर से प्रेरित था ।

— fergusq
स्रोत

इष्टतम पैटर्न का पता लगाएं

परीक्षण के मामलों

नियम

जेली , 11 बाइट्स

व्याख्या

जेली , 10 बाइट्स, @ डेनिस के समाधान पर आधारित है

व्याख्या

गणितज्ञ, 51 बाइट्स

पायथन 3, 99, 73 61 बाइट्स

अजगर 2, 106

जावास्क्रिप्ट (ईएस 6), 104 101 94 बाइट्स

जेली , 12 11 बाइट्स

यह काम किस प्रकार करता है

अजगर, 11 बाइट्स

व्याख्या

जाप , 16 15 बाइट्स

अपुष्ट और व्याख्या

पायथन 2 , 132 बाइट्स

05AB1E , 17 बाइट्स

PHP, 245 बाइट्स

टूट - फूट

हास्केल, 84 बाइट्स

रोदा , 68 बाइट्स