Die Folge enthält die dezimale Darstellung der Binärzahlen der Form:, 10101...wobei der n-te Term n Bits hat.

Die Reihenfolge lässt sich wahrscheinlich am einfachsten erklären, indem nur die Beziehungen zwischen der binären und der dezimalen Darstellung der Zahlen gezeigt werden:

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

Herausforderung:

Nehmen Sie eine Ganzzahl nund geben Sie die ersten n Zahlen in der Folge zurück. Sie können wählen, ob die Sequenz 0-indiziert oder 1-indiziert sein soll.

Testfälle:

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

Erklärungen sind wie immer erwünscht.

Dies ist OEIS A000975 .

Python 2 , 36 Bytes

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

Probieren Sie es online! Erläuterung: Die binäre Darstellung von istso, dass es einfach bleibt, es mit einer geeigneten Potenz von 2 zu multiplizieren und den ganzzahligen Teil zu nehmen.$\frac{2}3$0.101010101...

05AB1E , 4 Bytes

2 Bytes werden mit Neils 2/3 Trick gespeichert

Lo3÷

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Erläuterung

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

Gelee , ... 4 Bytes

Danke Meilen für -1 Byte!

ḶḂḄƤ

Probieren Sie es online!

Erläuterung:

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

Gelee , 4 Bytes

Jonathan Allans Version.

Ḷ€ḂḄ

Probieren Sie es 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.

Eine Version, die auf Neils 2/3-Trick basiert, liefert 5 Bytes (siehe Versionsverlauf).

MATL , 5 Bytes

:WI/k

Basierend auf Neils Antwort .

Erläuterung

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

Probieren Sie es online!

MATL , 9 Bytes

:q"@:oXBs

Probieren Sie es online!

Erläuterung

:       % 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 Byte dank user202729
-1 Byte dank mathmandan}

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

Probieren Sie es 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[]  

Vielen Dank an user202729 für die Unterstützung beim Speichern von 19 Bytes und an ovs für die Unterstützung beim Speichern von 6 Bytes.

Probieren Sie es online

Schale , 7 Bytes

mḋḣ↑Θݬ

Probieren Sie es online!

1-basiert, also liefert Eingabe n die ersten n Ergebnisse.

Erläuterung

     ݬ   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 Byte ^SBCS

Nimmt an ⎕IO( I ndex O rigin) zu sein 0, was auf vielen Systemen Standard ist. Anonyme implizite Präfixfunktion. 1-indiziert.

(2⊥⍴∘1 0)¨⍳

Probieren Sie es online!

⍳ ɩndices 0… n − 1

(… )¨ Wenden auf jede die folgende implizite Funktion an

 ⍴∘1 0 Stellen Sie die Liste zyklisch [1,0]auf diese Länge um

 2⊥ konvertiere von Basis 2 (binär) zu normaler Zahl

Perlv5.10 -n , 24 + 1 Bytes

-3 Bytes danke an Nahuel Fouilleul !

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

Probieren Sie es online!

Dieselbe Logik wie meine Ruby-Version, aber kürzer, weil Perl übersichtlicher ist. Aus irgendeinem seltsamen Grund printwürde ich keinen Separator machen (verdammt!), Also musste ich sayfrom verwenden v5.10;, damit dies lief. Ich bin mir nicht sicher, wie ich dies bewerten soll, also lasse ich es fürs Erste aus. ..

Erläuterung

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

Probieren Sie es online!

APL (Dyalog) , 7 Bytes

⌊3÷⍨2*⍳

Probieren Sie es online!

APL (Dyalog) , 11 Bytes

(2⊥2|⍳)¨1+⍳

Probieren Sie es online!

Verwendet ⎕IO←0.

C , 81 55 59 Bytes

1 indiziert.

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

Volles Programm, weniger Golf:

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

Probieren Sie es online!

EDIT 2: Ich war unter der Annahme, dass Funktionen nicht wiederverwendbar sein müssten, jetzt, wo ich darüber nachdenke, macht es vollkommen Sinn, dass sie wiederverwendbar sein müssten: P

EDIT: Ich hatte die falsche Vorstellung, dass ich das gesamte Programm in die Antwort einbeziehen musste. Es stellte sich heraus, dass ich nur die Funktion brauchte, die das macht. Das ist schön.

