Einführung

Natürlich haben wir viele Herausforderungen in Bezug auf Sequenzen. Hier ist eine andere.

Die Kimberling-Sequenz ( A007063 ) lautet wie folgt:

1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, ...

Dies wird durch Mischen der normalen Iteration erzeugt:

[1] 2  3  4  5  6  7  8

Der erste Term der Sequenz ist 1. Danach mischen wir die Sequenz neu, bis alle Begriffe auf der linken Seite verwendet werden. Das Mischen hat das Muster right - left - right - left - .... Da links von keine Begriffe stehen 1, wird nicht gemischt. Wir bekommen folgendes:

 2 [3] 4  5  6  7  8  9

Bei der i- ^ten Iteration verwerfen wir das i- ^te Element und fügen es in unsere Sequenz ein. Dies ist die 2. Iteration, also verwerfen wir den 2. Punkt. Die Sequenz wird: 1, 3. Für unsere nächste Iteration werden wir die aktuelle Iteration mit dem obigen Muster mischen. Wir nehmen den ersten unbenutzten Artikel rechts vom i- ^ten Artikel. Das ist zufällig so 4. Wir werden dies an unsere neue Iteration anhängen:

 4

Jetzt nehmen wir den ersten unbenutzten Gegenstand links vom i- ^ten Gegenstand. Das ist 2. Wir werden dies an unsere neue Iteration anhängen:

 4  2

Da links vom i- ^ten Element keine Elemente mehr vorhanden sind , wird der Rest der Sequenz an die neue Iteration angehängt:

 4  2 [5] 6  7  8  9  10  11  ...

Dies ist unsere 3. Iteration, wir werden also das 3. Element verwerfen 5. Dies ist der dritte Punkt in unserer Sequenz:

 1, 3, 5

Um die nächste Iteration zu erhalten, wiederholen Sie einfach den Vorgang. Ich habe ein GIF gemacht, wenn es nicht klar ist:

^{Das GIF hat länger gedauert als das Schreiben des eigentlichen Posts}

Aufgabe

• Bei einer nicht negativen Ganzzahl n werden die ersten n Terme der Sequenz ausgegeben
• Sie können eine Funktion oder ein Programm bereitstellen
• Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Testfälle:

Input: 4
Output: 1, 3, 5, 4

Input: 8
Output: 1, 3, 5, 4, 10, 7, 15, 8

Input: 15
Output: 1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28

Hinweis: Die Kommas in der Ausgabe sind nicht erforderlich. Sie können beispielsweise Zeilenumbrüche verwenden oder eine Liste usw. ausgeben.

Pyth, 22 Bytes

JS*3QVQ@JN=J.i>JhN_<JN

Probieren Sie es online aus: Demonstration

Führt einfach die im OP beschriebene Mischtechnik aus.

Erläuterung:

JS*3QVQ@JN=J.i>JhN_<JN
JS*3Q                    assign the list [1, 2, ..., 3*input-1] to J
     VQ                  for N in range(Q):
       @JN                  print J[N]
            .i              interleave 
              >JhN             J[N+1:] with
                  _<JN         reverse J[:N]
          =J                assign the resulting list to J

Julia, 78 71 Bytes

n->[(i=j=x;while j<2i-3 j=i-(j%2>0?1-j:j+2)÷2;i-=1end;i+j-1)for x=1:n]

Dies ist eine unbenannte Funktion, die eine Ganzzahl akzeptiert und ein Ganzzahl-Array zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz hier ist derselbe wie bei OEIS.

Ungolfed:

# This computes the element of the sequence
function K(x)
    i = j = x
    while j < 2i - 3
        j = i - (j % 2 > 0 ? 1 - j : j + 2)÷2
        i -= 1
    end
    return i + j - 1
end

# This gives the first n terms of the sequence
n -> [K(i) for i = 1:n]

7 Bytes gespart dank Mauris!

Mathematica 130 Bytes

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&

Wir beginnen mit einer Liste, bestehend aus dem Bereich von 1bis 3x, wox die gewünschte Anzahl von Kimberling-Sequenztermen angegeben ist.

Bei jedem Schritt n, TakeDropbricht die die aktuelle Liste in eine vordere Liste von 2n+1Begriffen (wo die Arbeit getan ist ) und hintere Liste (die später mit der verbunden werden Front Liste überarbeitet). Die vordere Liste wird mit dem folgenden Muster abgeglichen, {t___,z,r___}wobei z der Kimberling-Begriff in der Mitte der vorderen Liste ist. ris Riffle'd mit der rückseite von tund dann wird die hintere liste angehängt. zwird entfernt und an AppendTodie wachsende Kimberling-Sequenz angehängt .

