बिट फ़्लोटिंग सीक्वेंस

Question

थोड़ा से तैरता LSB को MSB एक स्थिति हर बार जब तक यह करने के लिए तैरता चलती शीर्ष कंटेनर की:

0000
0001
0010
0100
1000

एक बार जब एक बिट ऊपर की ओर तैरता है, तो दूसरा बिट अपनी यात्रा शुरू करता है और जब यह दूसरे बिट से मिलता है तो रुक जाता है:

1001
1010
1100

यह तब तक होता है जब तक कंटेनर बिट्स से भर नहीं जाता है:

1101
1110
1111

चुनौती

पूर्णांक संख्या को देखते हुए, बिट्स की संख्या के कंटेनर के लिए " बिट फ्लोटिंग सीक्वेंस " को आउटपुट करें ।

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

उदाहरण

केवल संख्यात्मक अनुक्रम आवश्यक है, बाइनरी प्रतिनिधित्व उदाहरण के रूप में दिखाया गया है:

• के लिए 1 :0 1

  0 -> 0
  1 -> 1
  

• के लिए 3 :0 1 2 4 5 6 7

  000 -> 0
  001 -> 1
  010 -> 2
  100 -> 4
  101 -> 5
  110 -> 6
  111 -> 7
  

• के लिए 4 :0 1 2 4 8 9 10 12 13 14 15

  0000 -> 0
  0001 -> 1
  0010 -> 2
  0100 -> 4
  1000 -> 8
  1001 -> 9
  1010 -> 10
  1100 -> 12
  1101 -> 13
  1110 -> 14
  1111 -> 15
  

• के लिए 8 :0 1 2 4 8 16 32 64 128 129 130 132 136 144 160 192 193 194 196 200 208 224 225 226 228 232 240 241 242 244 248 249 250 252 253 254 255

  00000000 -> 0
  00000001 -> 1
  00000010 -> 2
  00000100 -> 4
  00001000 -> 8
  …
  …
  …
  11111000 -> 248
  11111001 -> 249
  11111010 -> 250
  11111100 -> 252
  11111101 -> 253
  11111110 -> 254
  11111111 -> 255
  

Comments

क्या हम किसी भी क्रम में अनुक्रम का उत्पादन कर सकते हैं (यानी उलटा), या क्या उन्हें सबसे कम से उच्चतम क्रमबद्ध किया जाना है?

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

क्या हम तैरते हुए उत्पादन कर सकते हैं? जैसे[0.0, 1.0]

— ग्रैमी

क्या हम बाइनरी प्रतिनिधित्व का उपयोग कर उत्पादन कर सकते हैं?

— नील

क्या हम शून्य अनुक्रमित अनुक्रम का उत्पादन कर सकते हैं? यानी0 -> [0, 1]

— २३:३६ पर

Answer 1

05AB1E , 10 बाइट्स

LRL˜Íoî.¥ï

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

L                 # range [1..input]
 R                # reversed
  L               # convert each to a range: [[1..input], [1..input-1], ..., [1]]
   ˜              # flatten
    Í             # subtract 2 from each
     o            # 2**each
      î           # round up (returns a float)
       ï          # convert to integer
        .¥        # undelta

Comments

मुझे लगता है कि एक मेटा-पोस्ट कहीं है जो .0पूर्णांक के लिए डिफ़ॉल्ट रूप से तैरने की अनुमति देता है , लेकिन निश्चित नहीं है। मैं आमतौर पर ïफुटर को सुंदर-प्रिंट में रखता हूं और इसे बाइट-काउंट में शामिल नहीं करता हूं।

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

Answer 2

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

y=n=2**input()
while y:print n-y;y=y&y-1or~-y

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

यह 2**nइनपुट के अनुक्रम में प्रत्येक पद को घटाकर उत्पन्न करने के लिए छोटा हो जाता है n। यदि हम उनके द्विआधारी विस्तार को n=5देखते हैं, तो नीचे , हम बाइनरी विस्तार में 1 के त्रिकोण का एक अच्छा पैटर्न देखते हैं।

100000  32
011111  31
011110  30
011100  28
011000  24
010000  16
001111  15
001110  14
001100  12
001000  8
000111  7
000110  6
000100  4
000011  3
000010  2
000001  1

