La sequenza contiene la rappresentazione decimale dei numeri binari della forma:, 10101...dove l'ennesimo termine ha n bit.

La sequenza è probabilmente più semplice da spiegare mostrando semplicemente le relazioni tra le rappresentazioni binarie e decimali dei numeri:

0       ->  0
1       ->  1
10      ->  2
101     ->  5
1010    ->  10
10101   ->  21
101010  ->  42

Sfida:

Prendi un numero intero di input ne restituisce i primi n numeri nella sequenza. Puoi scegliere di avere la sequenza 0 indicizzata o 1 indicizzata.

Casi test:

n = 1   <- 1-indexed
0

n = 18
0, 1, 2, 5, 10, 21, 42, 85, 170, 341, 682, 1365, 2730, 5461, 10922, 21845, 43690, 87381

Le spiegazioni sono incoraggiate, come sempre.

Questo è OEIS A000975 .

Python 2 , 36 byte

lambda n:[2**i*2/3for i in range(n)]

Provalo online! Spiegazione: La rappresentazione binaria di è quindi rimasta semplicemente per moltiplicarla per una potenza appropriata di 2 e prendere la parte intera.$\frac{2}3$0.101010101...

05AB1E , 4 byte

2 byte salvati usando il trucco 2/3 di Neil

Lo3÷

Provalo online!

Spiegazione

L      # push range [1 ... input]
 o     # raise 2 to the power of each
  3÷   # integer division of each by 3

05AB1E , 6 byte

TRI∍ηC

Provalo online!

Spiegazione

T        # push 10
 R       # reverse it
  I∍     # extend to the lenght of the input
    η    # compute prefixes
     C   # convert each from base-2 to base-10

Gelatina , ... 4 byte

Grazie miglia per -1 byte!

ḶḂḄƤ

Provalo online!

Spiegazione:

Ḷ     Ḷowered range, or UnḶength. Get [0, 1, 2, 3, ..., n-1]
 Ḃ    Ḃit. Get the last bit of each number. [0, 1, 0, 1, ...]
   Ƥ  for each Ƥrefixes [0], [0, 1], [0, 1, 0], [0, 1, 0, 1], ...
  Ḅ   convert it from Ḅinary to integer.

Gelatina , 4 byte

La versione di Jonathan Allan.

Ḷ€ḂḄ

Provalo online!

Ḷ     Ḷowered range, or UnḶength.
 €    Apply for €each. Automatically convert the number n
      to the range [1,2,..,n]. Get [[0],[0,1],[0,1,2],..].
  Ḃ   Ḃit. Get the last bit from each number.
      Current value: [[0],[0,1],[0,1,0],..]
   Ḅ  Convert each list from Ḅinary to integer.

Una versione basata sul trucco 2/3 di Neil fornisce 5 byte, vedi la cronologia delle revisioni.

MATL , 5 byte

:WI/k

Basato sulla risposta di Neil .

Spiegazione

:       % Implicit input, n. Push range [1 2 ... n]
W       % 2 raised to that, element-wise. Gives [2 4 ...2^n] 
I       % Push 3
/       % Divide, element-wise
k       % Round down, element-wise. Implicit display

Provalo online!

MATL , 9 byte

:q"@:oXBs

Provalo online!

Spiegazione

:       % Implicit input n. Range [1 2 ... n]
q       % Subtract 1, element-wise: gives [0 1 ... n-1]
"       % For each k in [0 1 ... n-1]
  @     %   Push k
  :     %   Range [1 2 ... k]
  o     %   Modulo 2, element-wise: gives [1 0 1 ...]
  XB    %   Convert from binary to decimal
  s     %   Sum. This is needed for k=0, to transform the empty array into 0
        % Implicit end. Implicit display

Python 2 , 45 37 36 byte

^{-3 byte grazie a user202729
-1 byte grazie a mathmandan}

s=0
exec"print s;s+=s+~s%2;"*input()

Provalo online!

Python 3, 68 61 54 48 43 byte

