Permite definir una secuencia de puntero a ser cualquier secuencia tal que a (n) = a ((n-1) - (a (n-1))) forall n mayor que algún número finito. Por ejemplo, si nuestra secuencia comenzó con

3 2 1 

Nuestro siguiente término sería 2, porque a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (este ejemplo es índice cero, sin embargo, no importa qué índice use el cálculo) siempre sea lo mismo). Si repetimos el proceso obtenemos la secuencia 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

Tarea

Dado un conjunto inicial de enteros positivos, la secuencia del puntero comienza con ese conjunto.

Tipos de salida

La salida está destinada a ser flexible, si elige escribir una función como su programa puede devolver, ya sea una lista infinita de enteros o una función que indexa la secuencia. Si elige escribir un programa completo, puede generar términos de la secuencia indefinidamente.

También puede optar por tomar dos entradas, la matriz inicial y un índice. Si elige hacer esto, solo necesita mostrar el término de la secuencia en ese índice.

Nunca se le dará una secuencia que requiera indexación antes del comienzo de la secuencia. Por ejemplo, 3no es una entrada válida porque necesitaría términos antes del 3para resolver el siguiente término.

Este es el código de golf, por lo que su puntaje será el número de bytes en su programa con un puntaje más bajo mejor.

Casos de prueba

los casos de prueba se truncan por simplicidad

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 bytes

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

Una función anónima que, cuando se llama, crea una función fque le da al elemento en un índice dado en la secuencia.

Por favor, avíseme si entendí mal algo ...

Casco , 7 6 bytes

¡S!o_L

Devuelve una lista infinita. Pruébalo en línea! Tenga en cuenta que TIO tarda un tiempo en truncarse e imprimir el resultado.

Explicación

El operador ¡tiene varios significados. Aquí estoy usando "construir lista infinita iterando una función que calcula un nuevo elemento de la lista de los existentes". Dada una lista de longitud N , el nuevo elemento tendrá un índice basado en 1 N + 1 . Todo lo que necesitamos hacer es negar el último elemento de la lista (que es el valor anterior) e indexar en la lista usando el resultado.

¡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

Toma una lista y devuelve una función que indexa la secuencia

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

Pruébalo en línea!

Explicación

Aquí estamos definiendo una función !que toma una lista ly un índice n. Si nes menor que la longitud de lque el índice lde n, si no volvemos l!((n-1)-l!(n-1)). Esto sigue la definición recursiva de la función que le di en la pregunta.

Aquí está el mismo programa sin golf.

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

Lo uso en e<-n-1lugar de lo contrario para guardar bytes mientras lo asigno n-1para eque pueda usarse más tarde.

MATL , 13 9 bytes

:"tt0)_)h

Emite los términos iniciales seguidos de n términos adicionales (permitidos por el desafío), donde n es un entero positivo tomado como entrada.

Pruébalo en línea!

Explicación

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

toma dos entradas

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

Pruébalo en línea!

-3 bytes de Martin Ender

R , 55 bytes

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

Pruébalo en línea!

Toma dos entradas.

ML estándar (MLton) , 58 bytes

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

Pruébalo en línea! La función atoma la lista inicial y un índice y devuelve el elemento de secuencia en ese índice. Ejemplo de uso: a [4,3,1] 5rendimientos 4.

Jalea , 6 bytes

NṪịṭµ¡

Toma una secuencia S y un número entero k , y añade k términos para S .

Pruébalo en línea!

Cómo funciona

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)

Pruébalo en línea!

CJam, 10 bytes

{{(_j-j}j}

Para CJam, esto funciona muy bien (¡incluso supera a 05ab1e!).

Este es un bloque anónimo que espera entrada en el formulario i nen la pila, donde iestá el índice en la secuencia y nes una matriz de números iniciales.

La razón por la que esto funciona tan bien es por el joperador, que proporciona una recursión memorable de un conjunto de valores iniciales.

Explicación:

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

Toma dos entradas (integer-array ae integer n) y genera el n'valor de la secuencia.

Explicación:

Pruébalo aquí. (Puede tomar unos segundos)

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}

Pruébalo en línea

05AB1E , 20 bytes

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

Espera la entrada como una cadena separada por espacios, sigue produciendo indefinidamente; implementación bastante sencilla

Ejemplo de ejecución:

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

Pruébalo en línea!

Perl 5 , -a30 bytes

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

Pruébalo en línea!