A sequência contém a representação decimal dos números binários da forma:, em 10101...que o n-ésimo termo tem n bits.

A sequência é provavelmente mais fácil de explicar, mostrando apenas os relacionamentos entre as representações binária e decimal dos números:

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

Desafio:

Pegue um número inteiro de entrada ne retorne os primeiros n números na sequência. Você pode optar por ter a sequência indexada em 0 ou 1.

Casos de teste:

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

As explicações são incentivadas, como sempre.

Este é o OEIS A000975 .

Python 2 , 36 bytes

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

Experimente online! Explicação: A representação binária de éassim, resta simplesmente multiplicá-lo por uma potência apropriada de 2 e tomar a parte inteira.$\frac{2}3$0.101010101...

05AB1E , 4 bytes

2 bytes salvos usando o truque 2/3 de Neil

Lo3÷

Experimente online!

Explicação

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

05AB1E , 6 bytes

TRI∍ηC

Experimente online!

Explicação

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 bytes

Graças milhas por -1 byte!

ḶḂḄƤ

Experimente online!

Explicação:

Ḷ     Ḷ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 bytes

Versão de Jonathan Allan.

Ḷ€ḂḄ

Experimente 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.

Uma versão baseada no truque 2/3 de Neil fornece 5 bytes, consulte o histórico de revisões.

MATL , 5 bytes

:WI/k

Baseado na resposta de Neil .

Explicação

:       % 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

Experimente online!

MATL , 9 bytes

:q"@:oXBs

Experimente online!

Explicação

:       % 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 bytes

^{-3 bytes graças a user202729
-1 byte graças a mathmandan}

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

Experimente online!

Python 3, 68 61 54 48 43 bytes

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

Agradecemos a user202729 por ajudar a salvar 19 bytes e ovs por ajudar a salvar 6 bytes.

Experimente Online

Casca , 7 bytes

mḋḣ↑Θݬ

Experimente online!

Com base em 1, a entrada n fornece os primeiros n resultados.

Explicação

     ݬ   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) , 11 bytes ^SBCS

Assume ⎕IO( I ndex O rigin) como sendo 0, o padrão em muitos sistemas. Função de prefixo tácito anônimo. 1 indexado.

(2⊥⍴∘1 0)¨⍳

Experimente online!

⍳ ɩ ndices 0 ... n-1

(… )¨ Aplique a seguinte função tácita a cada

 ⍴∘1 0 remodelar ciclicamente a lista [1,0]com esse comprimento

 2⊥ converter do número base-2 (binário) para o normal

Perlv5.10 -n , 24 + 1 bytes

-3 bytes graças a Nahuel Fouilleul !

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

Experimente online!

Mesma lógica da minha versão do Ruby, mas mais curta porque o perl é mais conciso. Por alguma estranha razão, printnão faria um separador (caramba!), Então eu tive que usar sayfrom v5.10;para que isso funcionasse, não sei como pontuar isso, então estou deixando de fora por enquanto ?. ..

Explicação

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 bytes

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

Experimente online!

APL (Dyalog) , 7 bytes

⌊3÷⍨2*⍳

Experimente online!

APL (Dyalog) , 11 bytes

(2⊥2|⍳)¨1+⍳

Experimente online!

Usos ⎕IO←0.

C , 81 55 59 bytes

1 indexado.

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

Programa completo, menos golfe:

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

Experimente online!

EDIÇÃO 2: Eu assumi que as funções não precisavam ser reutilizáveis ​​agora que penso nisso; faz todo o sentido que elas precisem ser reutilizáveis: P

Edição: Eu estava sob o equívoco de que eu tinha que incluir todo o programa na resposta, acontece que eu só precisava da função que faz isso. Isso é bom.

Tenho certeza de que posso raspar alguns bytes aqui e ali. Eu já empreguei alguns truques. Uma grande parte do programa é dedicada a obter o argumento e transformá-lo em um int. Este é o meu primeiro código de golfe. Se estou fazendo algo errado, diga-me: P

Haskell , 47 40 53 49 44 40 34 bytes

-4 bytes graças ao usuário202729
-6 bytes graças a Laikoni

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

Experimente online!

Ruby , 26 bytes

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

Experimente online!

Supera todas as respostas ruby ​​mais antigas.

Explicação

1/3em binário parece 0.01010101..., então, se você o multiplicar por potências de dois, obtém:

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

Mas Ruby calcula os números na divisão int, fornecendo a sequência que eu preciso.

J , 9 bytes

