लिनुस अनुक्रम उत्पन्न करें

Question

परिभाषा

OEIS A006345 पर विवरण से :

खोजने के लिए a(n), या तो एक 1या एक पर विचार करें 2। प्रत्येक के लिए, सबसे लंबे समय तक दोहराए जाने वाले प्रत्यय को खोजें, अर्थात, प्रत्येक के लिए a(n)=1,2, sउस गुण के साथ सबसे लंबे अनुक्रम को ढूंढें, जिसके साथ अनुक्रम a(1),...,a(n)समाप्त होता है ss। अंक का उपयोग करें जो इस तरह के छोटे प्रत्यय का परिणाम देता है। a(1) = 1।

वर्क-आउट उदाहरण

a(1)=1।

यदि a(2)=1, हमारे पास वह क्रम होगा 1 1जहां अंत से सबसे लंबे समय तक दोहराए गए विकल्प हैं 1। यदि a(2)=2इसके बजाय, तो यह खाली स्थानापन्न होगा। इसलिए a(2)=2।

जब n=6, हम 1 2 1 1 2 1और के बीच चयन करते हैं 1 2 1 1 2 2। पहली पसंद में, 1 2 1अंत से लगातार दोगुना हो जाता है। दूसरी पसंद में, यह 2इसके बजाय है। इसलिए, a(6)=2।

जब n=9, हम 1 2 1 1 2 2 1 2 1 और के बीच चयन करते हैं 1 2 1 1 2 2 1 2 2। पहली पसंद में, सबसे लंबी दोगुनी लगातार विकल्प है 2 1, जबकि दूसरी पसंद 1 2 2में अंत में लगातार दोगुनी है। इसलिए a(9)=1।

कार्य

दिया n, लौटा a(n)।

ऐनक

• n सकारात्मक रहेगा।
• आप 1-अनुक्रमित के बजाय 0-अनुक्रमित का उपयोग कर सकते हैं। उस स्थिति में, कृपया अपने उत्तर में बताएं। साथ ही, उस स्थिति में भी nहो सकता है 0।

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

वृषण 1-अनुक्रमित हैं। हालाँकि, आप 0-अनुक्रमित का उपयोग कर सकते हैं।

n  a(n)
1  1
2  2
3  1
4  1
5  2
6  2
7  1
8  2
9  1
10 1
11 2
12 1
13 2
14 2
15 1
16 1
17 2
18 1
19 1
20 1

संदर्भ

• WolframMathWorld
• अनिवार्य OEIS A006345

Comments

के परीक्षण के मामले में n=9, पहली पसंद 1 2 1 1 2 2 1 2 1में 2 1अंत में दोगुना विकल्प है ।

— शर्लक 9

ध्यान दें कि लिंक किए गए OEIS पृष्ठ में ~ 43 बाइट्स का एक गोल पर्ल समाधान है।

— liori

Answer 1

हास्केल, 146 140 137 133 118 बाइट्स

s!l|take l s==take l(drop l s)=l|1<2=s!(l-1)
g[w,x]|w<x=1|1<2=2
a 1=1
a n=g$(\s x->(x:s)!n)(a<$>[n-1,n-2..1])<$>[1,2]

Comments

क्या आपको वास्तव में जरूरत है (\x->(\s->...? नहीं तो आप लिख सकते थे (\x s->...।

— 20

यही कारण है कि कुछ को बचाने के लिए मदद करता है

— कार्यक्रम आदमी

PPCG में आपका स्वागत है!

— दांव

ऊपरी ऊपरी सीमा का उपयोग करने के बजाय div ..., आप छोटे का उपयोग कर सकते हैं n। अतिरिक्त तुलनाएं सभी झूठी होंगी और परिणाम नहीं बदलेगी।

— क्रिश्चियन सिवर्स

ओह अच्छा, मुझे लगता है कि मैंने मान लिया कि अगर दुर्घटना बहुत बड़ी हो तो दुर्घटना होगी

— प्रोग्राम मैन

Answer 2

पायथन, 137 बाइट्स

def a(n,s=[0],r=lambda l:max([0]+filter(lambda i:l[-i:]==l[-i*2:-i],range(len(l))))):
 for _ in[0]*n:s+=[r(s+[0])>r(s+[1])]
 return-~s[n]

यह समाधान 0-आधारित अनुक्रमण का उपयोग कर रहा है।

Answer 3

जेली , 25 24 22 20 बाइट्स

2 बाइट्स डेनिस के लिए धन्यवाद।

2;€µḣJf;`€$ṪLµÞḢ
Ç¡Ḣ

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

पायथ में मेरे जवाब का एक बंदरगाह ।

Ç¡Ḣ   Main chain

 ¡    Repeat for (input) times:
Ç         the helper chain
  Ḣ   Then take the first element



2;€µḣJf;`€$ṪLµÞḢ  Helper chain, argument: z

2;€               append z to 1 and 2, creating two possibilities
   µ         µÞ   sort the possibilities by the following:
    ḣJ                generate all prefixes from shortest to longest
       ;`€            append the prefixes to themselves
      f   $           intersect with the original set of prefixes
           Ṫ          take the last prefix in the intersection
            L         find its length
                 Ḣ   take the first (minimum)

Answer 4

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

a@n_:=a@n=First@MinimalBy[{1,2},Array[a,n-1]~Append~#/.{___,b___,b___}:>Length@{b}&]

Answer 5

जेली , 30 29 28 27 24 बाइट्स

;€¬;\€Z;/f;`€$ṪḢ;
1Ç¡o2Ḣ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

Answer 6

MATL , 34 बाइट्स

vXKi:"2:"K@h'(.+)\1$'XXgn]>QhXK]0)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

