Позволяет определить последовательность указателей , чтобы быть любой последовательностью таким образом, что а (п) = а ((п-1) - (а (п-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)&  

Попробуйте онлайн!

-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] 5доходность 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'-ое значение последовательности.

Объяснение:

Попробуй это здесь. (Может занять несколько секунд.)

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

Попробуйте онлайн!