Lets definieren eine Zeigersequenz, eine beliebige Sequenz sein , dass a (n) a ((n-1) - (a (n-1))) = forall n größer als eine endliche Zahl. Zum Beispiel, wenn unsere Sequenz mit begann

3 2 1 

Unser nächster Term wäre 2, weil a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (dieses Beispiel ist der Index Null, es ist jedoch egal, welchen Index Sie für die Berechnung verwenden immer gleich sein.). Wenn wir den Vorgang wiederholen, erhalten wir die unendliche Folge

3 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2

Aufgabe

Bei einem gegebenen Anfangsarray positiver Ganzzahlen wird die Zeigersequenz beginnend mit diesem Array ausgegeben.

Ausgabearten

Die Ausgabe soll flexibel sein, wenn Sie eine Funktion schreiben, die als Programm zurückgegeben werden kann, entweder eine unendliche Liste von Ganzzahlen oder eine Funktion, die die Sequenz indiziert. Wenn Sie ein vollständiges Programm schreiben, können Sie Terme der Sequenz auf unbestimmte Zeit ausgeben.

Sie können auch zwei Eingaben vornehmen, das Start-Array und einen Index. Wenn Sie sich dazu entscheiden, müssen Sie nur den Term der Sequenz an diesem Index ausgeben.

Sie erhalten niemals eine Sequenz, die vor dem Beginn der Sequenz indexiert werden muss. Beispielsweise 3ist keine gültige Eingabe, da Sie Begriffe vor dem benötigen 3, um den nächsten Begriff aufzulösen.

Dies ist Codegolf, daher ist Ihre Punktzahl die Anzahl der Bytes in Ihrem Programm, wobei eine niedrigere Punktzahl besser ist.

Testfälle

Testfälle werden der Einfachheit halber abgeschnitten

2 1   -> 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 ...
2 3 1 -> 2 3 1 3 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 2 1 2 ...
3 3 1 -> 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 3 3 1 3 ...
4 3 1 -> 4 3 1 3 4 4 3 3 4 4 4 3 4 4 4 4 3 4 4 4 4 3 4 4 4 4 3 4 ...

JavaScript (ES6), 25 Byte

a=>f=n=>a[n]||f(--n-f(n))

Eine anonyme Funktion, die beim Aufrufen eine Funktion erstellt f, die das Element an einem bestimmten Index in der Sequenz angibt.

Bitte lassen Sie mich wissen, wenn ich etwas falsch verstanden habe ...

Schale , 7 6 Bytes

¡S!o_L

Gibt eine unendliche Liste zurück. Probieren Sie es online! Beachten Sie, dass es eine Weile dauert, bis TIO das Ergebnis abschneidet und druckt.

Erläuterung

Der Operator ¡hat mehrere Bedeutungen. Hier verwende ich "Konstruiere unendliche Liste durch Iteration einer Funktion, die ein neues Element aus der Liste der vorhandenen berechnet". Bei einer Liste mit der Länge N hat das neue Element einen auf 1 basierenden Index N + 1 . Alles, was wir tun müssen, ist das letzte Element der Liste zu negieren (dies ist der vorherige Wert) und anhand des Ergebnisses in die Liste zu indexieren.

¡S!o_L  Implicit input.
¡       Construct infinite list by iterating this function on input:
 S!      Element at index
    →    last element
  o_     negated.

Haskell , 36 Bytes

Nimmt eine Liste auf und gibt eine Funktion zurück, die die Sequenz indiziert

l!n|n<length l=l!!n|e<-n-1=l!(e-l!e)

Probieren Sie es online!

Erläuterung

Hier definieren wir eine Funktion !, die eine Liste lund einen Index annimmt n. Wenn nweniger als die Länge ist lwir Index ldurch n, sonst geht es zurück l!((n-1)-l!(n-1)). Dies folgt der rekursiven Definition der Funktion, die ich in der Frage angegeben habe.

Hier ist das gleiche Programm ungolfed.

a l n
 |n<length l = l!!n
 |otherwise = (a l) ((n-1) - (a l) (n-1))

Ich verwende e<-n-1stattdessen, um Bytes beim Zuweisen zu speichern n-1, edamit es später verwendet werden kann.

MATL , 13 9 Bytes

:"tt0)_)h

Gibt die Anfangsausdrücke gefolgt von n zusätzlichen Ausdrücken aus ( gemäß der Abfrage zulässig), wobei n eine positive Ganzzahl ist, die als Eingabe verwendet wird.

Probieren Sie es online!

Erläuterung

:"      % Implicitly input n. Do the following n times
  tt    %    Duplicate the sequence so far, twice. In the first iteration this
        %    implicitly inputs the array of initial terms
  0)    %    Get value of the last entry, say m
  _)    %    Get value of the entry which is m positions back from the last
  h     %    Append. This extends the array with the new entry
        % Implicit end. Implicitly display

Mathematica, 63 Bytes

