बॉम-स्वीट सीक्वेंस

21

बॉम-स्वीट सीक्वेंस (A086747 ट्विस्ट के साथ)

एक सकारात्मक पूर्णांक में ले जाएं nऔर पूर्णांक 1 से n तक प्रिंट करें, जिसके लिए बॉम-स्वीट अनुक्रम सही है। बॉम-स्वीट अनुक्रम गलत साबित हो सकता है यदि संख्या के द्विआधारी प्रतिनिधित्व में संख्या में कहीं भी लगातार शून्य की एक विषम संख्या होती है, और अन्यथा सत्य है। अधिक जानकारी के लिए लिंक पर क्लिक करें। यहाँ कुछ उदाहरण हैं:

1 -> 1 -> Truthy
2 -> 10 -> Falsy
3 -> 11 -> Truthy
4 -> 100 -> Truthy (Even run of zeros)

यहाँ एक उदाहरण दिया गया है n=32

चरण 1: बॉम-स्वीट अनुक्रम के लिए कल्पना की n=32

1               1 (1)
1 0             0 (2)
11              1 (3)
1 00            1 (4)
1 0 1           0 (5)
11 0            0 (6)
111             1 (7)
1 000           0 (8)
1 00 1          1 (9)
1 0 1 0         0 (10)
1 0 11          0 (11)
11 00           1 (12)
11 0 1          0 (13)
111 0           0 (14)
1111            1 (15)
1 0000          1 (16)
1 000 1         0 (17)
1 00 1 0        0 (18)
1 00 11         1 (19)
1 0 1 00        0 (20)
1 0 1 0 1       0 (21)
1 0 11 0        0 (22)
1 0 111         0 (23)
11 000          0 (24)
11 00 1         1 (25)
11 0 1 0        0 (26)
11 0 11         0 (27)
111 00          1 (28)
111 0 1         0 (29)
1111 0          0 (30)
11111           1 (31)
1 00000         0 (32)

इसलिए, एन के लिए बॉम-स्वीट अनुक्रम की गणना करने के बाद, उन संख्याओं को लें जो अनुक्रम के लिए सत्य थे और उन्हें अंतिम परिणाम के लिए इकट्ठा करते हैं। हमारे लिए n=32होगा:

[1, 3, 4, 7, 9, 12, 15, 16, 19, 25, 28, 31]

अंतिम उत्तर के रूप में।

यह कोड-गोल्फ , सबसे छोटी बाइट गिनती जीत है।

code-golf  sequence  base-conversion  binary 
— जादू ऑक्टोपस Urn
स्रोत
क) मुद्रण आवश्यक है, या हम सिर्फ एक स्ट्रिंग या सरणी लौटा सकते हैं? बी) क्या परिणाम आरोही क्रम में होना है?
— इरसेन
@ जब तक अंकों को प्रदर्शित नहीं किया जाता है, तब तक मैं ठीक हूं जो भी आपकी भाषा में है।
— मैजिक ऑक्टोपस Urn
2
"अधिक जानकारी के लिए, लिंक पर क्लिक करें।" नहीं, इसे प्रश्न में डालें।
— बिल्ली

जवाबों:

7

05AB1E , 10 9 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया

ƒNb00¡SP–

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

व्याख्या

ƒ          # for N in [0 ... input]
 Nb        # convert N to binary
   00¡     # split at "00"
      S    # convert to list of digits
       P   # product of list
        –  # if 1, print N
— Emigna
स्रोत
के ƒबजाय काम करता है >G?
— अदनान
1
@ अदनान: हां बिल्कुल। मैंने इसका उपयोग N = 0 से बचने के लिए नहीं किया, लेकिन इसमें विषम संख्या में शून्य होने से कोई फर्क नहीं पड़ता। मुझे मूर्ख। धन्यवाद :)
— एमिग्ना
@Emigna का .¡उपयोग करने की उम्मीद कर रहा था ;)
— मैजिक ऑक्टोपस मूत्र
@carusocomputing: मैंने उस पर विचार किया, लेकिन दुर्भाग्य से मैं कभी भी इससे छोटा नहीं हुआ।
— एमिग्ना
8

जावास्क्रिप्ट (ईएस 6), 70 68 63 बाइट्स

g=n=>n?g(n-1).concat(/0/.test(n.toString(2).split`00`)?[]:n):[]

console.log(g(1000).join(", "))
स्निपेट का विस्तार करें