v             % Concatenate stack vertically: produces empty array
XK            % Copy to clipboard K. This clipboard holds the current sequence
i:            % Take input n. Generate vector [1 2 ... n]
"             % For each k in [1 2 ... n]
  2:          %   Push [1 2]. These are the possible digits for extending the sequence
  "           %     For each j in [1 2]
    K         %       Push contents of clipboard K (current sequence)
    @         %       Push j (1 or 2)
    h         %       Concatenate horizontally: gives a possible extension of sequence
    '(.+)\1$' %       String to be used as regex pattern: maximal-length repeated suffix
    XX        %       Regex match
    gn        %       Convert to vector and push its length: gives length of match
  ]           %    End. We now have the suffix lengths of the two possible extensions
  >           %    Push 1 if extension with "1" has longer suffix than with "2"; else 0 
  Q           %    Add 1: gives 2 if extension with "1" produced a longer suffix, or 1
              %    otherwise. This is the digit to be appended to the sequence
  h           %    Concatenate horizontally
  XK          %    Update clipboard with extended sequence, for the next iteration
]             % End
0)            % Get last entry (1-based modular indexing). Implicitly display

Answer 7

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

import re
s='1'
exec"s+=`3-int(re.search(r'(.*)(.)\\1$',s).groups()[1])`;"*input()
print s[-1]

0-आधारित अनुक्रमण का उपयोग करता है। Ideone पर इसका परीक्षण करें ।

Answer 8

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

huh.mleq#.<T/lT2._b+RGS2QY

परीक्षण सूट।

व्याख्या

जब n = 6, हम 1 2 1 1 2 1और के बीच चयन करते हैं 1 2 1 1 2 2।

हम इन दो संभावनाओं को उत्पन्न करते हैं, और फिर उनके प्रत्ययों को देखते हैं।

पहले एक के लिए, प्रत्यय हैं: 1, 2 1, 1 2 1, 1 1 2 1, 2 1 1 2 1, 1 2 1 1 2 1।

हम जांच के द्वारा दोहरे प्रत्ययों के लिए फ़िल्टर करते हैं यदि वे 2 से विभाजित उनकी लंबाई के लिए उन्हें घुमाने के बाद समान हैं (यह पता चलता है कि यह चेक सही नहीं है, क्योंकि यह पुष्टि करता है 1और 2भी)।

हम अंतिम दोगुनी प्रत्यय लेते हैं और फिर इसकी लंबाई लेते हैं।

फिर हम उस संभावना को चुनते हैं जो ऊपर उत्पन्न न्यूनतम लंबाई से मेल खाती है।

फिर हम अगले मूल्य पर आगे बढ़ते हैं n।

इस कार्यक्रम के उद्देश्य के लिए, इसके बजाय उलट सरणी उत्पन्न करने के लिए यह गोल्फर था।

huh.mleq#.<T/lT2._b+RGS2QY
 u                      QY   repeat Q (input) times,
                             start with Y (empty array),
                             storing the temporary result in G:
                   +RGS2         prepend 1 and 2 to G,
                                 creating two possibilities
   .m             b              find the one that
                                 makes the following minimal:
                ._                   generate all prefixes
       q#                            filter for prefixes as T
                                     that equals:
         .<T/lT2                         T left-rotated
                                         by its length halved
      e                              take the last one
     l                               generate its length
  h                              take the first minimal one
h                                take the first one from the generated
                                 array and implicitly print it out

Answer 9

पायथ, 46 29 बाइट्स

@Leaky नन के उत्कृष्ट Pyth उत्तर से कुछ प्रेरणा ली। यह देखने की कोशिश की कि क्या तार का उपयोग करने का एक छोटा तरीका था। अभी भी 3 बाइट्स छोटी है!

huh.melM+kf!x>blTT._bm+dGS2Qk

आप इसे यहाँ आज़मा सकते हैं ।

Comments

uस्पष्ट सीई-लूप के बजाय लाल सीई का उपयोग करना आपको 4 बाइट्स बचाता है

— लीके नून

Answer 10

रेटिना , 51 42 बाइट्स

मार्टिन एंडर को 9 बाइट्स धन्यवाद।

.+
$*x
+`((.*)(^|2|(?<3>1))\2)x
$1$#3
!`.$

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

इस उत्तर का एक बंदरगाह ।

Answer 11

पर्ल, 40 बाइट्स

$a.=/(.*)(.)\1$/^$2for($a)x$_;$_=$a%5+1

कोड 39 बाइट्स लंबा है और -pस्विच ( +1 बाइट) की आवश्यकता है।

पाश प्रासंगिक OEIS पृष्ठ पर पर्ल समाधान से प्रेरित है , हालांकि मैं नियमित अभिव्यक्ति के साथ स्वतंत्र रूप से आया था।

Ideone पर इसका परीक्षण करें ।

Comments

आपने विशेष रूप से, टन हास्पेल / फिल कारमोडी ... को

— लीक किया है

वास्तव में तुलनीय नहीं है क्योंकि OEIS स्क्रिप्ट कोई इनपुट नहीं लेती है और पूरे अनुक्रम को प्रिंट करती है।

— डेनिस

Answer 12

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

इंडेक्स बेस 0

n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

कम गोल्फ वाला

n=>{
  r = d => (s+d).match(/(.*)\1$/)[0].length;
  c = '1';
  for(s = c; n--; s += c)
    c = r(1) > r(2) ? 2 : 1;
  return c;
}

परीक्षा

F=
n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

for(n=0;n<20;n++)console.log(n,F(n))