अनदेखी संख्या उत्पन्न करें

15

हम कहते हैं कि एक स्ट्रिंग एक मूल स्ट्रिंग का कोई निरंतर खंड है। उदाहरण के लिए catएक विकल्प है concatenate। हम कहेंगे कि एक उचित प्रतिस्थापन एक विकल्प है जो मूल स्ट्रिंग के बराबर नहीं है। उदाहरण के लिए concatenateएक विकल्प है, concatenateलेकिन एक उचित विकल्प नहीं है। (सिंगल कैरेक्टर स्ट्रिंग्स का कोई उचित विकल्प नहीं है)

अब हम इन शब्दों का उपयोग करके एक अनुक्रम परिभाषित करेंगे। N वें अवधि इस क्रम में सबसे छोटी संख्या अपने द्विआधारी प्रतिनिधित्व के लिए एक उचित सबस्ट्रिंग कि अनुक्रम में किसी पूर्ववर्ती अवधि की सबस्ट्रिंग नहीं है ऐसी है कि वहाँ हो जाएगा। पहला कार्यकाल है 10।

एक अभ्यास के रूप में पहले 5 शब्द उत्पन्न करने देता है। मैं चीजों को आसान बनाने के लिए बाइनरी में काम करूंगा।

पहला कार्यकाल है 10। चूंकि 11, सबसे छोटी संख्या में, केवल एक उचित विकल्प है, 1जो एक विकल्प भी है 10, 11अनुक्रम में नहीं है। 100लेकिन उचित-स्ट्रिंग शामिल करता है 00जो की सबस्ट्रिंग नहीं है 10तो 100हमारी अगली शब्द है। अगला, 101जिसमें 01अनुक्रम में इसे जोड़ने के लिए अद्वितीय उचित विकल्प 110शामिल है , फिर उचित प्रतिस्थापन 11होता है जो इसे अनुक्रम में जोड़ रहा है।

अब हमारे पास है

10, 100, 101, 110

111अगला है, लेकिन इसमें केवल सबस्ट्रिंग शामिल हैं 1और 11यह एक शब्द नहीं है। 1000हालांकि 000इसे अनुक्रम में शामिल करना है।

यहाँ दशमलव में पहले कुछ शब्द दिए गए हैं

2, 4, 5, 6, 8, 9, 10, 11, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 30, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 50, 54, 56, 58

कार्य

भी

  • N को इनपुट के रूप में लें और इस क्रम में n th टर्म उत्पन्न करें (या तो 0 या 1 अनुक्रमित)

  • अनुक्रम के लगातार उत्पादन की शर्तें

यह कोड-गोल्फ उत्तर है बाइट्स में कम बाइट्स के साथ बेहतर स्कोर किया जाता है।

code-golf  number  sequence  binary 
— पोस्ट रॉक गार्फ हंटर
स्रोत
क्या आउटपुट को दशमलव या बाइनरी में माना जाता है? या अन्यथा?
— AdmBorkBork
@AdmBorkBork मुझे लगता है कि यह पूर्णांक माना जाता है।
— E
100 वां शब्द (या कोई अन्य बड़ा n) जोड़ सकता है ?
— रॉड
@AdmBorkBork आपको किसी भी मानक अनुमत प्रारूप में आउटपुट करना चाहिए।
— रॉक गार्फ हंटर
@Rod 36 काफी बड़ा है? a(36)47 (1 अनुक्रमित) है।
— पोस्ट रॉक गार्फ हंटर

जवाबों:

5

पायथन 3 , 88 80 78 75 बाइट्स

गेहूं विज़ार्ड के लिए -6 बाइट्स धन्यवाद
-2 बाइट्स रूट रूटो
-3 बाइट्स के लिए धन्यवाद नोटजैगन के लिए धन्यवाद 

s={0}
n=1
while 1:n+=1;b=f"{n:b}";p={b[1:],b[:-1]};s|=p-s and{b,print(n)}|p

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

— छड़ी
स्रोत
— पोस्ट रॉक गार्फ हंटर
— पोस्ट रॉक गार्फ हंटर
@WheatWizard Ninja'd
— रॉड
पायथन 3.6 में, आप के bin(n)[2:]साथ प्रतिस्थापित करके 2 और बचा सकते हैं f"{n:b}"।
— रूटट्वो
-3 बाइट्स वास्तव में कुछ अजीब बदलावों के साथ।
— नॉटजागन
1

