Pozwala określić sekwencję wskaźnik być jakakolwiek sekwencja, tak, że (n) = a ((n-1) - ((n-1))) forall n większa niż pewna liczba skończonych. Na przykład, jeśli nasza sekwencja się rozpoczęła

3 2 1 

Nasz następny termin to 2, ponieważ a (n-1) = 1 , (n-1) -1 = 1 , a (1) = 2 (ten przykład jest indeksem zerowym, jednak nie ma znaczenia, jakiego indeksu użyjesz do obliczeń zawsze bądź taki sam.). Jeśli powtórzymy proces, otrzymamy nieskończoną sekwencję

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

Zadanie

Biorąc pod uwagę pewną początkową tablicę dodatnich liczb całkowitych, wyjściowa sekwencja wskaźnika zaczyna się od tej tablicy.

Typy wyjściowe

Wyjście ma być elastyczne, jeśli zdecydujesz się napisać funkcję jako swój program, może zwrócić: nieskończoną listę liczb całkowitych lub funkcję indeksującą sekwencję. Jeśli zdecydujesz się napisać pełny program, możesz wyświetlać terminy sekwencji w nieskończoność.

Możesz także wybrać dwa dane wejściowe, tablicę początkową i indeks. Jeśli zdecydujesz się to zrobić, musisz podać tylko ciąg sekwencji przy tym indeksie.

Nigdy nie otrzymasz sekwencji, która wymaga indeksowania przed rozpoczęciem sekwencji. Na przykład 3nie jest poprawnym danymi wejściowymi, ponieważ potrzebne byłyby warunki przed 3rozwiązaniem następnego terminu.

To jest golf golfowy, więc twój wynik będzie liczbą bajtów w twoim programie, przy czym niższy wynik będzie lepszy.

Przypadki testowe

przypadki testowe są obcinane dla uproszczenia

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 bajtów

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

Anonimowa funkcja, która po wywołaniu tworzy funkcję, fktóra daje element o podanym indeksie w sekwencji.

Daj mi znać, jeśli coś źle zrozumiem ...

Łuska , 7 6 bajtów

¡S!o_L

Zwraca nieskończoną listę. Wypróbuj online! Zauważ, że TIO może chwilę obciąć i wydrukować wynik.

Wyjaśnienie

Operator ¡ma kilka znaczeń. Używam tutaj „konstruuj nieskończoną listę, iterując funkcję, która oblicza nowy element z listy istniejących”. Biorąc pod uwagę listę długości N , nowy element będzie miał indeks oparty na 1 N + 1 . Wszystko, co musimy zrobić, to zanegować ostatni element listy (który jest poprzednią wartością) i zindeksować listę za pomocą wyniku.

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

Haskell , 36 bajtów

Pobiera listę i zwraca funkcję indeksującą sekwencję

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

Wypróbuj online!

Wyjaśnienie

Tutaj definiujemy funkcję, !która pobiera listę li indeks n. Jeśli njest mniejsza niż długość lindeksujemy lwedług n, w przeciwnym razie wracamy l!((n-1)-l!(n-1)). Jest to zgodne z rekurencyjną definicją funkcji podanej w pytaniu.

Oto ten sam program bez golfa.

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

Używam e<-n-1zamiast tego do zapisywania bajtów podczas przypisywania, n-1aby emożna było z nich później skorzystać.

MATL , 13 9 bajtów

:"tt0)_)h

Zwraca początkowe warunki, po których następuje n dodatkowych warunków (dozwolonych przez wyzwanie), gdzie n jest dodatnią liczbą całkowitą przyjętą jako dane wejściowe.

Wypróbuj online!

Wyjaśnienie

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

pobiera dwa dane wejściowe

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

Wypróbuj online!

-3 bajty od Martina Endera

R , 55 bajtów

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

Wypróbuj online!

Zajmuje dwa wejścia.

Standardowy ML (MLton) , 58 bajtów

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

Wypróbuj online! Funkcja apobiera początkową listę i indeks i zwraca element sekwencji pod tym indeksem. Przykładowe użycie: a [4,3,1] 5daje 4.

Galaretka , 6 bajtów

NṪịṭµ¡

Bierze sekwencji S i to liczba całkowita K i dodaje k warunki do S .

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online!

CJam, 10 bajtów

{{(_j-j}j}

W przypadku CJam robi to bardzo dobrze (nawet bije 05ab1e!).

Jest to anonimowy blok, który oczekuje danych wejściowych w formie i nna stosie, gdzie ijest indeksem w sekwencji i ntablicą liczb początkowych.

Powodem, dla którego działa to tak dobrze, jest joperator, który zapewnia zapamiętaną rekurencję z zestawu wartości początkowych.

Wyjaśnienie:

{    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 bajtów

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

Pobiera dwa dane wejściowe (tablica aliczb całkowitych i liczba całkowita n) i wysyła ndziesiątą wartość sekwencji.

Wyjaśnienie:

Wypróbuj tutaj.(Może to potrwać kilka sekund.)

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) bajtów

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

Wypróbuj online

05AB1E , 20 bajtów

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

Oczekuje, że dane wejściowe będą rozdzielone spacjami, a dane wyjściowe będą przesyłane w nieskończoność; całkiem prosta implementacja

Przykładowy przebieg:

$ 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 bajtów

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

Wypróbuj online!

Perl 5 , -a30 bajtów

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

Wypróbuj online!