Permet de définir une séquence de pointeur pour être une séquence telle que a (n) = a ((n-1) - (a (n-1))) forall n supérieur à un certain nombre fini. Par exemple, si notre séquence a commencé par

3 2 1 

Notre prochain terme serait 2, car a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (cet exemple est un indice zéro, mais peu importe l'indice que vous utilisez, le calcul sera toujours être le même.). Si nous répétons le processus, nous obtenons la séquence infinie

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

Tâche

Étant donné un tableau initial d'entiers positifs, affichez la séquence de pointeurs commençant par ce tableau.

Types de sortie

La sortie est censée être flexible, si vous choisissez d'écrire une fonction en tant que programme, elle peut renvoyer, soit une liste infinie d'entiers ou une fonction qui indexe la séquence. Si vous choisissez d'écrire un programme complet, vous pouvez sortir indéfiniment les termes de la séquence.

Vous pouvez également choisir de prendre deux entrées, le tableau de départ et un index. Si vous choisissez de le faire, vous devez uniquement afficher le terme de la séquence à cet index.

Vous ne recevrez jamais une séquence qui nécessite une indexation avant le début de la séquence. Par exemple, 3n'est pas une entrée valide car vous auriez besoin de termes avant le 3pour résoudre le terme suivant.

Il s'agit de code-golf, donc votre score sera le nombre d'octets de votre programme, un score inférieur étant meilleur.

Cas de test

les cas de test sont tronqués pour plus de simplicité

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 octets

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

Une fonction anonyme qui, lorsqu'elle est appelée, crée une fonction fqui donne l'élément à un index donné dans la séquence.

S'il vous plaît laissez-moi savoir si j'ai mal compris quoi que ce soit ...

Husk , 7 6 octets

¡S!o_L

Renvoie une liste infinie. Essayez-le en ligne! Notez qu'il faut un certain temps à TIO pour tronquer et imprimer le résultat.

Explication

L'opérateur ¡a plusieurs significations. Ici, j'utilise "construire une liste infinie en itérant une fonction qui calcule un nouvel élément à partir de la liste des éléments existants". Étant donné une liste de longueur N , le nouvel élément aura un indice basé sur 1 N + 1 . Tout ce que nous devons faire est de nier le dernier élément de la liste (qui est la valeur précédente) et d'indexer dans la liste en utilisant le résultat.

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

Haskell , 36 octets

Prend une liste et retourne une fonction qui indexe la séquence

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

Essayez-le en ligne!

Explication

Nous définissons ici une fonction !qui prend une liste let un index n. Si nest inférieure à la longueur de lnous index lpar n, sinon nous reviendrons l!((n-1)-l!(n-1)). Cela suit la définition récursive de la fonction que j'ai donnée dans la question.

Voici le même programme non golfé.

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

Je l' utilise au e<-n-1lieu d'ailleurs économiser des octets tout en attribuant n-1à de esorte qu'il peut être utilisé plus tard.

MATL , 13 9 octets

:"tt0)_)h

Génère les termes initiaux suivis de n termes supplémentaires (autorisés par le défi), où n est un entier positif pris en entrée.

Essayez-le en ligne!

Explication

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

prend deux entrées

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

Essayez-le en ligne!

-3 octets de Martin Ender

R , 55 octets

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

Essayez-le en ligne!

Prend deux entrées.

ML standard (MLton) , 58 octets

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

Essayez-le en ligne! La fonction aprend la liste initiale et un index et renvoie l'élément de séquence à cet index. Exemple d'utilisation: a [4,3,1] 5rendements 4.

Gelée , 6 octets

NṪịṭµ¡

Prend une séquence S et un nombre entier k , et ajoute k termes de S .

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

CJam, 10 octets

{{(_j-j}j}

Pour CJam, cela fonctionne très bien (il bat même 05ab1e!).

Il s'agit d'un bloc anonyme qui attend une entrée sous la forme i nsur la pile, où se itrouve l'index dans la séquence et nest un tableau de nombres de départ.

La raison pour laquelle cela fonctionne si bien est due à l' jopérateur, qui fournit une récursivité mémorisée à partir d'un ensemble de valeurs de départ.

Explication:

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

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

Prend deux entrées (tableau aentier et entier n), et sort la n'e valeur de la séquence.

Explication:

Essayez-le ici. (Cela pourrait prendre quelques secondes.)

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

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

Essayez-le en ligne

05AB1E , 20 octets

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

Attend l'entrée comme une chaîne séparée par des espaces, continue de produire indéfiniment; mise en œuvre assez simple

Exemple d'exécution:

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

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

Essayez-le en ligne!

Perl 5 , -a30 octets

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

Essayez-le en ligne!