让我们定义指针序列是这样的任何序列A（N）= A（（N-1） - （A（N-1）））的forall Ñ比一些有限数量。例如，如果我们的序列以

3 2 1 

我们的下一项将是2，因为a（n-1）= 1，（n-1）-1 = 1，a（1）= 2（此示例为零索引，但是使用计算将使用哪个索引并不重要总是一样。）。如果我们重复这个过程，我们将得到无限序列

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

任务

给定一些初始的正整数数组，输出从该数组开始的指针序列。

输出类型

输出是灵活的，如果您选择将函数编写为程序可以返回，则可以返回无限的整数列表或对序列进行索引的函数。如果您选择编写完整的程序，则可以无限期地输出序列的项。

您也可以选择采用两个输入，即起始数组和索引。如果选择这样做，则只需要在该索引处输出序列项。

您将永远不会得到需要在序列开始之前进行索引的序列。例如，3这不是有效的输入，因为您可能需要先输入术语才能3解析下一个术语。

这是代码高尔夫球，因此您的分数将是程序中的字节数，分数越低越好。

测试用例

为了简单起见，测试用例被截断

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个字节

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

一个匿名函数，当调用该函数时，将创建一个函数f，该函数以序列中的给定索引给出项目。

如果我误解了任何事情，请告诉我...

外壳，7 6字节

¡S!o_L

返回无限列表。 在线尝试！ 请注意，TIO截断并打印结果需要一些时间。

说明

运算符¡具有多种含义。在这里，我使用“通过迭代从现有元素列表中计算新元素的函数来构造无限列表”。给定长度为N的列表，新元素将具有基于1的索引N + 1。我们需要做的就是否定列表的最后一个元素（即先前的值），并使用结果将其索引到列表中。

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

Haskell，36个字节

取得列表并返回索引序列的函数

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

在线尝试！

说明

在这里，我们定义一个!带有列表l和索引的函数n。如果n是小于的长度l，我们指数l通过n，否则我们返回l!((n-1)-l!(n-1))。这遵循了我在问题中给出的函数的递归定义。

这是相同的程序。

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

我使用e<-n-1而不是其他方式在分配时保存字节n-1，e以便以后使用。

MATL，13 9字节

:"tt0)_)h

输出初始项，后跟n个其他项（挑战允许），其中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个字节

需要两个输入

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

在线尝试！

Martin Ender的-3个字节

R，55个字节

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

在线尝试！

接受两个输入。

标准ML（MLton），58字节

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

在线尝试！该函数a获取初始列表和索引，并在该索引处返回序列元素。用法示例：a [4,3,1] 5yields 4。

果冻，6个字节

NṪịṭµ¡

取一个序列S和一个整数k，并将k个项加到S上。

在线尝试！

怎么运行的

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个字节

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

在线尝试！

CJam，10个字节

{{(_j-j}j}

对于CJam来说，这非常好（甚至击败了05ab1e！）。

这是一个匿名块，期望i n以堆栈上的形式输入，其中i是序列中的索引，并且n是起始编号的数组。

之所以如此有效，是因为j运算符可以根据一组初始值提供建议的递归。

说明：

{    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个字节

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

接受两个输入（整数数组a和整数n），并输出n序列的'th值。

说明：

在这里尝试。（可能要花几秒钟。）

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）字节

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

在线试用

05AB1E，20个字节

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

期望输入以空格分隔的字符串，并无限期地输出；非常简单的实现

示例运行：

$ 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字节

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

在线尝试！

Perl 5中，-a30个字节

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

在线尝试！