Deixa para definir uma sequência de ponteiro para ser qualquer sequência de tal modo que uma (n) = a ((n-1) - (a (n-1))) forall n maior do que um número finito. Por exemplo, se nossa sequência começou com

3 2 1 

Nosso próximo termo seria 2, porque a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (este exemplo é índice zero, no entanto, não importa qual índice você use, o cálculo será sempre seja o mesmo.) Se repetirmos o processo, obtemos a sequência 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

Tarefa

Dada uma matriz inicial de números inteiros positivos, a seqüência do ponteiro começa com essa matriz.

Tipos de saída

A saída deve ser flexível; se você optar por escrever uma função como seu programa, ela poderá retornar, uma lista infinita de números inteiros ou uma função que indexe a sequência. Se você optar por escrever um programa completo, poderá imprimir os termos da sequência indefinidamente.

Você também pode optar por receber duas entradas, a matriz inicial e um índice. Se você optar por fazer isso, precisará gerar apenas o termo da sequência nesse índice.

Você nunca receberá uma sequência que requer indexação antes do início da sequência. Por exemplo, 3não é uma entrada válida porque você precisaria de termos anteriores ao 3para resolver o próximo termo.

Isso é código-golfe, então sua pontuação será o número de bytes no seu programa, com uma pontuação menor sendo melhor.

Casos de teste

casos de teste são truncados para simplificar

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

Uma função anônima que, quando chamada, cria uma função fque fornece o item em um determinado índice na sequência.

Por favor, deixe-me saber se eu não entendi nada ...

Casca , 7 6 bytes

¡S!o_L

Retorna uma lista infinita. Experimente online! Observe que leva um tempo para o TIO truncar e imprimir o resultado.

Explicação

O operador ¡tem vários significados. Aqui eu estou usando "construir lista infinita repetindo uma função que calcula um novo elemento da lista dos existentes". Dada uma lista do comprimento N , o novo elemento terá o índice baseado em 1 N + 1 . Tudo o que precisamos fazer é negar o último elemento da lista (que é o valor anterior) e indexar na lista usando o 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

Pega uma lista e retorna uma função que indexa a sequência

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

Experimente online!

Explicação

Aqui estamos definindo uma função !que recebe uma lista le um índice n. Se nfor menor do que o comprimento do lque o índice lpor n, caso contrário, vamos voltar l!((n-1)-l!(n-1)). Isso segue a definição recursiva da função que dei na pergunta.

Aqui está o mesmo programa não destruído.

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

Em e<-n-1vez disso, uso em vez disso para salvar bytes ao atribuir n-1a, epara que possa ser usado posteriormente.

MATL , 13 9 bytes

:"tt0)_)h

Gera os termos iniciais seguidos por n termos adicionais (permitidos pelo desafio), em que n é um número inteiro positivo recebido como entrada.

Experimente online!

Explicação

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

leva duas entradas

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

Experimente online!

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

Experimente online!

Toma duas entradas.

ML padrão (MLton) , 58 bytes

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

Experimente online! A função apega a lista inicial e um índice e retorna o elemento de sequência nesse índice. Exemplo de uso: a [4,3,1] 5rendimentos 4.

Gelatina , 6 bytes

NṪịṭµ¡

Leva uma sequência S e um inteiro k , e adiciona k termos de S .

Experimente online!

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

Experimente online!

CJam, 10 bytes

{{(_j-j}j}

Para CJam, isso funciona muito bem (até bate 05ab1e!).

Este é um bloco anônimo que espera entrada no formulário i nna pilha, onde iestá o índice na sequência e né uma matriz de números iniciais.

A razão pela qual isso funciona tão bem é por causa do joperador, que fornece recursão memorizada de um conjunto de valores iniciais.

Explicação:

{    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 duas entradas (número ainteiro e número inteiro n) e gera o n'th valor da sequência.

Explicação:

Experimente aqui. (Pode demorar alguns 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}

Experimente Online

05AB1E , 20 bytes

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

Espera a entrada como uma sequência separada por espaço, continua a produzir indefinidamente; implementação bastante direta

Exemplo de execução:

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

Experimente online!

Perl 5 , -a30 bytes

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

Experimente online!