प्रत्येक नंबर को पिछले एक से बाइनरी विस्तार में सबसे सही हटाकर प्राप्त किया जाता है, सिवाय इसके कि नंबर 0 बना देगा, हम इसके बजाय 1 घटाते हैं, 1 का एक नया ब्लॉक बनाते हैं जो एक नया छोटा त्रिकोण शुरू करता है। यह के रूप में कार्यान्वित किया जाता है y=y&y-1or~-y, जहां y&y-1सबसे दायीं ओर का 1 दूर करने के लिए एक सा चाल है, और or~-yदेता है y-1बजाय कि अगर मान 0 था।

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

def f(n,x=0):1%n;print x;f(n-x%2,x+(x%2**n or 1))

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

एक फ़ंक्शन जो प्रिंट करता है, त्रुटि के साथ समाप्त होता है। नीचे दिया गया अधिक अच्छा कार्यक्रम अधिक लंबा हो गया।

51 बाइट्स

n=input()
x=0
while n:n-=x%2;print x;x+=x%2**n or 1

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

Answer 3

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

RUḶ’F2*ĊÄŻ

पोर्ट @Grimy का 05AB1E उत्तर है , इसलिए उसे सुनिश्चित करें!
-1 बाइट @ ग्रीम को धन्यवाद ।

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

स्पष्टीकरण:

R           # Create a list in the range [1, (implicit) argument]
 U          # Reverse it to [argument, 1]
  Ḷ         # Create an inner list in the range [0, N) for each value N in this list
   ’        # Decrease each by 1
    F       # Flatten the list of lists
     2*     # Take 2 to the power each
       Ċ    # Ceil
        Ä   # Undelta (cumulative sum) the list
         Ż  # And add a leading 0
            # (after which the result is output implicitly)

Comments

R_2-> Ḷ’-1 के लिए। Ḷहै केवल समझदार रेंज , मैं वास्तव में चाहते हैं 05AB1E इसके लिए एक एकल byter था।

— ग्रिमी

@Grimy आह, मैं कैसे याद किया कि एक। मैंने रेंज की खोज की और इसे किसी तरह से छोड़ दिया जाना चाहिए था ..>> धन्यवाद!

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

Answer 4

पर्ल 5 ( -n), 41 40 बाइट्स

-1 बाइट थेल्स से एक्सकली

map{/01.*1/||say oct}glob"0b"."{0,1}"x$_

TIO

• "{0,1}"x$_: स्ट्रिंग "{0,1}"को n बार दोहराया जाता है
• "0b". : के लिए सहमति "0b"
• glob : ग्लोब विस्तार (कार्टेशियन उत्पाद)
• map{... }: प्रत्येक तत्व के लिए
• /01.*1/||: तब छोड़ना जब 01किसी चीज का अनुसरण करना1
• say oct : दशमलव में परिवर्तित करने और कहने के लिए

Comments

40

— Xcali

Answer 5

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

जब संदेह हो, तो xnor की विधि का उपयोग करें ।

n=>(g=x=>x?[n-x,...g(x&--x||x)]:[])(n=1<<n)

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

---

जावास्क्रिप्ट (ईएस 6),  59 57 55  52 बाइट्स

f=(n,x=0)=>x>>n?[]:[x,...f(n,x+=x+(x&=-x)>>n|!x||x)]

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

कैसे?

$p(x)$$2$$x$$p(0)=0$

$x$$-x$$1$$x$

$$p(52)=52 \operatorname{AND}-52=4$$

$p$$a_n$$a_n(0)=0$

$$a_n(k+1)=\cases{ a_n(k)+p(a_n(k)), & \text{if $p(a_n(k))\neq0$ and $a_n(k)+p(a_n(k))<2^n$}\\ a_n(k)+1, & \text{otherwise} }$$

टिप्पणी की गई

f = (                   // f is a recursive function taking:
  n,                    //   n = input
  x = 0                 //   x = current term of the sequence
) =>                    //
  x >> n ?              // if x is greater than or equal to 2**n:
    []                  //   stop recursion
  :                     // else:
    [                   //   update the sequence:
      x,                //     append the current term to the sequence
      ...f(             //     do a recursive call:
        n,              //       pass n unchanged
        x +=            //       update x:
          x + (x &= -x) //         given x' = lowest bit of x set to 1:
          >> n          //         if x + x' is greater than or equal to 2**n
          | !x          //         or x' is equal to 0: add 1 to x
          || x          //         otherwise, add x' to x
      )                 //     end of recursive call
    ]                   //   end of sequence update