थोड़ा और अधिक दिलचस्प पुनरावर्ती समाधान:

n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(‌​n/4))

67 बाइट्स @Neil की बदौलत।

g कॉल करने के लिए फ़ंक्शन है।

— ETHproductions
स्रोत
यह एक दिलचस्प तरीका है, क्या आपने पहले ऐसा किया है?
— मैजिक ऑक्टोपस Urn
@carusocomputing यह विशेष अनुक्रम नहीं है, लेकिन मैंने अतीत में कई बार इस प्रकार की पुनरावृत्ति की है। fएक फ़ंक्शन के समान है जिसका उपयोग मैं कभी-कभी किसी संख्या में 1-बिट की संख्या को गिनने के लिए करता हूं।
— ETHproductions
नहीं करता है fजब असफल n=0? fकेवल 0 या 1 रिटर्न के रूप में भी आप दो बाइट्स का उपयोग करके शेव कर सकते हैं n&f(n>>1)।
— नील
@ नील "1 से n तक पूर्णांक प्रिंट करें", n = 0मामला नहीं है;)।
— मैजिक ऑक्टोपस Urn
मैंने आपके पुनरावर्ती समाधान को बंद करके एक और बाइट का मुंडन किया filter:n=>[...Array(n+1).keys()].filter(f=n=>n<2?n:n%4?n&f(n>>1):f(n/4))
— नील
4

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

g=lambda n:n*[0]and g(n-1)+[n]['0'in`bin(n)[1:].split('00')`:]

बाइनरी प्रतिनिधित्व में 1 के विषम रनों के लिए चेक, विभाजित करके 00और जाँचता है कि क्या कोई शून्य परिणामी सूची के स्ट्रिंग प्रतिनिधित्व में रहता है। आमतौर पर, द्विआधारी संख्या के साथ शुरू होता है 0b, जिसमें एक शून्य होता है जिसे झूठे सकारात्मक से बचने के लिए निकालने की आवश्यकता होती है।

एन्यूमरेशन को नीचे की ओर ले जाकर किया जाता है।

— XNOR
स्रोत
4

दे घुमा के, 58, 46 बाइट्स

संपादन:

  • बदला बीसी के साथ डीसी (Thx @Digital ट्रामा!)
  • 1 से शुरू करें;

golfed

seq $1|sed 'h;s/.*/dc -e2o&p/e;s/00//g;/0/d;x'

परीक्षा

>./baum 32
1 
3
4
7 
9
12
15
16
19
25
28
31

व्याख्या की

खोल

seq $1 #generate a sequence of integers from 1 to N, one per line
|sed   #process with sed

sed 

h                #Save input line to the hold space
s/.*/dc -e2o&p/e #Convert input to binary, with dc
s/00//g          #Remove all successive pairs of 0-es
/0/d             #If there are still some zeroes left
                 #(i.e. there was at least one odd sequence of them)
                 #drop the line, proceed to the next one
x                #Otherwise, exchange the contents of the hold 
                 #and pattern spaces and (implicitly) print

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत
3

बैच, 143 बाइट्स

@for /l %%i in (1,1,%1)do @call:c %%i
@exit/b
:c
@set/ai=%1
:l
@if %i%==1 echo %1&exit/b
@set/ar=%i%%%4,i/=4-r%%2*2
@if %r% neq 2 goto l
— नील
स्रोत
3

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

{grep {.base(2)!~~/10[00]*[1|$]/},1..$_}

कोशिश करो

{
  grep            # find all of them
  {
    .base(2)      # where the binary representation
    !~~           # does not match
    /
      10          # ｢10｣
      [ 00 ]*     # followed by an even number of ｢0｣s
      [ 1 | $ ]   # either at end or before a ｢1｣
    /
  }, 1 .. $_      # from one to the input
}

( []गैर-कैप्चरिंग ग्रुपिंग के <[]>लिए उपयोग किया जाता है, चरित्र वर्गों के लिए उपयोग किया जाता है)

— ब्रैड गिल्बर्ट b2gills
स्रोत
2

पॉवरशेल , 79 61 बाइट्स

1..$args[0]|?{0-notin([convert]::ToString($_,2)-split'1|00')}

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

मुझे आज सुबह प्रेरणा मिली कि मैं -splitऑपरेशन कैसे करूं , फिर यह देखूं कि यह कैसे एक्सनोर के उत्तर के समान है , इसलिए, मुझे लगता है कि महान दिमाग एक जैसा सोचते हैं?

