22

Un po galleggia dal LSB al MSB spostando una posizione ogni volta fino a che galleggia sulla parte superiore del contenitore:

Una volta che un bit galleggia verso l'alto, un altro bit inizia il suo viaggio e si interrompe quando incontra un altro bit:

1001
1010
1100

Questo accade fino a quando il contenitore non viene riempito con bit:

1101
1110
1111

Sfida

Dato un numero intero, genera la " Sequenza mobile di bit " per un contenitore di quel numero di bit.

Ogni termine della sequenza può essere separato da qualsiasi separatore di tua scelta.
Edit : Sequenza deve essere mostrata come numeri decimali interi, partendo dal primo therm: 0.
La dimensione del contenitore potrebbe essere maggiore di zero e fino al numero di bit dell'intero più grande supportato dalla lingua scelta. Si può presumere che l'input corrisponda sempre a questo requisito.

Esempi

È richiesta solo la sequenza numerica, la rappresentazione binaria è mostrata come esempio:

Per 1 :0 1
```
0 -> 0
1 -> 1
```

Per 3 :0 1 2 4 5 6 7

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

Per 4 :0 1 2 4 8 9 10 12 13 14 15

Per 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

code-golf sequence

— PaperBirdMaster
fonte

2

Possiamo emettere la sequenza in qualsiasi ordine (cioè invertito) o devono essere ordinati dal più basso al più alto?

— Kevin Cruijssen,

1

Possiamo produrre come float? Ad esempio[0.0, 1.0]

— Grimmy,

8

Possiamo produrre usando la rappresentazione binaria?

— Neil,

Possiamo emettere la sequenza indicizzata zero? vale a dire0 -> [0, 1]

— attinat

7

05AB1E , 10 byte

LRL˜Íoî.¥ï

Provalo online!

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

— Grimmy
fonte

2

Penso che ci sia un meta-post da qualche parte che permetta float .0di default per numeri interi, ma non sono sicuro. Personalmente di solito metto il ïfooter nel piè di pagina per stampare piuttosto e non lo includo nel conteggio dei byte.

— Kevin Cruijssen,

7

Python 2 , 45 byte

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

Provalo online!

Risulta più breve generare 2**nmeno ogni termine nella sequenza per l'input n. Se osserviamo la loro espansione binaria, sotto per n=5, vediamo un bel modello di triangoli di 1 nelle espansioni binarie.

Ogni numero viene ottenuto dal precedente rimuovendo quello più a destra dell'espansione binaria, tranne se ciò renderebbe il numero 0, sottraggiamo invece 1, creando un nuovo blocco di 1 che avvia un nuovo triangolo più piccolo. Questo è implementato come y=y&y-1or~-y, dove y&y-1è un piccolo trucco per rimuovere l'estrema destra, e or~-ydà y-1invece se quel valore era 0.

Python 2 , 49 byte

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

Provalo online!

Una funzione che stampa, terminando con errori. Il più bel programma qui sotto si è rivelato più lungo.

51 byte

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

Provalo online!

— XNOR
fonte

6

Gelatina , 11 10 byte

RUḶ’F2*ĊÄŻ

Porto di @Grimy 's risposta 05AB1E , quindi assicuratevi di upvote lui!
-1 byte grazie a @Grimy .

Provalo online.

Spiegazione:

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)

— Kevin Cruijssen
fonte

2

R_2-> Ḷ’per -1. Ḷè l'unica gamma sensata , vorrei davvero che 05AB1E avesse un solo byte per questo.

— Grimmy,

@Grimy Ah, come mi sono perso quello. Ho cercato il raggio d'azione e devo averlo ignorato in qualche modo ..>.> Grazie!

— Kevin Cruijssen,

4

Perl 5 ( `-n`), 41 40 byte

-1 byte ringrazia Xcali

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

TIO

"{0,1}"x$_ : la stringa "{0,1}" ripetuta n volte
"0b". : concatenato a "0b"
glob : espansione globale (prodotto cartesiano)
map{...} : per ogni elemento
/01.*1/||: saltare quando 01seguito da qualcosa allora1
say oct : per convertire in decimale e dire

— Nahuel Fouilleul
fonte

40

— Xcali,

4

JavaScript (ES6), 43 byte

In caso di dubbi, utilizzare il metodo di xnor .

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

Provalo online!

JavaScript (ES6), 59 57 55 52 byte

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

Provalo online!

Come?

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

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

p (52) = 52 E - 52 = 4

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

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

{un'}_{n} (K + 1) = {\begin{cases} {un'}_{n} (K) + p ({un'}_{n} (K)), & Se p ({un'}_{n} (K)) \neq 0 e {un'}_{n} (K) + p ({un'}_{n} (K)) < 2^{n} \\ {un'}_{n} (K) + 1, & altrimenti \end{cases}

$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} }$

Commentate

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

— Arnauld
fonte

3

Python 2 , 95 76 byte

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

Provalo online!

— TFeld
fonte

3

Perl 6 , 43 byte

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

Provalo online!

