22

एक डी ब्रूजन अनुक्रम दिलचस्प है: यह सबसे छोटा, चक्रीय अनुक्रम है जिसमें किसी दिए गए लंबाई के दिए गए वर्णमाला के सभी संभावित अनुक्रम शामिल हैं। उदाहरण के लिए, यदि हम वर्णमाला A, B, C और 3 की लंबाई पर विचार कर रहे हैं, तो एक संभावित आउटपुट है:

AAABBBCCCABCACCBBAACBCBABAC

आपको लगता है कि अक्षरों का प्रयोग कर हर संभव 3-चरित्र अनुक्रम देखेंगे A, Bऔर Cवहाँ में हैं।

आपकी चुनौती संभव के रूप में कुछ पात्रों में एक डी ब्रुजन अनुक्रम उत्पन्न करना है। आपके फ़ंक्शन को दो पैरामीटर लेने चाहिए, एक पूर्णांक अनुक्रमों की लंबाई का प्रतिनिधित्व करता है, और एक सूची जिसमें वर्णमाला होती है। आपका आउटपुट सूची रूप में अनुक्रम होना चाहिए।

आप मान सकते हैं कि वर्णमाला की प्रत्येक वस्तु अलग है।

एक उदाहरण जनरेटर यहां पाया जा सकता है

मानक खामियां लागू होती हैं

code-golf combinatorics

— नाथन मेरिल
स्रोत

क्या अनुक्रमों की लंबाई का प्रतिनिधित्व करने वाला पूर्णांक अद्वितीय अक्षरों की संख्या से बड़ा हो सकता है?

— kukac67

हाँ। लंबाई 4 का एक द्विआधारी अनुक्रम 0000111101100101 होगा

— नाथन मेरिल

"आपकी चुनौती के रूप में संभव के रूप में कुछ वर्णों में एक डे ब्रूजन अनुक्रम उत्पन्न करने के लिए है" - क्या इसका मतलब है "कोड गोल्फ" या "सबसे कम संभव डी ब्रूजन अनुक्रम लंबाई प्राप्त करें"?

— फ्राईमईएग्गमैन

2

दोनों। अर्हता प्राप्त करने के लिए, आपके कार्यक्रम को सबसे कम अनुक्रम का उत्पादन करना चाहिए, लेकिन जीतने के लिए, आपका कार्यक्रम सबसे छोटा होना चाहिए।

— नाथन मेरिल

2

@xem: आमतौर पर डी ब्रूजन दृश्यों में रैपराउंड शामिल होता है, जो कि उन लापता दृश्यों को प्रदर्शित करता है।

— कीथ रान्डेल

6

पायथ, 31 बाइट्स

यह मेरे CJam उत्तर में उपयोग किए गए एल्गोरिथ्म का प्रत्यक्ष रूपांतरण है । गोल्फ स्वागत के लिए युक्तियाँ!

Mu?G}H+GG+G>Hefq<HT>G-lGTUH^GHk

यह कोड एक फ़ंक्शन को परिभाषित करता है gजो दो तर्क लेता है, पात्रों की सूची की संख्या और संख्या।

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

Mu?G}H+GG+G>Hefq<HT>G-lGTUH^GHkg"ABC"3

आउटपुट:

AAABAACABBABCACBACCBBBCBCCC

कोड विस्तार:

M                 # def g(G,H):
 u                #   return reduce(lambda G, H:
  ?G              #     (G if
    }H            #       (H in
      +GG         #          add(G,G)) else
    +G            #       add(G,
      >H          #         slice_end(H,
        e         #           last_element(
         f        #             Pfilter(lambda T:
          q       #               equal(
           <HT    #                 slice_start(H,T),
           >G     #                 slice_end(G,
             -lGT #                   minus(Plen(G),T))),
          UH      #               urange(H)))))),
  ^GH             #     cartesian_product(G,H),
  k               #     "")

इसे यहाँ आज़माएँ

— अनुकूलक
स्रोत

4

CJam, 52 49 48 बाइट्स

यह आश्चर्यजनक रूप से लंबा है। पायथ अनुवाद से युक्तियों में यह एक बहुत कुछ हासिल किया जा सकता है।