हम 1इनपुट तक लूप $args[0]करते हैं, और Where-Objectउपयुक्त संख्याओं को खींचने के लिए एक ऑपरेटर का उपयोग करते हैं |?{...}। खंड एक सरल बूलियन मान है - हम सुनिश्चित कर रहे हैं कि 0है -notinके परिणाम (...)।

पार्न्स के अंदर, हम आधार के साथ [convert]::वर्तमान संख्या (यानी, इसे बाइनरी स्ट्रिंग में बदलते हैं)। फिर हम रेगेक्स पर स्ट्रिंग करते हैं - यह एक लालची मैच है, और स्ट्रिंग्स की एक सरणी में परिणाम होता है (उदाहरण के लिए, आगे और पीछे)।$_ ToString2-split1|00100010'','','0','','0'

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

— AdmBorkBork
स्रोत
2

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

f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)

@Xnor के लिए धन्यवाद 20 से (गोल्फ!) बाइट्स बंद!

एक अनियंत्रित सूची देता है। यह काफी कुशल है: इनपुट 100,000 TIO पर लगभग 40 एमएस लेता है।

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

— डेनिस
स्रोत
अच्छी विधि! मुझे लगता है कि आप बेस केस भी कर सकते हैं [1][n:]or। इसके अलावा, x-~xके लिए 2*x+1।
— xnor 10
यह बहुत साफ समाधान देता है यदि आप इसके बजाय पेड़ f=lambda n,k=1:n/k*[1]and[k]+f(n,k-~k)+f(n,4*k)को हटाते हैं : तो मान लें कि ऊपूत किसी भी क्रम में हो सकते हैं।
— xnor
@xnor यह पागल कम है। धन्यवाद!
— डेनिस
1

MATL , 12 11 बाइट्स

:"@BY'og)?@

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

व्याख्या

यह पता लगाने के लिए कि क्या कोई संख्या वैध है, यह बाइनरी में कनवर्ट होता है, रन-लेंथ एन्कोडिंग को लागू करता है, केवल विषम लंबाई के रन रखता है, और जाँचता है कि कोई रन ऑफ़ ज़ीरो बचता है या नहीं।

:       % Take input n implicitly. Push range [1 2 ... n]
"       % For each k in [1 2 ... n]
  @     %   Push k
  B     %   Convert to binary
  Y'    %   Run-length encoding. Pushes array of values and array of run-lengths
  o     %   Parity. Gives array that contains 0 for even lengths, 1 for odd
  g)    %   Convert to logical and use index into the array of values
  ?     %   If the result does not contain zeros
    @   %     Push k
        %   End
        % End
        % Implicitly display stack
— लुइस मेंडो
स्रोत
स्पष्टीकरण के लिए संपादित प्रश्न, मुझे लगा कि कुछ लोग OEIS पर क्लिक करेंगे और बिना पढ़े ही वहां से चले जाएंगे; P यही तो मैं भी कभी-कभी करता हूं।
— मैजिक ऑक्टोपस Urn
@carusocomputing हां, मैं हमेशा बहुत तेजी से पढ़ता हूं :)
— लुइस
1

आर, 75 बाइट्स

for(i in 1:scan()){x=rle(miscFuncs::bin(i));if(!any(x$l%%2&!x$v))cat(i,"")}

स्टड से इनपुट पढ़ता है और दशमलव से बाइनरी वेक्टर में बदलने के binलिए miscFuncsपैकेज से फ़ंक्शन का उपयोग करता है । नतीजतन मानों की जांच के लिए रन-लंबाई एन्कोडिंग करता है == 0और लंबाई विषम है।

— Billywob
स्रोत
1

स्टैक्ड , 69 बाइट्स

यहाँ कोशिश करो!

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all]"filter

या, 67 बाइट्स में गैर-कम्‍प्‍यूटिंग:

:>1+[bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap even all]"filter

और, 49 बाइट्स पर और अधिक गैर-कमिंग:

:>1+[bits rle{k:k 0=}filter values even all]fkeep

सभी टीओएस के रूप में इनपुट लेते हैं और टीओएस पर आउटपुट छोड़ते हैं।

व्याख्या

:>1+[...]"filter   input: n
:>                 range from [0, n)
  1+               range from [1, n]
    [...]          a function
         "filter   apply to each cell and filter

