Consente di definire una sequenza puntatore essere qualsiasi sequenza tale che una (n) = a ((n-1) - (a (n-1))) forall n maggiore di un certo numero finito. Ad esempio se la nostra sequenza è iniziata con

3 2 1 

Il nostro prossimo termine sarebbe 2, perché a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (questo esempio è indice zero, tuttavia non importa quale indice verrà utilizzato per il calcolo essere sempre lo stesso.). Se ripetiamo il processo otteniamo la sequenza infinita

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

Compito

Dato un array iniziale di numeri interi positivi, viene emessa la sequenza di puntatori che inizia con quell'array.

Tipi di uscita

L'output è pensato per essere flessibile, se si sceglie di scrivere una funzione come programma, può restituire un elenco infinito di numeri interi o una funzione che indicizza la sequenza. Se si sceglie di scrivere un programma completo, è possibile produrre in modo indefinito i termini della sequenza.

Puoi anche scegliere di prendere due input, l'array iniziale e un indice. Se si sceglie di eseguire questa operazione, è necessario solo generare il termine della sequenza in quell'indice.

Non ti verrà mai assegnata una sequenza che richiede l'indicizzazione prima dell'inizio della sequenza. Ad esempio, 3non è un input valido perché è necessario disporre di termini prima 3di risolvere il termine successivo.

Questo è code-golf, quindi il tuo punteggio sarà il numero di byte nel tuo programma con un punteggio più basso migliore.

Casi test

i casi di test vengono troncati per semplicità

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

Una funzione anonima che, quando viene chiamata, crea una funzione fche fornisce l'elemento in corrispondenza di un determinato indice nella sequenza.

Per favore fatemi sapere se ho frainteso qualcosa ...

Buccia , 7 6 byte

¡S!o_L

Restituisce un elenco infinito. Provalo online! Si noti che TIO impiega un po 'di tempo a troncare e stampare il risultato.

Spiegazione

L'operatore ¡ha diversi significati. Qui sto usando "costruisci un elenco infinito ripetendo una funzione che calcola un nuovo elemento dall'elenco di quelli esistenti". Dato un elenco di lunghezza N , il nuovo elemento avrà un indice basato su 1 N + 1 . Tutto quello che dobbiamo fare è annullare l'ultimo elemento dell'elenco (che è il valore precedente) e indicizzarlo nell'elenco usando il risultato.

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

Haskell , 36 byte

Prende un elenco e restituisce una funzione che indicizza la sequenza

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

Provalo online!

Spiegazione

Qui stiamo definendo una funzione !che accetta un elenco le un indice n. Se nè inferiore alla lunghezza di lnoi dell'indice lda n, altrimenti torniamo l!((n-1)-l!(n-1)). Questo segue la definizione ricorsiva della funzione che ho dato alla domanda.

Ecco lo stesso programma ungolfed.

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

Uso e<-n-1invece di salvare altrimenti i byte durante l'assegnazione n-1in emodo che possa essere utilizzato in seguito.

MATL , 13 9 byte

:"tt0)_)h

Emette i termini iniziali seguiti da n termini aggiuntivi (consentiti dalla sfida), dove n è un numero intero positivo preso come input.

Provalo online!

Spiegazione

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

accetta due input

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

Provalo online!

-3 byte da Martin Ender

R , 55 byte

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

Provalo online!

Accetta due input.

ML standard (MLton) , 58 byte

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

Provalo online! La funzione aprende l'elenco iniziale e un indice e restituisce l'elemento sequenza in quell'indice. Esempio di utilizzo: a [4,3,1] 5rese 4.

Gelatina , 6 byte

NṪịṭµ¡

Prende una sequenza S e un intero k , e aggiunge k termini di S .

Provalo online!

Come funziona

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 byte

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

Provalo online!

CJam, 10 byte

{{(_j-j}j}

Per CJam, questo funziona molto bene (batte persino 05ab1e!).

Questo è un blocco anonimo che prevede input nel modulo i nnello stack, dove iè l'indice nella sequenza ed nè un array di numeri iniziali.

Il motivo per cui funziona così bene è a causa jdell'operatore, che fornisce la ricorsione memorizzata da un set di valori iniziali.

Spiegazione:

{    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 byte

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

Accetta due input (intero-array ae intero n) e genera il n'th valore della sequenza.

Spiegazione:

Provalo qui. (Potrebbe richiedere alcuni secondi.)

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) byte

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

Provalo online

05AB1E , 20 byte

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

Si aspetta che l'input sia una stringa separata da spazio, continua a essere emessa indefinitamente; implementazione piuttosto semplice

Esempio di esecuzione:

$ 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 byte

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

Provalo online!

Perl 5 , -a30 byte

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

Provalo online!