Nimmt zwei Eingänge

(Clear@a;(a@#2[[1]]=#)&~MapIndexed~#;a@n_:=a[n-1-a[n-1]];a@#2)&  

Probieren Sie es online!

-3 Bytes von Martin Ender

R , 55 Bytes

f=function(a,n)"if"(n<=sum(a|1),a[n],f(a,n-1-f(a,n-1)))

Probieren Sie es online!

Nimmt zwei Eingänge.

Standard-ML (MLton) , 58 Bytes

fun a$n=if n<length$then List.nth($,n)else a$(n-1-a$(n-1))

Probieren Sie es online! Die Funktion animmt die Anfangsliste und einen Index und gibt das Sequenzelement an diesem Index zurück. Anwendungsbeispiel: a [4,3,1] 5Erträge 4.

Gelee , 6 Bytes

NṪịṭµ¡

Nimmt eine Sequenz S und eine ganze Zahl k und fügt k Terme zu S hinzu .

Probieren Sie es online!

Wie es funktioniert

NṪịṭµ¡  Main link. Left argument: S (sequence). Right argument: k (integer)

    µ¡  Combine the links to the left into a (variadic) chain and call it k times.
        The new chain started by µ is monadic, so the chain to the left will be
        called monadically.
N           Negate; multiply all elements in S by -1.
 Ṫ          Tail; retrieve the last element, i.e., -a(n-1).
  ị         At-index; retrieve the element of S at index -a(n-1).
            Since indexing is modular and the last element has indices n-1 and 0,
            this computes a( (n-1) - a(n-1) ).
   ṭ        Tack; append the result to S.

Python 2 , 48 Bytes

a=lambda S,n:n<len(S)and S[n]or a(S,~a(S,~-n)+n)

Probieren Sie es online!

CJam, 10 Bytes

{{(_j-j}j}

Für CJam ist das sehr gut (es schlägt sogar 05ab1e!).

Dies ist ein anonymer Block, der Eingaben in das Formular i nauf dem Stapel erwartet. Dabei ihandelt es sich um den Index in der Sequenz und num ein Array von Startnummern.

Der Grund, warum dies so gut funktioniert, ist der jOperator, der eine gespeicherte Rekursion aus einer Reihe von Startwerten bereitstellt.

Erläuterung:

{    Function j(n) with [j(0), j(1), j(2)] = [4, 3, 1], return j(6):
 (    Decrement:    5
 _    Duplicate:    5 5
 j    j(5):
  (    Decrement:   5 4
  _    Duplicate:   5 4 4
  j    j(4):
   (    Decrement:  5 4 3
   _    Duplicate:  5 4 3 3
   j    j(3):
    (    Decrement: 5 4 3 2
    _    Duplicate: 5 4 3 2 2
    j    j(2) = 1:  5 4 3 2 1
    -    Subtract:  5 4 3 1
    j    j(1) = 3:  5 4 3 3
   -    Subtract:   5 4 0
   j    j(0) = 4:   5 4 4
  -    Subtract:    5 0
  j    j(0) = 4:    5 4
 -    Subtract:     1
 j    j(1) = 3:     3
}j   End:           3

Java (8), 60 Bytes

int a(int[]a,int n){return n<a.length?a[n]:a(a,--n-a(a,n));}

Nimmt zwei Eingaben (Integer-Array aund Integer n) und gibt den n'ten Wert der Sequenz aus.

Erläuterung:

Probieren Sie es hier aus. (Könnte einige Sekunden dauern.)

int a(int[]a,int n){        // Method with int[] and int parameters and int return-type
  return n<a.length?        //  If input `n` is smaller than the length of the array:
          a[n]              //   Output the `n`'th item of the array
         :                  //  Else:
          a(a,--n-a(a,n));  //   Recursive call with `n-1-a(n-1)`
}                           // End of method

Perl, 38 +3 (-anl) Bytes

{print;push@F,$_=$F[$#F-$F[$#F]];redo}

Probieren Sie es online

05AB1E , 20 Bytes

#`r[=ˆŽ¼}[¯¾¯¾è-è=ˆ¼

Erwartet die Eingabe als durch Leerzeichen getrennte Zeichenfolge und gibt sie auf unbestimmte Zeit aus. ziemlich einfache Implementierung

Beispiellauf:

$ 05ab1e -e '#`r[=ˆŽ¼}[¯¾¯¾è-è=ˆ¼' <<< '3 2 1'
3
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2
2
1
2

Java (OpenJDK 8) , 95 93 91 90 Bytes

a->i->{int j=0,b[]=new int[++i];for(;j<i;j++)b[j]=j<a.length?a[j]:b[~-j-b[j-1]];return b;}

Probieren Sie es online!

Perl 5 , -a30 Bytes

#!/usr/bin/perl -a
use 5.10.0
say$F[@F]=$F[-1-$F[-1]]while 1

Probieren Sie es online!