गणितज्ञ, ११६ ११० बाइट्स

x={};f=Subsequences[#~IntegerDigits~2]&;Do[MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]&&x~AppendTo~Echo@n,{n,2,∞}]

मूल रूप से अनुक्रम की शर्तें आउटपुट।

व्याख्या

x={};

x अनुक्रम की शर्तों की अब तक की सूची है।

f=Subsequences[#~IntegerDigits~2]&

fवह है Functionजो पूर्णांक लेता है और Subsequencesअपने सभी आधार 2प्रतिनिधित्व (खाली सूची {}और IntegerDigitsस्वयं की पूरी सूची सहित ) को वापस करता है।

Do[...,{n,2,∞}]

से ...मूल्य के लिए मूल्यांकन करें ।n2∞

...&&x~AppendTo~Echo@n

यदि ...है False, तो दूसरे तर्क का And( &&) कभी मूल्यांकन नहीं किया जाता है। यदि ...है True, तो Echo@nप्रिंट और रिटर्न n, जो हम फिर AppendToसूची में हैं x।

MemberQ[Most@f@n,s_/;FreeQ[f/@x,s,2]]

हम यह जांचना चाहते हैं कि कुछ उचित विकल्प nक्रम में किसी पिछले शब्द का विकल्प नहीं है। Most@f@nके समुचित सबस्ट्रिंग की सूची है n, हम तो जाँच किसी भी सबस्ट्रिंग देखते हैं कि क्या s_है जो एक है MemberQकि सूची की ऐसी है कि सूची f/@xअनुक्रम के पिछले नियमों की सबस्ट्रिंग सूचियों में से है FreeQके sस्तर पर 2।

— ngenisis
स्रोत
1

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

s={};Do[!SubsetQ[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]]&&(s=s~Join~t;Echo@i),{i,∞}]


अनुक्रम के लगातार उत्पादन की शर्तें

-15 बाइट्स के लिए @ngenisis के लिए विशेष thanx


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

(s=r={};For[i=2,i<2#,i++,If[!ContainsAll[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]],s=s~Join~t;r~AppendTo~i]];r[[#]])&


N को इनपुट के रूप में लें और इस क्रम में nth टर्म जेनरेट करें (1 अनुक्रमित)

इनपुट

[1000]

उत्पादन

1342

— J42161217
स्रोत
अब तक दिखाई देने वाले सबस्ट्रिंग पर नज़र रखने के लिए अच्छा विचार है! मैं कम से कम 15बाइट्स की जासूसी करता हूं : इससे SubsetQकम और इसके बराबर है ContainsAll, आप Andइसके बजाय का उपयोग कर सकते हैं If, Unionअनावश्यक है, और Doलगभग हमेशा की तुलना में छोटा है For:s={};Do[!SubsetQ[s,(t=Subsequences@IntegerDigits[i,2])[[2;;-2]]]&&(s=s~Join~t;Echo@i),{i,∞}]
— ngenisis
3अधिक बाइट्स का उपयोग करके Most:s={};Do[!SubsetQ[s,Most[t=Subsequences@IntegerDigits[i,2]]]&&(s=s~Join~t;Echo@i),{i,2,∞}]
— ngenisis
0

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

u+G
fP-Fm.:.Bd)+TG1Y

यह अनुक्रम को असीम रूप से प्रिंट करता है। यह केवल एक परिणाम के रूप में ऑफ़लाइन उपयोग किया जा सकता है।

स्पष्टीकरण (अंतरिक्ष एक नई रेखा है):

u+G fP-Fm.:.Bd)+TG1Y
u                  Y    Apply the following function to the previous output
                        until it stops changing (or forever, in this case),
                        starting with the empty list
    f             1     Find the first positive integer where
               +TG      The integer prepended to the current list
        m               Map to
           .Bd          Convert to binary
         .:   )         Form all subsequences
      -F                Fold the filter-out function over the list
                        This iteratively removes all subsequences already seen
                        from the candidate
     P                  Remove the last subsequence which is the whole number.
   (newline)            Print that first integer
 +G                     Prepend that first integer to the list