Blocco di codice anonimo che accetta un numero e genera la sequenza separata da newline. Funziona iniziando con 0 ripetute n volte, quindi sostituendo 01con 10o l'ultima 0con a 1fino a quando il numero è solo uno.

O 40 byte, usando l'approccio di Nahuel Fouilleul

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

Provalo online!

— Jo King
fonte

" quindi sostituendo 01con 10o l'ultimo 0con un 1fino a quando il numero è solo uno " È una mossa geniale!

— PaperBirdMaster,

3

Python 2 , 60 byte

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

Provalo online!

Python 3 , 76 byte

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

Provalo online!

— OVS
fonte

3

Python 2 , 67 byte

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

Provalo online!

— sette negativi
fonte

3

Python 3 , 62 byte

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

Provalo online!

L'idea è più o meno la stessa della soluzione di @ Arnauld .

Un'altra soluzione a 65 byte:

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

Provalo online!

— Joel
fonte

2

Gelatina , 12 byte

⁼þ‘ṚÄUo€ƊẎQḄ

Provalo online!

— Erik the Outgolfer
fonte

2

05AB1E , 13 12 byte

Tsãʒ1ÛSO2‹}C{

-1 byte grazie a @Grimy (dai un'occhiata anche al suo approccio più breve qui).

Provalo online o verifica tutti i casi di test .

Spiegazione:

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)

— Kevin Cruijssen
fonte

Alternate 13: oL<ʒbIj1Û1¢2‹. Non mi sembra di poterlo abbassare.

— Grimmy,

1

@Grimy ho appena avuto oL<ʒbIj1ÛSO2‹e stavo cercando di vedere dove fosse il mio errore. :) Ma sono felice di vedere che non riesci a trovare una versione più breve per una delle mie risposte per un cambiamento. ; p (inb4 ne trovi uno più corto dopo tutto xD)

— Kevin Cruijssen

1

@Grimy ho la sensazione SO2‹ in qualche modo possa essere di 3 byte, ma non lo vedo e non sono del tutto sicuro .. Ci sono alcune alternative, come SO1~o SÆ>d, ma non riesco a trovare un 3-byte.

— Kevin Cruijssen,

1

10 con un approccio completamente diverso

— Grimmy

1

La vostra sensibilità è stato bene, ho appena trovato un 3-byter: SO!. Abbastanza sicuro di avere alcune vecchie risposte 2‹che potrebbero trarne beneficio.

— Grimmy,

2

Retina , 26 byte

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

Provalo online! Uscite in binario. Se ciò non è accettabile, quindi per 39 byte:

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

Provalo online! Spiegazione:

.+
*0

Converti l'input in una stringa di nzeri.

L$w`.(.*)

Abbina tutte le possibili sottostringhe non vuote.

$.`*1$'1$1

Per ogni sottostringa, output: il prefisso con 0s è cambiato in 1s; il suffisso; la partita con l'iniziale è 0cambiata in 1.

+`10
011
%`1

Converti da binario a decimale.

— Neil
fonte

2

Brachylog , 27 byte

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

Provalo online!

Output fuori servizio e con duplicati. Se non va bene, attacca doalla fine.

— Stringa non correlata
fonte

1

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    θ               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

— Neil
fonte

1

Perl 5 , 40 byte

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

Provalo online!

— Grimmy
fonte

1

Retina , 24 byte

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

Uscite in binario. L'input dovrebbe avere una nuova riga finale.

Tentativo di spiegazione:

.+              #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 $

Ho cercato di evitare l' /0/opzione regex lunga 3 byte riorganizzando le opzioni, ma non ci sono riuscita.

Provalo online!

— il mio pronome è monicareinstate
fonte

Non penso che sia consentito l'output in binario. C'è un commento che chiede se è permesso, ma è meglio supporre che non puoi farlo fino a quando il richiedente non risponde

— Jo King

1

C (clang) , 73 byte

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;}

Provalo online!

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

— AZTECCO
fonte

1

k4, 28 24 byte

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

@ L'approccio di Grimy è stato portato su k4

modifica: -4 grazie a ngn!

— scarabocchio
fonte

1

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

— ngn

puoi rimuovere lo spazio dopoxexp

— ngn

@ngn, |,\!:ora sembra così ovvio che lo vedo!

— scarabocchio

Sequenza variabile bit

Sfida

Esempi

05AB1E , 10 byte

Python 2 , 45 byte

Gelatina , 11 10 byte

Perl 5 ( -n), 41 40 byte

JavaScript (ES6), 43 byte

JavaScript (ES6), 59 57 55 52 byte

Come?

Commentate

Python 2 , 95 76 byte

Perl 6 , 43 byte

Python 2 , 60 byte

Python 3 , 76 byte

Python 2 , 67 byte

Python 3 , 62 byte

Gelatina , 12 byte

05AB1E , 13 12 byte

Retina , 26 byte

Brachylog , 27 byte

Carbone , 19 byte

Perl 5 , 40 byte

Retina , 24 byte

C (clang) , 73 byte

k4, 28 24 byte

Perl 5 ( `-n`), 41 40 byte