[:#.\2|i.

Como funciona?

i. - lista 0..n-1

2| - os itens da lista mod 2

\ - todos os prefixos

#. - para decimal

[: - bata o garfo (como eu tenho o número par (4) de verbos)

Experimente online!

Retina , 28 bytes

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

Experimente online!

Com base em 0, então a entrada n fornece os primeiros n + 1 resultados.

Explicação

Usa a recursão do OEIS:

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

Vamos seguir o programa:

)K`0

Este é um estágio constante: descarta a entrada e define a cadeia de trabalho como 0o valor inicial da sequência. O )quebra esta fase em um grupo. Esse grupo em si não faz nada, mas quase todas as etapas (incluindo as de grupo) registram o resultado em um log, e precisaremos de duas cópias 0desse log para que o programa funcione.

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

Há várias configurações aqui: "$+"+envolve o palco em um loop. O "$+"é tratado como uma substituição e $+refere-se à entrada do programa, ou seja, n . Isso significa que o loop é executado n vezes.

Em seguida, ¶<agrupa cada iteração em um estágio de saída, que imprime a entrada do estágio com um avanço de linha à direita (para que a primeira iteração imprima o zero, a segunda iteração imprima o resultado da primeira iteração e assim por diante).

O estágio em si substitui toda a cadeia de trabalho pela substituição na última linha. Esse utiliza um parêntese de fechamento implícito e argumentos implícitos para o operador de repetição *, portanto, é realmente a abreviação de:

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

O material dentro dos parênteses pode ser dividido em três partes:

• $&*_: fornece uma sequência de a (n-1) _ s.
• _: dá um único _.
• 2*$-1*_: fornece uma sequência de 2 * a (n-1) _ . O $-1refere-se ao penúltimo resultado no log de resultados, ou seja, a iteração do loop antes do último. É por isso que precisamos fazer cópias do zero no log, caso contrário, isso se refere à entrada do programa na primeira iteração.

Em seguida, $.(…)mede o comprimento da sequência resultante. Em outras palavras, calculamos a(n) = a(n-1) + 1 + 2*a(n-2)passando por unário (na verdade, não: $.(…)é preguiçoso e, na verdade, não avalia seu conteúdo, se é possível determinar o comprimento resultante diretamente por meio da aritmética, portanto isso é bastante eficiente).

O resultado da iteração final do loop (o n + 1 o elemento da sequência) é impresso devido à saída implícita de Retina no final do programa.

Brain-Flak , 36 bytes

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

Experimente online!

Explicação:

O próximo número na sequência é obtido por n*2+1ou 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

Ruby 42 41 43 41 37 35 31 33 30 bytes

-2 bytes graças ao Unihedron

-3 bytes graças a GB

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

Experimente online!

> <> , 22 + 3 bytes (sinalizador -v)

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

Experimente online!

Explicação

A pilha é inicializada com o contador de 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 bytes

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

Porto da resposta Python 2 de @Neil .
1 indexado e emitido diretamente, cada valor em uma linha separada.

Explicação:

Experimente 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

Resposta antiga de 80 bytes:

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

Entrada indexada em 1 e Stringsaída delimitada por espaço

Explicação:

Experimente 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 bytes

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

Experimente (35)

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

Experimente (30)

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

Experimente (30)

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

Experimente (27)

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

Experimente (25)

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

Experimente (20)

Expandido:

{
 (
  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 bytes

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

Experimente online!

Python 2 , 34 bytes

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

Experimente online!

Retorna na ordem inversa.

C, 47 46 bytes

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

O acumulador acomeça com zero. Em cada etapa, dobramos ( a+=a) e adicionamos um se o bit menos significativo anterior era zero ( !(a%2)ou equivalente -(~a)%2).

Programa de teste

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

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

Resultados

$ ./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 

Japonês , 10 9 7 6 bytes

Todos derivados independentemente de outras soluções.

1 indexado.

õ!²mz3

Tente

Explicação

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

Tente

Versão de 7 bytes

õ_ou ì2

Tente

õ            :[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

Versão de 9 bytes

õ_îA¤w)n2

Tente

õ            :[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 bytes

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

Experimente online!

MATL , 7 bytes

:&+oRXB

Experimente online!

Explicação:

         % 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

A saída seria 0, 1, 2, 5 ...se Pfoi adicionada ao final ( flip), tornando-o em 8 bytes.

Ruby -n ,32. 30 + 1 bytes

Como temos exatamente 1 linha de entrada, $.é muito conveniente!

EDIT: Estou surpreso por ter conseguido me superar, mas parece usar o -nque conta como 1 (pela regra 2 em condições especiais padrão , pois o Ruby pode ser executado com ruby -e 'full program'(portanto, -né 1) todas as instâncias getsusadas apenas uma vez Seja um jogador de golfe dessa maneira; acredito que esse é um marco para o ruby, fale se você não concorda com essa linha de pensamento antes de reutilizá-la repetidamente no futuro)

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

Experimente online!

Explicação

# 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 bytes

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

Experimente online!

Usa a fórmula roubada descaradamente desta outra resposta Ruby.

Apesar de não ter a=0iria trabalhar (awk trata "vazio" como 0), o primeiro elemento de 0 não vai ficar impresso e em vez disso ser uma emptylinha, que enquanto eu diria é uma saída válida provavelmente não vai passar, então não há a=0o que pode ser inserido como argumento de linha de comando.

C, 52 bytes

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

Indexado 1

Experimente online!

brainfuck , 40 bytes

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

Experimente online!

Indexado a 0. Entrada como código de caractere, saída como unário com bytes nulos que separam séries de códigos de caracteres 1s. Assume células de 8 bits, a menos que você queira inserir mais de 255. Assume células negativas, embora isso possa ser corrigido à custa de vários bytes.

Anteriormente, 50 bytes

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

Experimente online!

Entradas como código de caracteres, saídas como código de caracteres. 1 indexado. Provavelmente poderia jogar um pouco de golfe.

O @Unihedron aponta que eu esqueci de especificar que isso precisa de células de tamanho infinito, caso contrário, ele chega ao 8º número.