— isaacg
स्रोत
0

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

import Data.List
b 0=""
b n=b(n`div`2)++(show$n`mod`2)
s=nub.(tails=<<).inits
p x=s x\\[x]
n(_,l)x|(p.b)x\\l/=[]=(x,l++(s.b)x)|1<2=(0,l)
filter(>1)$fst<$>scanl n(1,[])[1..]

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

व्याख्या

कोड लगातार अनुक्रम उत्पन्न करता है।

  • bएक के Intरूप में द्विआधारी प्रतिनिधित्व रिटर्न एString
  • s एक स्ट्रिंग के सभी सबस्ट्रिंग लौटाता है
  • p एक स्ट्रिंग के सभी उचित पदार्थों को लौटाता है
  • n एक ऐसा कार्य है जिसे पुनरावृति से लागू किया जाता है और जिसमें एक टपल होता है:
    • वर्तमान तत्व, यदि यह अनुक्रम का सदस्य है, अन्यथा 0
    • निम्नलिखित सभी नंबरों के लिए जाँच करने के लिए सभी सबस्ट्रिंग की एक सूची
  • अंत में, बार-बार scanlकॉल करने के लिए उपयोग किया जाता है nऔर इसका आउटपुट केवल 1 से अधिक तत्वों को शामिल करने के लिए फ़िल्टर किया जाता है

यहाँ थोड़ा और अधिक पठनीय संस्करण है, गोल्फिंग से पहले:

import Data.List

binary :: Int -> String
binary 0=""
binary n|(d,r)<-divMod n 2=binary d++["01"!!r]

substrings :: String -> [String]
substrings xs = nub$inits xs>>=tails

properSubstrings :: String -> [String]
properSubstrings xs = substrings xs\\[xs]

sb  = substrings.binary
psb = properSubstrings.binary

g = scanl step (1,[]) [1..]
  where step (_,l) x | psb x \\ l /= [] = (x,l++sb x)
                     | otherwise        = (0,l)

f=filter(>1)$fst<$>g
— क्रिस्टियन लुपस्कू
स्रोत
0

जावास्क्रिप्ट, 57 बाइट्स

for(x=1;;x++)/^10|10(00)*$/.test(x.toString(2))&&alert(x)

कोड स्निपेट दिखाएं

हम दिए गए नंबर n को बाइनरी फॉर्म में लिखते हैं , फिर:

  • यदि संख्या के साथ शुरू होता है 10, n अनुक्रम में होना चाहिए:
    • इसमें पहले 1को हटा दें , शेष बाइनरी स्ट्रिंग को नहीं देखा जाना चाहिए, क्योंकि n सबसे छोटी संख्या है जिसमें ऐसा स्ट्रिंग हो सकता है
  • यदि संख्या के साथ शुरू होता है 11:
    • इसमें पहले को हटाकर 1, शेष बाइनरी स्ट्रिंग (हम इसे दान करते हैं जैसा 1xकि तब से देखा जाना चाहिए:
      • 1xक्रम में संख्या है, या
      • संख्या 1x0क्रम में है, क्योंकि इसमें अद्वितीय उप स्ट्रिंग है1x
    • यदि यह विषम है (1 के साथ समाप्त होता है), तो इसे अनुक्रम में नहीं होना चाहिए, क्योंकि:
      • ( n - 1) / 2 क्रम में, या
      • अनुक्रम में ( n - 1), क्योंकि इसमें अद्वितीय उप स्ट्रिंग ( n - 1) / 2 हैं
    • यदि यह सम है (0 के साथ समाप्त होता है), यह क्रम में है यदि if n / 2 अनुक्रम में नहीं है
      • इसी विचार के साथ, n / 2 अनुक्रम में नहीं है यदि if n / 2 विषम है, या n / 4 अनुक्रम में है

निष्कर्ष:

संख्या का द्विआधारी रूप विषम संख्या के 10साथ शुरू या समाप्त होता 1है 0। या रेगेक्स में वर्णन करें: एक्स मैच /^10|10(00)*$/।

— TSH
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.