Ich bin mir ziemlich sicher, dass ich hier und da ein paar Bytes abschneiden kann. Ich habe schon ein paar Tricks angewendet. Ein großer Teil des Programms dient dazu, das Argument in ein int zu verwandeln. Dies ist mein erster Code Golf. Wenn ich etwas falsch mache, sag mir: P

Haskell , 47 40 53 49 44 40 34 Bytes

-4 Bytes dank user202729
-6 Bytes dank Laikoni

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

Probieren Sie es online!

Rubin , 26 Bytes

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

Probieren Sie es online!

Schlägt alle älteren Rubin-Antworten.

Erläuterung

1/3in binär sieht 0.01010101...so aus, wenn Sie es mit Zweierpotenzen multiplizieren, erhalten Sie:

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

Aber Ruby setzt die Zahlen auf int division und gibt mir die Reihenfolge, die ich brauche.

J 9 Bytes

[:#.\2|i.

Wie es funktioniert?

i. - Liste 0..n-1

2| - die Listenelemente mod 2

\ - Alle Präfixe

#. - zu dezimal

[: - verschließt die Gabel (da ich gerade Anzahl (4) von Verben habe)

Probieren Sie es online!

Retina , 28 Bytes

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

Probieren Sie es online!

0-basiert, also gibt der Eingang n den ersten n + 1 Ergebnisse.

Erläuterung

Verwendet die Rekursion von OEIS:

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

Lass uns das Programm durchgehen:

)K`0

Dies ist eine konstante Phase: Sie verwirft die Eingabe und setzt den Arbeitsstring auf 0den Anfangswert der Sequenz. Das )schließt diese Etappe in eine Gruppe. Diese Gruppe selbst führt nichts aus, aber fast jede Phase (einschließlich Gruppenphasen) zeichnet das Ergebnis in einem Protokoll auf, und wir benötigen zwei Kopien des 0Protokolls, damit das Programm funktioniert.

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

Hier gibt es eine Reihe von Konfigurationen: "$+"+Wickelt die Bühne in eine Schleife. Das "$+"wird als Substitution behandelt und $+bezieht sich auf die Eingabe des Programms, dh n . Dies bedeutet, dass die Schleife ausgeführt wird n- mal ausgeführt wird.

Anschließend wird ¶<jede Iteration in eine Ausgangsstufe eingeschlossen, die die Stufen druckt Eingang mit einem nachgestellten Zeilenvorschub druckt (die erste Iteration druckt die Null, die zweite Iteration druckt das Ergebnis der ersten Iteration usw.).

Die Bühne selbst ersetzt den gesamten Arbeitsstring durch die Ersetzung in der letzten Zeile. Dass man verwendet eine implizite schließenden Klammer und implizite Argumente für den Wiederholungsoperator *, es ist so tatsächlich die Abkürzung für:

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

Das Zeug in den Klammern kann in drei Teile zerlegt werden:

• $&*_: gibt eine Zeichenfolge von a (n-1) _ s.
• _: gibt eine Single _ .
• 2*$-1*_: ergibt eine Zeichenkette von 2 * a (n-1) _ . Das$-1 bezieht sich auf das vorletzte Ergebnis im Ergebnisprotokoll, dh die Schleifeniteration vor dem letzten. Aus diesem Grund mussten wir zunächst Kopien der Null im Protokoll erstellen, da sich dies sonst auf die Eingabe des Programms bei der ersten Iteration beziehen würde.

Dann $.(…)misst die Länge des resultierenden Strings. Mit anderen Worten, wir haben berechnet, a(n) = a(n-1) + 1 + 2*a(n-2)indem wir durch unary gegangen sind (obwohl nicht wirklich:$.(…) ist faul und wertet den Inhalt nicht wirklich aus, wenn es die resultierende Länge direkt durch Arithmetik bestimmen kann, was sogar sehr effizient ist).

Das Ergebnis der letzten Schleifeniteration (das n + 1- te Element der Sequenz) wird aufgrund der impliziten Ausgabe von Retina am Ende des Programms gedruckt.

Brain-Flak , 36 Bytes

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

Probieren Sie es online!

Erläuterung:

Die nächste Nummer in der Sequenz erhalten Sie mit n*2+1oder 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 dank Unihedron

-3 Bytes dank GB

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

Probieren Sie es online!

> <> , 22 + 3 (-v Flag) Bytes

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

Probieren Sie es online!

Erläuterung

Der Stapel wird mit dem Schleifenzähler initialisiert.

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

Port von @Neils Python 2 Antwort .
1-indiziert und direkt ausgegeben, jeder Wert in einer separaten Zeile.

Erläuterung:

Probieren Sie es online aus.

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

Alte 80-Byte-Antwort:

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

1-indizierte Eingabe und durch Leerzeichen getrennte StringAusgabe

Erläuterung:

Probieren Sie es online aus.

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(~$_)}}

Probieren Sie es aus (35)

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

Probieren Sie es aus (30)

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

Probieren Sie es aus (30)

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

Probieren Sie es aus (27)

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

Probieren Sie es aus (25)

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

Probieren Sie es aus (20)

Erweitert:

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

Probieren Sie es online!

Python 2 , 34 Bytes

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

Probieren Sie es online!

Rückgabe in umgekehrter Reihenfolge.

C 47 46 Bytes

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

Der Akku abeginnt mit Null. Bei jedem Schritt verdoppeln wir es ( a+=a) und addieren eins, wenn das vorhergehende niedrigstwertige Bit Null war ( !(a%2)oder gleichwertig -(~a)%2).

Testprogramm

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

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

Ergebnisse

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

Alles unabhängig von anderen Lösungen abgeleitet.

1-indiziert.

õ!²mz3

Versuch es

Erläuterung

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

Versuch es

7-Byte-Version

õ_ou ì2

Versuch es

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

9-Byte-Version

õ_îA¤w)n2

Versuch es

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

Probieren Sie es online!

MATL , 7 Bytes

:&+oRXB

Probieren Sie es online!

Erläuterung:

         % 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

Die Ausgabe wäre, 0, 1, 2, 5 ...wenn Pam Ende ( flip) hinzugefügt wurde , was 8 Bytes ergibt.

Rubin -n ,32 30 + 1 Bytes

Da wir genau 1 Eingabezeile haben, $.ist das göttlich praktisch!

BEARBEITEN: Ich bin erstaunt, dass ich es geschafft habe, mich zu übertreiben, aber es scheint, als würde "using" -nals 1 gelten ( gemäß Regel 2 unter speziellen Standardbedingungen) , da Ruby mit ruby -e 'full program'(also -n1) ausgeführt werden kann, wobei alle Instanzen getsnur einmal verwendet werden können Ich glaube, dies ist ein Meilenstein für Ruby. Sprechen Sie uns bitte an, wenn Sie mit diesem Gedankengang nicht einverstanden sind, bevor ich ihn in Zukunft wiederholt wieder verwende.

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Verwendet die Formel, die schamlos aus dieser anderen Ruby-Antwort gestohlen wurde .

Wenngleich dies nicht a=0funktionieren würde (awk behandelt "leer" als 0), wird das erste Element von 0 nicht gedruckt und ist stattdessen eine emptyZeile. Ich würde behaupten, dass eine gültige Ausgabe wahrscheinlich nicht übergeben wird, also gibt es a=0welche als Kommandozeilenargument eingefügt werden.

C, 52 Bytes

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

1-indiziert

Probieren Sie es online!

Brainfuck , 40 Bytes

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

Probieren Sie es online!

0-indiziert. Eingabe als Zeichencode, Ausgabe als unär mit Null-Bytes, die eine Reihe von Zeichencodes von 1 trennen. Nimmt 8-Bit-Zellen an, es sei denn, Sie möchten über 255 eingeben. Nimmt negative Zellen an, obwohl dies auf Kosten mehrerer Bytes behoben werden könnte.

Bisher 50 Bytes

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

Probieren Sie es online!

Eingaben als Zeichencode, Ausgaben als Zeichencode. 1-indiziert. Wahrscheinlich könnte ein wenig Golf gespielt werden.

@Unihedron weist darauf hin, dass ich vergessen habe anzugeben, dass dies Zellen mit unendlicher Größe benötigt, andernfalls wird es an der achten Stelle aufgefüllt.