c=lambda x,r=0:x and[r]+c(x-1,2*r+~r%2)or[]  

Grazie a user202729 per aver contribuito a salvare 19 byte e ovs per aver contribuito a salvare 6 byte.

Provalo online

Buccia , 7 byte

mḋḣ↑Θݬ

Provalo online!

Basato su 1, quindi l'input n fornisce i primi n risultati.

Spiegazione

     ݬ   The infinite list [1, 0, 1, 0, 1, ...]
    Θ     Prepend a zero.
   ↑      Take the first n elements.
  ḣ       Get the prefixes of that list.
mḋ        Interpret each prefix as base 2.

APL (Dyalog Unicode) , ^{SBCS da} 11 byte

Assume ⎕IO( I NDICE O rigine) di essere 0, che è di default su molti sistemi. Funzione prefisso tacito anonimo. 1-indicizzati.

(2⊥⍴∘1 0)¨⍳

Provalo online!

⍳ ɩ ndices 0… n − 1

(... )¨ applica la seguente funzione tacita a ciascuno

 ⍴∘1 0 ridimensionare ciclicamente l'elenco [1,0]a quella lunghezza

 2⊥ convertire da base-2 (binario) a numero normale

Perlv5.10 -n , 24 + 1 byte

-3 byte grazie a Nahuel Fouilleul !

say$v=$v*2|$|--while$_--

Provalo online!

Stessa logica della mia versione di Ruby, ma più breve perché perl è più concisa. Per qualche strana ragione, printnon farebbe un separatore (dannazione!), Così ho dovuto utilizzare sayda v5.10;in modo che questo periodo, io non sono sicuro di come a segnare questo, quindi me ne vado fuori per ora ?. ..

Spiegazione

say    # Like shouting, but milder.
  $v = $v*2 | $|-- # Next element is this element times 2 bitwise-OR
                   # with alternating 0 1 0 1..., so 0b0, 0b1, 0b10, 0b101...
                   # $. is OUTPUT_AUTOFLUSH, which is initially 0 and
                   #   setting all non-zero values seem to be treated as 1
  while $_-- # do for [input] times

Haskell , 33 byte

l=1:0:l
($scanl((+).(2*))0l).take

Provalo online!

APL (Dyalog) , 7 byte

⌊3÷⍨2*⍳

Provalo online!

APL (Dyalog) , 11 byte

(2⊥2|⍳)¨1+⍳

Provalo online!

Usi ⎕IO←0.

C , 81 55 59 byte

1 indicizzato.

i,j;f(c){for(i=j=0;i<c;)printf("%d ",i++&1?j+=j+1:(j+=j));}

Programma completo, meno golf:

i;j;main(c,v)char**v;{c=atoi(*++v);for(;i<c;i++)printf("%d ",i&1?j+=j+1:(j+=j));}

Provalo online!

EDIT 2: Ero supposto che le funzioni non dovevano essere riutilizzabili ora che ci penso, ha perfettamente senso che dovrebbero essere riutilizzabili: P

EDIT: Avevo il malinteso che avrei dovuto includere l'intero programma nella risposta, risulta che avevo solo bisogno della funzione che lo fa. Bello.

Sono abbastanza sicuro di potermi radere qualche byte qua e là. Ho già impiegato alcuni trucchi. Una grande parte del programma è dedicata a ottenere l'argomento e trasformarlo in un int. Questo è il mio primo codice golf. Se sto facendo qualcosa di sbagliato, dimmi: P

Haskell , 47 40 53 49 44 40 34 byte

-4 byte grazie all'utente202729
-6 byte grazie a Laikoni

(`take`l)
l=0:[2*a+1-a`mod`2|a<-l]

Provalo online!

Rubino , 26 byte

->n{(1..n).map{|i|2**i/3}}

Provalo online!

Batte tutte le risposte rubino più vecchie.

Spiegazione

1/3in binario sembra 0.01010101..., quindi se lo moltiplichi per potenze di due, ottieni:

n| 2^n/3
-+---------
1|0.1010101...
2|01.010101...
3|010.10101...
4|0101.0101...
5|01010.101...
6|010101.01...