कार्यक्रम:

bits{e.b:e b 0#=}chunkby[0 has]filter$sizemap 2%0 eq all  input: c
bits                                                      convert c to binary
    {e.b:e b 0#=}chunkby                                  split into chunks of contiguous 0s
                        [0 has]filter                     take only chunks with 0s
                                     $sizemap             map each chunk to its size
                                              2%          vectorized modulus 2
                                                0 eq      vectorized equality with 0
                                                     all  all of them are of even lengths

नॉनकंपेटिंग की व्याख्या:

यह ऊपर के समान है, कुछ प्रमुख अंतरों के साथ:

:>1+[bits rle{k:k 0=}filter values even all]fkeep   input: y
          rle                                       run length encode y
             {k:k 0=}filter                         keep keys that = 0
                            values                  get those values
                                            fkeep   like `filter`, but is implemented with
                                                    taking `f` as a boolean mask
— कोनोर ओ ब्रायन
स्रोत
स्टैक्ड ऐसा लगता है कि इसके साथ खेलने में मज़ा आ सकता है!
— ElPedro
@ElPedro धन्यवाद: D यह वास्तव में है
— Conor O'Brien
1

Befunge, 84 51 49 बाइट्स

थोड़े से प्रयोग के बाद, मुझे एहसास हुआ कि बैच जवाब के साथ एक तकनीक का उपयोग करके मैं अपने मूल समाधान की तुलना में काफी बेहतर कर सकता हूं जो नील के साथ आया था।

<v::\<&1
:_v#:/+2*2!%2:_v#-2%4
:$<@_v#!:-1\+1$<:.

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

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

यदि मोडुलो 4 2 के बराबर नहीं है, तो हमें शेष बिट्स का परीक्षण जारी रखने की आवश्यकता है, इसलिए हम उन बिट्स को स्थानांतरित करते हैं जो पहले से ही परीक्षण किए जा चुके हैं। यह मान को विभाजित करके किया जाता है, इसे n , द्वारा कॉल करने देता है 2+2*!(n%2)। इसका मतलब है कि अगर पहली बिट 1 थी, तो हम 2 से विभाजित करते हैं (उस 1 बिट को छोड़ते हुए), लेकिन अगर यह 0 था, तो हम 4 से विभाजित करते हैं, इसलिए हम हमेशा शून्य के जोड़े को छोड़ देंगे।

अगर हम अंततः शून्य पर पहुंच जाते हैं, तो इसका मतलब है कि शून्य बिट्स के कोई विषम अनुक्रम नहीं थे, इसलिए हम संख्या लिखते हैं।

— जेम्स होल्डरनेस
स्रोत
1

विजुअल बेसिक (.net 4.5) 163 बाइट्स

पहले कभी यहाँ जवाब दो तो मुझे यकीन है कि मैंने कुछ पंगा ले लिया है। मुझे जाने दो और मैं ठीक कर दूंगा। क्या विज़ुअल बेसिक लैम्ब्डा की भी अनुमति है?

लगातार शून्य विचारों को हटाने के लिए MamaFunRoll का धन्यवाद

Dim R=Sub(m)System.Console.WriteLine(String.Join(",",System.Linq.Enumerable.Range(1, m).Where(Function(s) Not Convert.ToString(s,2).Replace("00","").Contains(0))))

आर (32) आउटपुट 

1,3,4,7,9,12,15,16,19,25,28,31
— भूत
स्रोत
1

जावा, 144 130 128 बाइट्स

यह उतना घिसा-पिटा नहीं है जितना मुझे लगता है कि यह हो सकता है, लेकिन मैंने सोचा कि यह एक रेगेक्स का उपयोग करने के लिए एक प्यारा समाधान होगा, कभी भी इसका इस्तेमाल नहीं किया जाएगा।

golfed:

static String a(int n){String s="";for(Integer i=0;i++<n;)if(i.toString(i,2).replaceAll("00|1","").isEmpty())s+=i+" ";return s;}

Ungolfed:

static String a(int n){
    String s="";                      //Cheaper than using a list/array
    for(Integer i=0;i++<n;)           //Loop n times
        if(i.toString(i,2)            //Convert int to base 2 string
                .replaceAll("00|1","")//Find and remove ones and consecutive zeroes
                .isEmpty())           //If any chars remain, i is truthy
            s+=i+" ";                 //Append i to the storage string
    return s;                         //Return all values
}

संपादित करें: मैं regex 00 | 1 को 00 के बजाय 1, और प्रतिस्थापन के बीच ".replace (" 1 "," ") को हटाकर isEmpty से 14 बाइट्स को बचाने में सक्षम था!

एडिट 2: मैं i बटर बनाकर 2 बाइट्स बचाने में सक्षम था और i.toString के साथ Integer.toString को संदर्भित करता था।

— Zavada
स्रोत
@JamesHolderness कि पकड़ने के लिए धन्यवाद! जब मैंने पहली बार इसे लिखा था, तो मैंने इसे कुछ समय के लिए गोल्फिंग और ungolfing करने की गलती की थी, इसलिए यह जरूर हुआ कि यह कैसे हुआ।
— ज़वाडा
0

क्लोजर, 103 बाइट्स

मुझे नहीं लगता कि यह सबसे छोटा तरीका है ...

#(remove(fn[v]((set(map(fn[s](mod(count s)2))(re-seq #"0+"(Integer/toString v 2))))1))(range 1(inc %)))

re-seqलगातार शून्य खोजने के लिए उपयोग करता है, उनके मॉडुलो -2 की लंबाई को मैप करता है set, यदि 1सेट से नंबर मिलता है , तो उन्हें डिस्कनेक्ट करता है।

— NikoNyrh
स्रोत
0

आश्चर्य है , 38 बाइट्स

@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0

उपयोग:

(@(!>@=1len iO0Rstr#["00"]bn#0)rng1+1#0) 32

व्याख्या

अधिक पठनीय:

@(
  fltr@
    = 1 
      len 
        iO 0 
          Rstr #["00"] 
            bn #0
) rng 1 +1 #0

rng 1 +1 #0: 1 से इनपुट तक सीमा।

fltr@ ...: निम्नलिखित विधेय के साथ फिल्टर रेंज।

bn #0: वर्तमान आइटम को बाइनरी में कनवर्ट करें। (यह एक अग्रणी होगा 0b)।

Rstr #["00"]: 00स्ट्रिंग में होने वाली किसी भी घटना की पुनरावृत्ति ।

len iO 0: 0स्ट्रिंग में s की मात्रा गिनें ।

=1: जांचें कि क्या राशि 1 के बराबर है। यदि 0छंटाई के बाद स्ट्रिंग में एकमात्र बचा है 0b, तो यह सही है; अन्यथा, यह गलत है।

— मामा फन रोल
स्रोत
0

माणिक, 78 69 68 बाइट्स

->n{(1..n).select{|m|m.to_s(s=2).split(?1).map{|i|s|=i.size};s&1<1}}

पुराने संस्करण:

->n{(1..n).select{|m|m.to_s(2).split(?1).select{|i|i.size%2>0}[0].!}}
->n{(1..n).select{|m|b=z=0;(m.to_s(2)+?1).each_char{|i|z+=i>?0?b|=z:1};b&1<1}}
— DepressedDaniel
स्रोत
0

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

Select[Range@#,FreeQ[Union@#+Mod[Length@#,2,1]&/@Split[#~IntegerDigits~2],{1}]&]&

गणना, एक संख्या में लगातार अंकों के प्रत्येक रन के लिए, {उस रन प्लस में सामान्य अंक (1 यदि लंबाई विषम है, 2 यदि लंबाई समान है)}; यदि कोई उत्तर {1} है तो संख्या अनुक्रम में नहीं है।

— ग्रेग मार्टिन
स्रोत
0

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

Select[Range@#,And@@EvenQ/@Length/@Cases[Split[#~IntegerDigits~2],{0..}]&]&

#~IntegerDigits~2इनपुट के बाइनरी अंकों की सूची की गणना करता है #। Splitकि समान तत्वों के रन में सूची ले Casesकि मैच {0..}ले Lengthउनमें से प्रत्येक की, ले EvenQलंबाई की और फिर वापस जाने के Andपरिणामों की।

— ngenisis
स्रोत
1
एक बाइट की बचत आप मेरे समाधान से ले सकते हैं:!Or@@OddQ/@...
— मार्टिन एंडर
0

पायथन 3, 86 82 बाइट्स

प्रगति में गोल्फ ...

lambda n:[x for x in range(1,n+1)if 1-any(i%2for i in map(len,bin(x).split('1')))]

4 बाइट्स bin(x)[2:]को केवल बदलकर बंद कर दिया bin(x)- यह 0bस्ट्रिंग की शुरुआत में निकलता है , लेकिन मुझे एहसास हुआ कि यह वास्तव में गणना को प्रभावित नहीं करता है :)

— FlipTack
स्रोत
0

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

यह मुख्य रूप से मेरे पाइथन को गोल्फ करने के लिए है।

def o(n):
 r=0
 for i in bin(n)[2:]:
  if i=='1':
   if r&1:return 0
   r=0
  else:r+=1
 return ~r&1
lambda n:[i for i in range(1,n+1)if o(i)]
— Noodle9
स्रोत
0

रूबी, 54 53 48 बाइट्स

->n{(1..n).reject{|x|x.to_s(2)=~/10(00)*(1|$)/}}

मुझे नहीं लगता था कि इस के लिए रेगेक्स इतना बुनियादी होने वाला था।

संपादित करें 1: -1 के लिए नकार से छुटकारा पाने के लिए अस्वीकृत।

संपादन 2: -5 के लिए स्विच किया matchगया =~।

— Elenian
स्रोत
0

सी # 159 157 155 बाइट्स

टू एक्सएक्सएक्सएक्स के लिए 2 एक्स दो बाइट्स को बचाया।

नोट: रिवर्स ऑर्डर में चींटियों को प्रिंट करता है।

void B(int n){var b=Convert.ToString(n,2);int c=0,i=0;for(;i<b.Length;){if(b[i++]<49)c++;else if(c%2>0)break;}if(c%2<1)Console.WriteLine(n);if(n>1)B(--n);}

स्पष्टीकरण:

void B(int n)
{
    // convert our int to a binary string
    var b = Convert.ToString(n, 2);

    // set our '0' counter 'c' and our indexer 'i' 
    int c = 0, i = 0;

    // loop over the binary string, without initialisation and afterthought
    for (; i < b.Length;)
    {
        // check for '0' (48 ASCII) and increment i. increment c if true
        if (b[i++] < 49)
            c++;

        // otherwise check if c is odd, and break if it is
        else if (c%2 > 0)
            break;
    }

    // print the int if c is even
    if (c%2 < 1)
        Console.WriteLine(n);

    // recursively call B again with the next number
    if (n > 1)
        B(--n);
}
— Erresen
स्रोत
पहली नज़र में, c%2==0हो सकता है c%2<1।
— यति दिनांक
ओह रुको, यह भी एक वैध प्रस्तुत नहीं है। इसे 1 से सही परिणाम प्रिंट करना चाहिए N।
— यति
@TuukkaX ने सवाल को गलत कर दिया है ... अब संशोधित उत्तर।
— इर्रसेन
@TuukkaX संपादित और श्रेय
— Erresen
1
b[i++] == '0'हो सकता है b[i++]==48, लेकिन चूंकि अन्य संभावित चरित्र '1' (ASCII 49) है, आप बस यह देख सकते हैं कि क्या b[i++]<49।
— यति
0

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

Select[Range@#,FreeQ[#~IntegerDigits~2//.{x___,0,0,y___}:>{x,y},0]&]&

एक ही लंबाई:

Select[Range@#,#~IntegerString~2~StringDelete~"00"~StringFreeQ~"0"&]&
— alephalpha
स्रोत
0

जेली, 15 13 10 बाइट्स

अन्य जवाबों को देखने के बाद दो बाइट्स बचाए, एक और 3 बाइट्स डेनिस की बदौलत

Bœṣ0,0Ȧµ€T

व्याख्या

Bœṣ0,0Ȧµ€T -Helper link: argument K (integer): ex. 24
B          -Convert K to a list of its binary digits: 24 -> [1,1,0,0,0]
   0,0     -Create a list of two 0's: [0,0]
 œṣ        -Split the binary digits on instances of the sublist: [1,1,0,0,0]-> [[1,1],[0]]
      Ȧ    -Any and All: Check if our list has any falsy values or is empty
       µ   -Take all our previous atoms and wrap them into one monad.
        €  -Map this new monad over a list. Since our input is an integer, this implicitly maps it over the range [1..N] (Like the 'R' atom)
         T -Get the indices of all truthy values (1's)
— Xanderhall
स्रोत
tio.run/nexus/jelly#ARcA6P//QsWT4bmjMCwwyKbCteKCrFT///8zMg 3 बाइट्स बचाता है।
— डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.