q~a*{m*:s}*{:H\:G_+\#)GGHH,,{_H<G,@-G>=},W=>+?}*

इनपुट पसंद आता है

3 "ABC"

यानी - पात्रों की सूची और लंबाई का स्ट्रिंग।

और आउटपुट डी ब्रूजन स्ट्रिंग है

AAABAACABBABCACBACCBBBCBCCC

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

1

गोश सीजेम पर प्रतिबंध लगाया जाना चाहिए, यह सिर्फ एक गोल्फिंग कार्य के लिए नहीं बनाया गया है, बल्कि यह हर संभव गोल्फिंग कार्य के लिए लगता है ...

— दोष

2

@flawr आपको एक पाइथ जवाब के लिए इंतजार करना चाहिए: P

— ऑप्टिमाइज़र

3

CJam, 52 49 बाइट्स

यहाँ CJam में एक अलग दृष्टिकोण है:

l~:N;:L,(:Ma{_N*N<0{;)_!}g(+_0a=!}g]{,N\%!},:~Lf=

इस तरह इनपुट लेता है:

"ABC" 3

और लाइंडन जैसा काम करता है

CCCBCCACBBCBACABCAABBBABAAA

इसे यहाँ आज़माएँ।

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

गोल्फिंग कारणों से, मैं बाद के अक्षरों को वर्णमाला के निचले क्रम का क्रम मानता हूं।

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

1

जावास्क्रिप्ट (ईएस 6) 143

मार्टिन के aswer की तरह लिंडन शब्दों का प्रयोग, सिर्फ 3 बार लंबा ...

F=(a,n)=>{
  for(w=[-a[l='length']],r='';w[0];)
  {
    n%w[l]||w.map(x=>r+=a[~x]);
    for(;w.push(...w)<=n;);
    for(w[l]=n;!~(z=w.pop()););
    w.push(z+1)
  }
  return r
}

फायरफॉक्स / फायरबग कंसोल में टेस्ट

console.log(F("ABC",3),F("10",4))

उत्पादन

CCCBCCACBBCBACABCAABBBABAAA 0000100110101111

— edc65
स्रोत

1

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

मुझे वास्तव में यकीन नहीं है कि मेरे दृष्टिकोण के कारण इसे और अधिक कैसे गोल किया जाए।

def f(a,n):
 s=a[-1]*n
 while 1:
    for c in a:
     if((s+c)[len(s+c)-n:]in s)<1:s+=c;break
    else:break
 print s[:1-n]

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

Ungolfed:

यह कोड मेरे समाधान से हाल ही की चुनौती के लिए एक मामूली संशोधन है ।

def f(a,n):
    s=a[-1]*n
    while 1:
        for c in a:
            p=s+c
            if p[len(p)-n:]in s:
                continue
            else:
                s=p
                break
        else:
            break
    print s[:1-n]

केवल कारण [:1-n]की आवश्यकता है क्योंकि अनुक्रम में रैप-अराउंड शामिल है।

— mbomb007
स्रोत

1

पॉवर्सशेल, 164 96 बाइट्स

-68 बाइट्स के साथ-साथ O($n*2^n)पुनरावर्ती जनरेटर के बजाय -चैचO(n*log(n))

param($s,$n)for(;$z=$s|% t*y|?{"$($s[-1])"*($n-1)+$x-notmatch-join"$x$_"[-$n..-1]}){$x+=$z[0]}$x

अनगुल्ड और परीक्षण स्क्रिप्ट:

$f = {

param($s,$n)                    # $s is a alphabet, $n is a subsequence length
for(;                           # repeat until...
    $z=$s|% t*y|?{              # at least a character from the alphabet returns $true for expression:
        "$($s[-1])"*($n-1)+$x-notmatch  # the old sequence that follows two characters (the last letter from the alphabet) not contains
        -join"$x$_"[-$n..-1]    # n last characters from the new sequence
}){
    $x+=$z[0]                   # replace old sequence with new sequence
}
$x                              # return the sequence

}

@(
    ,("ABC",  2, "AABACBBCC")
    ,("ABC",  3, "AAABAACABBABCACBACCBBBCBCCC")
    ,("ABC",  4, "AAAABAAACAABBAABCAACBAACCABABACABBBABBCABCBABCCACACBBACBCACCBACCCBBBBCBBCCBCBCCCC")
    ,("ABC",  5, "AAAAABAAAACAAABBAAABCAAACBAAACCAABABAABACAABBBAABBCAABCBAABCCAACABAACACAACBBAACBCAACCBAACCCABABBABABCABACBABACCABBACABBBBABBBCABBCBABBCCABCACABCBBABCBCABCCBABCCCACACBACACCACBBBACBBCACBCBACBCCACCBBACCBCACCCBACCCCBBBBBCBBBCCBBCBCBBCCCBCBCCBCCCCC")
    ,("ABC",  6, "AAAAAABAAAAACAAAABBAAAABCAAAACBAAAACCAAABABAAABACAAABBBAAABBCAAABCBAAABCCAAACABAAACACAAACBBAAACBCAAACCBAAACCCAABAABAACAABABBAABABCAABACBAABACCAABBABAABBACAABBBBAABBBCAABBCBAABBCCAABCABAABCACAABCBBAABCBCAABCCBAABCCCAACAACABBAACABCAACACBAACACCAACBABAACBACAACBBBAACBBCAACBCBAACBCCAACCABAACCACAACCBBAACCBCAACCCBAACCCCABABABACABABBBABABBCABABCBABABCCABACACABACBBABACBCABACCBABACCCABBABBABCABBACBABBACCABBBACABBBBBABBBBCABBBCBABBBCCABBCACABBCBBABBCBCABBCCBABBCCCABCABCACBABCACCABCBACABCBBBABCBBCABCBCBABCBCCABCCACABCCBBABCCBCABCCCBABCCCCACACACBBACACBCACACCBACACCCACBACBACCACBBBBACBBBCACBBCBACBBCCACBCBBACBCBCACBCCBACBCCCACCACCBBBACCBBCACCBCBACCBCCACCCBBACCCBCACCCCBACCCCCBBBBBBCBBBBCCBBBCBCBBBCCCBBCBBCBCCBBCCBCBBCCCCBCBCBCCCBCCBCCCCCC")
    ,("01",   3, "00010111")
    ,("01",   4, "0000100110101111")
    ,("abcd", 2, "aabacadbbcbdccdd")
    ,("0123456789", 3, "0001002003004005006007008009011012013014015016017018019021022023024025026027028029031032033034035036037038039041042043044045046047048049051052053054055056057058059061062063064065066067068069071072073074075076077078079081082083084085086087088089091092093094095096097098099111211311411511611711811912212312412512612712812913213313413513613713813914214314414514614714814915215315415515615715815916216316416516616716816917217317417517617717817918218318418518618718818919219319419519619719819922232242252262272282292332342352362372382392432442452462472482492532542552562572582592632642652662672682692732742752762772782792832842852862872882892932942952962972982993334335336337338339344345346347348349354355356357358359364365366367368369374375376377378379384385386387388389394395396397398399444544644744844945545645745845946546646746846947547647747847948548648748848949549649749849955565575585595665675685695765775785795865875885895965975985996667668669677678679687688689697698699777877978878979879988898999")
    ,("9876543210", 3, "9998997996995994993992991990988987986985984983982981980978977976975974973972971970968967966965964963962961960958957956955954953952951950948947946945944943942941940938937936935934933932931930928927926925924923922921920918917916915914913912911910908907906905904903902901900888788688588488388288188087787687587487387287187086786686586486386286186085785685585485385285185084784684584484384284184083783683583483383283183082782682582482382282182081781681581481381281181080780680580480380280180077767757747737727717707667657647637627617607567557547537527517507467457447437427417407367357347337327317307267257247237227217207167157147137127117107067057047037027017006665664663662661660655654653652651650645644643642641640635634633632631630625624623622621620615614613612611610605604603602601600555455355255155054454354254154053453353253153052452352252152051451351251151050450350250150044434424414404334324314304234224214204134124114104034024014003332331330322321320312311310302301300222122021121020120011101000")
) |% {
    $s,$n,$e = $_
    $r = &$f $s $n
    "$($r-eq$e): $r"
}