Ma Ruby riporta i numeri sulla divisione int, dandomi la sequenza di cui ho bisogno.

J , 9 byte

[:#.\2|i.

Come funziona?

i. - elenco 0..n-1

2| - le voci dell'elenco mod 2

\ - tutti i prefissi

#. - in decimale

[: - tappi la forcella (dato che ho un numero pari (4) di verbi)

Provalo online!

Retina , 28 byte

)K`0
"$+"+¶<`.+
$.(*__2*$-1*

Provalo online!

Basato su 0, quindi input n dà i primi n + 1 risultati.

Spiegazione

Utilizza la ricorsione da OEIS:

a(n) = a(n-1) + 2*a(n-2) + 1

Andiamo attraverso il programma:

)K`0

Questa è una fase costante: scarta l'input e imposta la stringa di lavoro su 0, il valore iniziale della sequenza. Questo )avvolge questa fase in un gruppo. Quel gruppo stesso non fa nulla, ma quasi tutte le fasi (comprese le fasi del gruppo) registrano il risultato in un registro e 0per far funzionare il programma sono necessarie due copie del registro.

"$+"+¶<`.+
$.(*__2*$-1*

C'è un sacco di configurazioni qui: "$+"+avvolge il palco in un ciclo. La "$+"viene trattata come una sostituzione, e $+si riferisce all'ingresso del programma, ossia n . Ciò significa che il ciclo è eseguito n volte.

Quindi ¶<avvolge ogni iterazione in uno stage di output, che stampa l' input dello stage con un avanzamento riga finale (quindi la prima iterazione stampa lo zero, la seconda iterazione stampa il risultato della prima iterazione e così via).

Lo stage stesso sostituisce l'intera stringa di lavoro con la sostituzione sull'ultima riga. Quello utilizza una parentesi di chiusura implicita e argomenti impliciti per l'operatore di ripetizione *, quindi in realtà è l'abbreviazione di:

$.($&*__2*$-1*_)

Il materiale all'interno delle parentesi può essere suddiviso in tre parti:

• $&*_: fornisce una stringa di a (n-1) _ s.
• _: dà un singolo _.
• 2*$-1*_: fornisce una stringa di 2 * a (n-1) _ . Il si $-1riferisce al penultimo risultato nel registro dei risultati, vale a dire l'iterazione del ciclo prima dell'ultimo. Ecco perché all'inizio avevamo bisogno di copie dello zero nel registro, altrimenti ciò si riferirebbe all'input del programma sulla prima iterazione.

Quindi $.(…)misura la lunghezza della stringa risultante. In altre parole, abbiamo calcolato a(n) = a(n-1) + 1 + 2*a(n-2)passando per unario (non proprio se:$.(…) è pigro e non ne valuta effettivamente il contenuto se può determinare la lunghezza risultante direttamente attraverso l'aritmetica, quindi è anche abbastanza efficiente).

Il risultato dell'iterazione del ciclo finale ( n + 1 ° elemento della sequenza) viene stampato a causa dell'output implicito di Retina alla fine del programma.

Brain-Flak , 36 byte

{([()]{}<((({}<>)<>){}([{}]()))>)}<>

Provalo online!

Spiegazione:

Il numero successivo nella sequenza è ottenuto da n*2+1o n*2+0.

{([()]{}< Loop input times
  (
   (({}<>)<>){} Copy n to other stack; n*2
   ([{}]())  i = 1-i
  ) push n*2 + i
>)} End loop
<> Output other stack

Rubino 42 41 43 41 37 35 31 33 30 byte

-2 byte grazie a Unihedron

-3 byte grazie a GB

->x{a=0;x.times{a-=~a+p(a)%2}}

Provalo online!

> <> , 22 + 3 (-v flag) byte

0:nao::1+2%++$1-:?!;$!

Provalo online!

Spiegazione

Lo stack viene inizializzato con il contatore loop.

0:nao                  : Push 0 to the stack, duplicate and print with a new line.
                         [7] -> [7, 0]
     ::1+              : Duplicate the stack top twice more then add 1 to it.
                         [7, 0] -> [7, 0, 0, 1]
         2%++          : Mod the stack top by 2 then add all values on the stack bar the loop counter.
                         [7, 0, 0, 1] -> [7, 1]
             $1-:?!;$! : Swap the loop counter to the top, minus 1 from it and check if zero, if zero stop the program else continue.

Java 8, 115 81 80 52 byte

n->{for(int i=2;n-->0;i*=2)System.out.println(i/3);}

Python 2 di Port of @Neil .
1 indicizzato ed emesso direttamente, ogni valore su una linea separata.

Spiegazione:

Provalo online.

n->{                           // Method with integer parameter and no return-type
  for(int i=2;                 //  Start integer `i` at 2
      n-->0;                   //  Loop `n` times:
      i*=2)                    //    Multiply `i` by 2 after every iteration
    System.out.println(i/3);}  //   Print `i` integer-divided by 3 and a new-line

Risposta di vecchi 80 byte:

n->{String t="",r=t;for(Long i=0L;i<n;)r+=i.parseLong(t+=i++%2,2)+" ";return r;}

1 input indicizzato e Stringoutput delimitato da spazi

Spiegazione:

Provalo online.

n->{                             // Method with integer parameter and String return-type
  String t="",r=t;               //  Temp and result-Strings, both starting empty
  for(Long i=0L;i<n;)            //  Loop from 0 to `n` (exclusive)
    r+=                          //   Append the result-String with:
       i.parseLong(        ,2);  //    Binary to integer conversion
                   t+=           //     append the temp-String with:
                      i  %2      //      current index `i` modulo-2
                       ++        //      and increase `i` by one afterwards
       +" ";                     //    + a space
  return r;}                     //  Return the result-String

Perl 6 ,  35 30 27 25  20 byte

{[\~](0,+!*...*)[^$_]».&{:2(~$_)}}

Provalo (35)

{(0,{$_*2+|($+^=1)}…*)[^$_]}

Provalo (30)

{(⅓X*(2,4,8…2**$_))».Int}

Provalo (30)

{(⅔,* *2…*)[^$_]».Int}

Provalo (27)

{((2 X**1..$_)X/3)».Int}

Provalo (25)

{(2 X**1..$_)Xdiv 3}

Provalo (20)

Allargato:

{
 (
  2                  # 2
    X**              # cross to the power of
       1..$_         # Range from 1 to the input (inclusive)
            )

             Xdiv    # cross using integer divide
                  3  # by 3
}

Python 2 , 33 byte

s=2
exec"print s/3;s*=2;"*input()

Provalo online!

Python 2 , 34 byte

f=lambda n:n*[f]and[2**n/3]+f(n-1)

Provalo online!

Restituisce in ordine inverso.

C, 47 46 byte

a;f(n){for(a=0;n--;a+=a-~a%2)printf("%d ",a);}

L'accumulatore ainizia con zero. Ad ogni passaggio, lo raddoppiamo ( a+=a) e ne aggiungiamo uno se il precedente bit meno significativo era zero ( !(a%2)o, equivalentemente,-(~a)%2 ).

Programma di test

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        f(atoi(*argv));
        puts("");
    }
}

risultati

$ ./153783 1 2 3 4 5 6
0 
0 1 
0 1 2 
0 1 2 5 
0 1 2 5 10 
0 1 2 5 10 21 

Japt , 10 9 7 6 byte

Tutti derivati ​​indipendentemente da altre soluzioni.

1-indicizzati.

õ!²mz3

Provalo

Spiegazione

õ        :[1,input]
 !²      :Raise 2 to the power of each
   m     :Map
    z3   :Floor divide by 3

Provalo

Versione a 7 byte

õ_ou ì2

Provalo

õ            :[1,input]
 _           :Pass each through a function
   o         :[0,current element)
    u        :Modulo 2 on above
      ì2     :Convert above from base-2 array to base-10

Versione a 9 byte

õ_îA¤w)n2