nwird um inkrementiert 1und die aktuelle Liste wird von derselben Funktion über verarbeitetNest.

Beispiel

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&[100]

{1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, 42, 35, 33, 46, 53, 6, 36, 23, 2 , 55, 62, 59, 76, 65, 54, 11, 34, 48, 70, 79, 99, 95, 44, 97, 58, 84, 25, 13, 122, 83, 26, 115, 82, 91 , 52, 138, 67, 90, 71, 119, 64, 37, 81, 39, 169, 88, 108, 141, 38, 16, 146, 41, 21, 175, 158, 165, 86, 191, 45 198, 216, 166, 124, 128, 204, 160, 12, 232, 126, 208, 114, 161, 156, 151, 249, 236, 263, 243, 101, 121, 72, 120, 47, 229 }

Python 2, 76 Bytes

for a in range(input()):
 b=a+1
 while-~b<2*a:b=a-(b^b%-2)/2;a-=1
 print a+b

Erläuterung

Dies ist die OEIS Formel nach vielen Golf-Transformationen! Es hat wunderbar geklappt . Der ursprüngliche Code war

i=b=a+1
while b<2*i-3:b=i-(b+2,1-b)[b%2]/2;i-=1
print i+b-1

Ich wurde zuerst los i, ersetzte es durch a+1überall und erweiterte die Ausdrücke:

b=a+1
while b<2*a-1:b=a+1-(b+2,1-b)[b%2]/2;a-=1
print a+b

Schreiben Sie dann b<2*a-1um -~b<2*a, um ein Byte Leerzeichen zu speichern, und verschieben Sie das +1in die Auswahl, Division durch 2 und Negation:

while-~b<2*a:b=a-(b,-b-1)[b%2]/2;a-=1

Dann -b-1ist eben ~bso, dass wir schreiben können (b,~b)[b%2]. Dies entspricht der b^0 if b%2 else b^-1Verwendung des XOR-Operators oder alternativ dazu b^b%-2.

while-~b<2*a:b=a-(b^b%-2)/2;a-=1

Pyth, 29 25 Bytes

VQ+.W<hHyN-~tN/x%Z_2Z2hNN

Jakube hat 4 Bytes gespart, aber ich habe keine Ahnung mehr, wie ich den Code lesen soll.

Hier ist die alte Lösung:

VQKhNW<hKyN=K-~tN/x%K_2K2)+KN

Übersetzung meiner Python-Antwort. Ich bin nicht sehr gut in Pyth, also gibt es vielleicht noch Möglichkeiten, dies zu verkürzen.

VQ                              for N in range(input()):
  KhN                             K = N+1
     W<hKyN                       while 1+K < 2*N:
           =K-~tN/x%K_2K2)         K = (N--) - (K%-2 xor K) / 2
                          +KN     print K + N

APL, 56 44 Bytes

{⍵<⍺+⍺-3:(⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵⋄⍺+⍵-1}⍨¨⍳

Dies ist ein unbenannter monadischer Zug, der eine Ganzzahl auf der rechten Seite akzeptiert und ein Array zurückgibt. Es ist ungefähr der gleiche Ansatz wie meine Julia-Antwort .

Die innerste Funktion ist eine rekursive dyadische Funktion, die den n- ten Term in der Kimberling-Sequenz zurückgibt , wobei n als identisches linkes und rechtes Argument angegeben wird.

{⍵<⍺+⍺-3:                                    ⍝ If ⍵ < 2⍺ - 3
         (⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵           ⍝ Recurse, incrementing a and setting
                                             ⍝ ⍵ = ⍺ - (3 + (-1)^⍵ * (1 + 2⍵))/4
                                   ⋄⍺+⍵-1}   ⍝ Otherwise return ⍺ + ⍵ - 1

Auf diese Weise können wir individuelle Begriffe für die Sequenz ermitteln. Das Problem wird dann jedoch, dass dies eine dyadische Funktion ist, was bedeutet, dass Argumente auf beiden Seiten erforderlich sind. Geben Sie den ⍨Operator ein! Wenn Sie eine Funktion fund eine Eingabe angeben x, f⍨xist dies dasselbe wie x f x. In unserem Fall fkönnen wir unter Bezugnahme auf die oben genannte Funktion also den folgenden monadischen Zug konstruieren:

f⍨¨⍳

Wir bewerben uns f auf jede Ganzzahl 1 auf die Eingabe an und erhalten ein Array.

12 Bytes gespart dank Dennis!