Answer 6

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

n=input()
a=0
print 0
while n:
 for j in range(n):print a+2**j
 n-=1;a+=2**n

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

Answer 7

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

{0 x$_,{say :2($_);S/(0)1|0$/1$0/}...1 x$_}

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

अनाम कोड ब्लॉक जो एक नंबर लेता है और नए सिरे से अलग किए गए अनुक्रम को आउटपुट करता है। 0 दोहराया n बार फिर या तो जगह के साथ शुरू करने से यह काम करता है 01के साथ 10या पिछले 0एक साथ 1नंबर तक सिर्फ लोगों को है।

या 40 बाइट्स, नाहुएल फौइलुल के दृष्टिकोण का उपयोग करते हुए

{grep /010*1/|{say :2($_)},[X~] ^2 xx$_}

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

Comments

" तो या तो जगह 01के साथ 10या पिछले 0एक साथ 1नंबर तक सिर्फ लोगों को है " यह एक प्रतिभाशाली चाल है!

— पेपरबर्डमास्टर

Answer 8

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

f=lambda i,n=0,b=1:[n][i:]or[n]+f(i-1/b,n^b+b/2,b>>i or 2*b)

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

---

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

f=lambda n:[0][n:]or[0]+[2**i for i in range(n-1)]+[x|1<<n-1for x in f(n-1)]

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

Answer 9

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

n=0
i=2**input()-1
while n<=i:print n;d=n&(~-n^i)or 1;n+=n+d>i or d

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

Answer 10

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

def f(n,c=0):
 while c<2**n:yield c;r=c&-c;c+=c+r>>n or r or 1

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

यह विचार कमोबेश @ अरनौलड के समाधान के समान है ।

एक और 65-बाइट समाधान:

lambda n:g(2**n-1)
g=lambda c:[0][c:]or g(c-((c&-c)//2 or 1))+[c]

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

Answer 11

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

⁼þ‘ṚÄUo€ƊẎQḄ

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

Answer 12

05AB1E , 13 12 बाइट्स

Tsãʒ1ÛSO2‹}C{

-1 बाइट के लिए धन्यवाद @ ग्रीम (यहां उनके छोटे दृष्टिकोण पर एक नज़र डालें)।

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

स्पष्टीकरण:

T             # Push 10
 sã           # Swap to get the (implicit) input, and get the cartesian product with "10"
   ʒ          # Filter it by:
    1Û        #  Remove leading 1s
      SO      #  Get the sum of the remaining digits
        !     #  Check that the sum is either 0 or 1 by taking the factorial
              #  (NOTE: Only 1 is truthy in 05AB1E)
         }C   # After the filter: convert all remaining strings from binary to integer
           {  # And sort (reverse) them
              # (after which the result is output implicitly)

Comments

वैकल्पिक 13 oL<ʒbIj1Û1¢2‹:। ऐसा नहीं लगता कि मैं इसे कम कर सकता हूं।

— ग्रैमी

@ जिस्म मैं बस था oL<ʒbIj1ÛSO2‹और यह देखने की कोशिश कर रहा था कि मेरी गलती कहाँ थी। :) लेकिन मुझे यह देखकर खुशी हुई कि आप बदलाव के लिए मेरे किसी एक उत्तर के लिए एक छोटा संस्करण नहीं पा सके हैं। ; पी (inb4 आप सभी xD के बाद एक छोटा पाते हैं)

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

@ मुझे लगता है कि SO2‹किसी भी तरह शायद 3 बाइट्स हो सकते हैं, लेकिन मैं इसे नहीं देख रहा हूं और यह भी पूरी तरह से निश्चित नहीं है .. कुछ विकल्प हैं, जैसे SO1~या SÆ>d, लेकिन मैं एक 3-बटर को खोजने में असमर्थ हूं।

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

10 एक पूरी तरह से अलग दृष्टिकोण के साथ

— ग्रैमी

आपकी भावना सही थी, मुझे सिर्फ एक 3-बायटर मिला SO!:। मुझे यकीन है कि मेरे पास कुछ पुराने जवाब हैं, 2‹जो इसका फायदा उठा सकते हैं।

— ग्रिममी

Answer 13

रेटिना , 26 बाइट्स

.+
*0
L$w`.(.*)
$.`*1$'1$1

इसे ऑनलाइन आज़माएं! बाइनरी में आउटपुट। यदि यह स्वीकार्य नहीं है, तो 39 बाइट्स के लिए:

.+
*0
L$w`.(.*)
$.`*1$'1$1
+`10
011
%`1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
*0

इनपुट को nशून्य की एक स्ट्रिंग में परिवर्तित करें ।

L$w`.(.*)

सभी संभव गैर-खाली सबस्ट्रिंग का मिलान करें।

$.`*1$'1$1

प्रत्येक विकल्प के लिए, आउटपुट: 0s के साथ उपसर्ग बदल गया1 ; प्रत्यय; प्रारंभिक के साथ मैच 0बदल गया 1।

+`10
011
%`1

बाइनरी से दशमलव में परिवर्तित करें।

Answer 14

ब्रेकीलॉग , 27 बाइट्स

1;0|⟦₅;2z^₍ᵐLtT&-₁↰+ᵐ↙T,L,0

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

आउटपुट आउट ऑफ ऑर्डर और डुप्लिकेट के साथ। अगर यह ठीक नहीं है, doतो अंत में निपटें ।

Answer 15

चारकोल , 19 बाइट्स

Ｉ⮌Ｅ⊕θＥι⁺⁻Ｘ²ＩθＸ²ιＸ²λ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

    θ               Input
   ⊕                Incremented
  Ｅ                 Map over implicit range
      ι             Outer index
     Ｅ              Map over implicit range
           Ｉθ       Input cast to integer
               ι    Outer index
                  λ Inner index
         Ｘ²  Ｘ² Ｘ²  Power of 2
       ⁺⁻           Subtract and add
 ⮌                  Reverse outer list
Ｉ                   Cast to string
                    Implicitly print

Answer 16

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

map{say$-;$-+=2**$_}0,0..$_-2;$_--&&redo

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

Answer 17

रेटिना , 24 बाइट्स

.+
*0
/0/+<0`(0)1|0$
1$1

बाइनरी में आउटपुट। इनपुट में एक अनुगामी न्यूलाइन होनी चाहिए।

स्पष्टीकरण पर प्रयास करें:

.+              #match the entire input
*0              #replace it with that many zeroes
/0/+<0`(0)1|0$  #while the string has a 0, substitute the first match and output
1$1             #if 01 is present in the string, replace it with 10, else replace the last character with $

मैंने /0/विकल्पों को फिर से व्यवस्थित करके 3 बाइट्स लंबे रेगेक्स विकल्प से बचने की कोशिश की , लेकिन नहीं कर सका।

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

Comments

मुझे नहीं लगता कि बाइनरी में आउटपुट की अनुमति है। यह पूछने पर कि क्या यह अनुमति दी गई है, एक टिप्पणी है, लेकिन यह मान लेना बेहतर है कि आप पूछने वाले का जवाब नहीं दे सकते हैं

— जो किंग

Answer 18

सी (क्लैंग) , 73 बाइट्स

o,j,y;f(x){for(o=j=0;printf("%d ",o),x;o+=y+!y,y+=y+!y)j=!j?y=0,--x:--j;}

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

for(o=j=0;printf("%d ",o),x;  o+=y+!y, y+=y+!y) 
// adds 1, 1+1=>2 , 2+2=> 4 .... sequence

 j=!j?y=0,--x:--j; 
// uses ternary instead of nested loop to decrement 'x' when 'j' go to 0

Answer 19

k4, 28 24 बाइट्स

0,+\"j"$2 xexp,/-1+|,\!:

@ ग्रिमी का दृष्टिकोण k4 तक पहुंच गया

संपादित करें: -4 ngn के लिए धन्यवाद!

Comments

!:'1+|!:->|,\!:

— ngn

आप के बाद अंतरिक्ष निकाल सकते हैंxexp

— NGN

@ng, |,\!:अब यह स्पष्ट है कि मैं इसे देख रहा हूँ!

— घसीट