Provalo

õ            :[1,input]
 _           :Pass each through a function
   A         :10
    ¤        :Convert to binary
     w       :Reverse
  î          :Repeat the above until it's length equals the current element
      )      :Close nested methods
       n2    :Convert from binary to base-10

Haskell , 52 byte

(`take`map a[0..])
a 0=0
a 1=1
a n=a(n-1)+2*a(n-2)+1

Provalo online!

MATL , 7 byte

:&+oRXB

Provalo online!

Spiegazione:

         % Implicitly grab input, n
:        % Range: 1 2 ... n

 &+      % Add the range to itself, transposed
         % 2 3 4 5 ...
         % 3 4 5 6 ...
         % 4 5 6 7 ...
         % 5 6 7 8 ...

   o     % Parity (or modulus 2)
         % 0 1 0 1 ...
         % 1 0 1 0 ...
         % 0 1 0 1 ...
         % 1 0 1 0 ...

    R    % Upper triangular matrix:
         % 0 1 0 1
         % 0 0 1 0
         % 0 0 0 1
         % 0 0 0 0

    XB   % Convert rows to decimal:
         % [5, 2, 1, 0]
         % Implicitly output

L'output sarebbe 0, 1, 2, 5 ...se Pfosse aggiunto alla fine ( flip), rendendolo 8 byte.

Rubino -n ,32 30 + 1 byte

Dal momento che abbiamo esattamente 1 riga di input, $.è godly conveniente!

EDIT: Sono sorpreso di essere riuscito a superare me stesso, ma sembra usare -nquale conta come 1 (secondo la regola 2 in condizioni speciali predefinite , poiché Ruby può essere eseguito con ruby -e 'full program'(quindi -nè 1) tutte le istanze di getscui viene utilizzata solo una volta può essere abbattuto 1 carattere in questo modo; credo che questa sia una pietra miliare per il rubino, per favore parla se non sei d'accordo con questo treno di pensieri prima di riutilizzarlo ripetutamente in futuro)

v=0
?1.upto($_){p v=v*2|$.^=1}

Provalo online!

Spiegazione

# while gets(); -- assumed by -n
v=0            # First element of the sequence
?1.upto($_){   # Do from "1" to "$LAST_READ_LINE" aka: Repeat [input] times
  p            # print expression
  v=v*2|$.^=1  # Next element is current element times two
               # bitwise-or 0 or 1 alternating
               # $. = lines of input read so far = 1 (initially)
}
# end           -- assumed by -n

AWK a=0 , 31 byte

{for(;$1--;a=a*2+1-a%2)print a}

Provalo online!

Usa la formula spudoratamente rubata da questa altra risposta di Ruby.

Pur non avendo a=0funzionerebbe (awk tratta "vuoto" come 0), il primo elemento di 0 non verrà stampato invece essere un emptylinea, che mentre sosterrei è un'uscita valida probabilmente non passerà, quindi non c'è a=0che può essere inserito come argomento della riga di comando.

C, 52 byte

i,k;f(n){for(i=k=0;i<n;k=++i%2+2*k)printf("%d ",k);}

1-indicizzato

Provalo online!

brainfuck , 40 byte

,[>.>>[>]<[.->[>]+[<]+<]+<[[-<+>]>-<]<-]

Provalo online!

0-indicizzati. Input come codice char, output come unario con byte null che separano le serie di char code 1s. Presuppone celle a 8 bit a meno che non si desideri immettere oltre 255. Presuppone celle negative, sebbene ciò possa essere risolto a spese di diversi byte.

In precedenza, 50 byte

,[[<]>->>[<-<->>>>-<]<[->>++<<]>>+[-<<+>>]<<.<<+>]

Provalo online!

Input come codice char, output come codice char. 1-indicizzati. Probabilmente potrebbe essere giocato un po 'a golf.

@Unihedron sottolinea che ho dimenticato di specificare che questo ha bisogno di celle di dimensioni infinite, altrimenti supera l'ottavo numero.