21, 21, 23, 20, 5, 25, 31, 24,?

Zainspirowany tą łamigłówką , biorąc pod uwagę liczbę całkowitą , wydrukuj następującą sekwencję, aż dojdziesz do liczby niecałkowitej (zepsute, na wypadek gdybyś chciał rozwiązać zagadkę samodzielnie)$n>0$

$a_0 = n$
$a_{4k+1} = a_{4k} \cdot(4k+1)$
$a_{4k+2} = a_{4k+1} + (4k+2)$
$a_{4k+3} = a_{4k+2} - (4k+3)$
$a_{4k+4} = a_{4k+3} / (4k+4)$
lub bardziej intuicyjnie: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

Przypadki testowe:

1: 1, 1, 3, 0, 0, 0, 6, -1
2: 2, 2, 4, 1
3: 3, 3, 5, 2
4: 4, 4, 6, 3
5: 5, 5 , 7, 4, 1, 5, 11, 4
6: 6, 6, 8, 5
9: 9, 9, 11, 8, 2, 10, 16, 9
21: 21, 21, 23, 20, 5, 25, 31, 24, 3, 27, 37, 26

Dane wejściowe i wyjściowe można przyjmować w dowolnym rozsądnym formacie, standardowe luki są jak zwykle zabronione.

W duchu golfa kodowego wygrywa najkrótsza odpowiedź w bajtach!

Piaskownica: https://codegolf.meta.stackexchange.com/a/18142/59642

05AB1E (starsza wersja) , 18 17 bajtów

[N"/*+-"Nè.VÐïÊ#=

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

[                # Start an infinite loop:
 N               #  Push the 0-based loop-index
  "/*+-"         #  Push string "/*+-"
        Nè       #  Index into this string with the loop-index
          .V     #  And use a 05AB1E-eval to calculate the next number
 Ð               #  Triplicate this number
  ï              #  Cast it to an integer
   Ê             #  And if it's NOT equal to the number we triplicated:
    #            #   Stop the infinite loop
  =              #  Print the number without popping

Używam tutaj starszej wersji 05AB1E, a także najpierw obliczyć następną liczbę przed wydrukowaniem, ponieważ pętla jest oparta na 0 i wykona to /0w pierwszej iteracji. To zaoszczędziło bajt w porównaniu z poprzednim N>i "*+-/". Działa to tylko, ponieważ w starszej wersji liczba dzielona przez 0 pozostaje taka sama; mając na uwadze, że w nowej wersji stałoby się 0; i w rzeczywistej matematyce dałoby podział przez błąd zero.

Scratch 3.0 39 bloków / 323 bajtów

Wypróbuj online !

Alternatywnie, jako składnia SB:

when gf clicked
delete[all v]of[o v
ask()and wait
set[. v]to(answer
set[n v]to(1
repeat until<(n)contains[.
if<((n)mod(4))=(0
set[. v]to((. )*(n
else
if<((n)mod(4))=(1
change[. v]by(n
else
if<((n)mod(4))=(2
change[. v]by((0)-(n
else
set[. v]to((. )/(n
end
end
end
add(n)to[o v
change[n v]by(1
end
delete(length of(o))of[o v

Spójrzcie na was, bawcie się swoimi fantazyjnymi evalwypowiedziami! Cóż, nie ja! Nie ... Scratch nie ma ewaluacji, więc musiałem robić rzeczy ciężko ... jeśli stwierdzenia.

Przynajmniej to nie gotojest ...

Biała spacja , 251 227 202 bajtów

[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][T N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S T S S T   N
_Copy_2nd_item][S T S S T   N
_Copy_2nd_item][S N
S _Duplicate_top][S S S T   S S N
_Push_4][T  S T T   _Modulo][S N
S _Duplicate_top][N
T   S S N
_If_0_Jump_to_Label_DIVIDE][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate_top][N
T   S T N
_If_0_Jump_to_Label_MULTIPLY][S S S T   N
_Push_1][T  S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_ADD][S N
T   _Swap_top_two][S T  S S T   N
_Copy_2nd_item][T   S S T   _Subtract][N
S N
N
_Jump_to_LOOP][N
S S S N
_Create_Label_DIVIDE][S N
N
_Discard_top][T S T S _Divide][S T  S S T   S N
_Copy_3nd_item][S T S S T   S N
_Copy_3nd_item][T   S T T   _Modulo][N
T   S N
_If_0_Jump_to_Label_LOOP][N
N
N
_Exit_Program][N
S S T   N
_Create_Label_MULTIPLY][S N
N
_Discard_top][T S S N
_Multiply][N
S N
N
_Jump_to_Label_LOOP][N
S S S S N
_Create_Label_ADD][T    S S S _Add][N
S N
N
_Jump_to_Label_LOOP]

Litery S(spacja), T(tab) i N(nowa linia) dodane tylko jako wyróżnienia.
[..._some_action]dodano tylko jako wyjaśnienie.

Wypróbuj online (tylko z surowymi spacjami, tabulatorami i nowymi wierszami).

-24 bajty po komentarzu sugerującym @JoKingn%i > 0 . Chociaż tylko if(x < 0)i if(x == 0)są dostępne w białej spacji, zwykłe sprawdzanie if(x*-1 < 0)jest w zasadzie takie samo jak if(x > 0).
Dodatkowe -25 bajtów dzięki @JoKing .

Wyjaśnienie:

Cytat z odpowiedzi Scratch :

Przynajmniej to nie gotojest ...

Czy ktoś powiedział goto? Biała spacja nie ma nic poza gototworzeniem zarówno pętli, jak i instrukcji if. xD Dodatkowo jest to język oparty na stosie, więc muszę często zamieniać / odrzucać / kopiować. I na koniec: białe znaki nie mają nawet liczb zmiennoprzecinkowych, a jedynie dzielenie liczb całkowitych, więc korzystałem n % i * -1 < 0z programu, jeśli liczba całkowita nie może podzielić bieżącej liczby.

Pseudo kod:

Integer n = STDIN as input
Integer i = 0
Label LOOP:
  Print n as number
  i = i + 1
  Integer t = i % 4
  If(t == 0):
    Jump to Label DIVIDE
  t = t - 1
  If(t == 0):
    Jump to Label MULTIPLY
  t = t - 1
  If(t == 0):
    Jump to Label ADD
  n = n - i
  Jump to Label LOOP
Label DIVIDE:
  n = n / i
  Integer m = n % i
  If(m == 0):
    Jump to Label LOOP
  Exit program
Label MULTIPLY:
  n = n * i
  Jump to Label LOOP
Label ADD:
  n = n + i
  Jump to Label LOOP

Haskell , 75 74 73 bajtów

-1 bajt dzięki Will Ness -1 bajt dzięki nimi

(#1)
n#i|i`mod`4<1,n`mod`i>0=[n]|y<-i+1=n:(x!!i)n i#y
x=div:(*):(+):(-):x

Wypróbuj online!

Unika używania ułamkowych liczb całkowitych, aby zaoszczędzić na bajtach

JavaScript (V8) , 52 bajty

Drukuje grupy 4 terminów. Zainspirowany odpowiedzią GB Ruby .

n=>{for(k=0;n%1==0;n/=k+=3)print(n,n*=++k,n-~k,--n)}

Wypróbuj online!

JavaScript (V8) , 54 bajty

Drukuje warunki sekwencji.

n=>{for(k=0;n%1==0;n=eval(n+'*+-/'[k++&3]+k))print(n)}

Wypróbuj online!

JavaScript (ES6),  59  58 bajtów

Zwraca tablicę.

f=(n,k)=>k&&(n=eval(n+'/*+-'[k&3]+k))%1?[]:[n,...f(n,-~k)]

Wypróbuj online!

Perl 6 , 44 bajtów

{$_,{($_,<* + - />[$++%4]~++$).EVAL}...^*%1}

Wypróbuj online!

Anonimowy blok kodu, który pobiera liczbę i zwraca sekwencję. Gdybyśmy mogli pominąć pierwszy element (który zawsze jest taki sam jak drugi element), moglibyśmy zaoszczędzić 3 bajty, usuwając$_,

Python 3 , 60 bajtów

f=lambda n,i=1:[]if n%1else[n]+f([n/i,n*i,n+i,n-i][i%4],i+1)

Wypróbuj online!

Piet , 297 190 144 kodów (432 bajty)

Wypróbowałem nowe podejście, używając pointerpolecenia jako przełącznika (k mod 4) w celu ujednolicenia kodu wyjściowego, co skutkuje gęstszym obrazem kodu 10x19. Potem grałem w golfa o 1 rząd i 2 kolumny do 8x18.

Oto ślad, aby zobaczyć, jak to działa:

Pierwszy wiersz wypycha 0 na stosie jako indeks początkowy (ponieważ możemy tylko pushliczby naturalne, wypychamy 2, a następnie odejmujemy), a następnie odczytuje dane wejściowe jako liczbę.

Kolumna znajdująca się najbardziej po lewej stronie ma wspólny kod duplikowania liczby i wstawiania jednego do wyniku, a następnie przesuwania indeksu na szczycie stosu, zwiększania go, a następnie trzykrotnie. Następnie wprowadzamy pastelowy czerwony blok w kształcie litery R przez ciemnobłękitny kod, aby uzyskać pointerpolecenie, które daje nam różne ścieżki dla reszty naszego indeksu mod 4.

Mod 1, wychodzimy przez górę, aby się pomnożyć. Najpierw tasujemy kopię naszego indeksu na później, a następnie wykonujemy mnożenie. Po przejściu przez biel dla noop, wchodzimy do kolumny powyżej, aby naprawić parzystość cc (musi być odwrócona parzystą liczbę razy, aby utrzymać stabilność pętli), a następnie pointer (1)od wejścia do magenta paska: Działa jak złap nasze cztery ścieżki i odeślij nas z powrotem do pętli.

Mod 2, wychodzimy wstecz do sumy. Kształt pastelowego bloku kodu oznacza, że ​​wychodzimy z wiersza powyżej miejsca, w którym weszliśmy, i używamy 3, które wciskamy na stos, wychodząc przez czerwony kod do pointer (3)siebie. Kolumny te mają białą spację przed arytmetyką i nieco inną kolejność pchania i przełączania cc, ponieważ w innym przypadku kolory sąsiadowałyby z koderami o wartościach całkowitych w sąsiedniej kolumnie.

Mod 3 wysyła nas w dół do odejmowania. To samo, co mnożenie, z tą różnicą, że po drodze przekraczamy ścieżkę podziału (ponieważ cc ma różną parzystość przy wchodzeniu do pastelowego zielonego paska, dwie egzekucje wychodzą z tego paska na różnych końcach). Robiąc to, wybieramy niechciane duplicatepolecenie, więc popwycofujemy się z ciemnozielonym kodem przed wejściem do paska korekcji i zbierania CC.

Mod 4, idziemy od razu do podziału. Tutaj najpierw musimy poważniej przetasować stos, aby uzyskać dwie pary n i a do wykonania operacji, ponieważ musimy sprawdzić, czy jest to liczba całkowita. Robimy to modna pierwszej parze, a następnie notna wyniku, a następnie używamy tego do pointer- jeśli nie jest to podzielne, idziemy prosto, co wysyła nam dwie pointerkomendy do przeciwległego rogu do nieuniknionego bloku, a tym samym kończy program. W przeciwnym razie skręcamy w prawo i dostajemy dividepolecenie wejścia do karmazynowego paska.

Stara wersja

Bardzo prosty kod: wypycha 1 i dane wejściowe na stosie, a następnie przechodzi przez cztery operacje przez: tasowanie indeksu na stosie, zwiększanie go o 1, duplikowanie, tasowanie jednej kopii z powrotem w dół, wykonywanie operacji arytmetycznej, powielanie liczby i wstawianie jednego do wyniku.

W przypadku podziału, który jako jedyny może zakończyć sekwencję, tworzy bardziej skomplikowany stos, aby najpierw sprawdzić, czy n mod index == 0, w przeciwnym razie wchodzi do nieuniknionego kodera i kończy się. W przeciwnym razie używa drugiej kopii iin do wykonania podziału.

C # (interaktywny kompilator Visual C #) , 72 , 70 , 69 bajtów

n=>{for(int i=1;n%1==0;n=new[]{n/i,n*i,n+i,n-i}[i++%4])Write(n+" ");}

Wypróbuj online!

Rubin , 56 54 52 bajtów

f=->n,z=1{n%1>0?[]:[n,n*=z,n-~z,n-=1]+f[n/=z+3,z+4]}

Wypróbuj online!

Po kilku (nieudanych) próbach evalzorientowałem się, że najszczęśliwszym rozwiązaniem jest zbudowanie tablicy z 4 elementami jednocześnie, przynajmniej w rubinie.

Dzięki Arnauld za -2 bajty.

R , 90 bajtów , 87 bajtów 85 bajtów 80 bajtów 74 73 bajtów

Proste wdrożenie zasad:

a=scan();while(T<13)a=c(a,d<-a[T]*T,d+T+1,e<-d-1,e/((T<-T+4)-1));a[!a%%1]

Wypróbuj online!

z T<13następującymi informacjami z głębszej analizy układanki. Rzeczywiście istnieją tylko trzy rodzaje sekwencji: o długości 4, gdy a⁰ nie jest zgodne z 1 modułem 8; te o długości 12, gdy a⁰ jest zgodne z 21 modulo 32; i te o długości 8 dla pozostałych przypadków.

Alternatywny kod unikający pętli kończy się na 87 bajtach:

`~`=rep;b=(scan()-1)*c(32~4,8,40~3,1,9~3)/32+c(1,1,3,0~3,6,-c(8,1,9,-71,17)/8);b[!b%%1]

Wypróbuj online!

Haskell , 104 86 85 bajtów

n#i=n:(cycle[(/),(*),(+),(-)]!!floor i)n i#(i+1)
takeWhile((==).ceiling<*>floor).(#1)

Wypróbuj online!

h=Można pominąć, ponieważ jest on używany tylko do testów.

Ach, golf golfowy, gdzie warto zwiększyć kwadratową złożoność czasu, aby zmniejszyć jedną postać.

104 bajty

f=flip
g x=scanl(f($))x.zipWith(f($))[1..].cycle$f<$>[(*),(+),(-),(/)]
takeWhile((==).ceiling<*>floor).g

Wypróbuj online!

Bardziej podoba mi się ta odpowiedź, ale niestety jest ona dłuższa.

Japt , 25 24 bajtów

Kolejna adaptacja rozwiązania Ruby GB .

%1ª[UU*=°VU´ÒVU]cßU/=V±3

Spróbuj

Główną sztuczką jest tutaj przeciążenie cmetody tablic. Przekaż mu inną tablicę jako argument i połączy ją z pierwotną tablicą. Podaj mu liczbę jako argument, jak ma to miejsce przy ostatnim wywołaniu rekurencyjnym, i spłaszczy pierwotną tablicę o tyle poziomów - 1w tym przypadku po zaokrągleniu. Ponieważ jednak tablica ma zawsze tylko jeden poziom głębokości, spłaszczenie nie ma żadnego efektu.

%1ª[UU*=°VU´ÒVU]cßU/=V±3     :Implicit input of integer U
%1                           :U modulo 1
  ª                          :Logical OR with
   [                         :Construct and array containing
    U                        :  U
     U*=                     :  U multiplied by
        °V                   :    V (initially 0) prefix incremented
          U´                 :  The new value of U, postfix decremented
            ÒV               :    Subtract the bitwise negation of V
              U              :  The now-decrmented U
               ]             :End array
                c            :Concatenate, or flatten by
                 ß           :  Recursive call to the programme with argument
                  U/=        :    U divided by
                     V±3     :      V incremented by 3

Java 8, 84 bajtów

n->{for(int i=1;n%1==0;n=new float[]{n/i,n*i,n+i,n-i}[i++%4])System.out.println(n);}

Wypróbuj online.

Inspiracją jest tworzenie tablicy ze wszystkimi czterema wartościami Rubinową odpowiedzią @GB , chociaż teraz zauważam, że użycie trójskładnikowej instrukcji if jest taką samą ilością bajtów:

n->{for(int i=0;n%1==0;n=++i%4<1?n/i:i%4<2?n*i:i%4<3?n+i:n-i)System.out.println(n);}

Wypróbuj online.

Perl 5 , 53 bajtów

@a=qw(/ * + -);say,eval"\$_$a[++$i%4]=$i"while$_==int

Wypróbuj online!

Czerwony , 102 bajty

func[n][k: m: 0 until[foreach o[* + - /][print n t: n
n: do reduce[n o m: m + 1]]k: k + 1 t % m <> 0]]

Wypróbuj online!

AWK , 57 bajtów

{n=$1;for(k=1;n%1==0;n/=k++)print n,n*=k++,n+=k++,n-=k++}

Wypróbuj online!

Rutger , 310 bajtów

n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];

Wypróbuj online!

Najwyższy czas ponownie użyć Rutgera. Niestety, może to nie być najlepszy język dla tego zadania, ponieważ nie ma żadnej formy eval, zmuszając mnie do użycia czterech instrukcji if

Jak to działa

Jak działa Rutger

Krótkie przedmowa o tym, jak działa język: wszystko jest albo przypisaniem, albo funkcją, a każda funkcja wymaga dokładnie jednego argumentu. W przypadku operacji wymagających więcej niż jednego argumentu (np. Mnożenie) pierwsze wywołanie zwraca funkcję częściową , która po ponownym wywołaniu z drugim argumentem zwraca oczekiwany wynik. Na przykład:

left = Times[5];
Print[left[6]];

wydrukuje 30: Wypróbuj online!. Chociaż zwykle jest to dłuższa niż zwykła alternatywa, może czasami oszczędzać bajty, jeśli funkcja jest wywoływana wielokrotnie z jednym stałym argumentem i jednym zmieniającym się argumentem, na przykład podczas drukowania tabel czasów.

Ta reguła jednego argumentu ma zastosowanie do wszystkiego, co nie jest stałą ani zmienną, w tym pętli i warunków warunkowych. Jednak pętli i instrukcji warunkowych ( For, Each, While, DoWhile, Ifi IfElse) są wykonalne , co oznacza, że aby właściwie prowadzonym nich, Dofunkcja musi być wywołana (patrz ostatni wiersz w odpowiedzi). Ponownie może to zaoszczędzić bajty przy wielokrotnym uruchamianiu tej samej pętli lub pozwolić na uruchomienie dowolnego kodu między definicją a uruchomieniem pętli.

Wreszcie istnieją trzy sposoby odwoływania się do zmiennych, z których wszystkie są używane w tym programie. Pierwszym z nich jest bezpośrednie odwołanie , w którym nazwa zmiennej poprzedzona jest $symbolem. Uzyskuje to bezpośredni dostęp do wartości zmiennej i zwraca ją. Drugim jest odwołanie funkcjonalne , które nie ma znaku prefiksu. Umożliwia to kodowi rozróżnienie między (potencjalnie częściowymi) funkcjami przypisanymi do zmiennych a rzeczywistymi zmiennymi zawierającymi określoną wartość. Wreszcie pośrednie odwołanie , poprzedzone @symbolem, tworzy zmienną (jeśli jeszcze nie istnieje) i zwraca obiekt zmiennej w danym zakresie. Umożliwia to utworzenie zmiennej pętli (np. iWfor i in range(...) ).

Jak działa rzeczywiste rozwiązanie

Oto nielepszy kod:

n = elem = $Input;
var = 0;
while = While[{
	mod = Modulo[$elem];
	Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
	Print[$elem];
	equal = Equal[$index];

	if = If[{ equal[1]; }];
	if = if[{ func = Times[$elem]; }];
	Do[$if];

	if = If[{ equal[2];}];
	if = if[{ func = Add[$elem];}];
	Do[$if];

	if = If[{ equal[3];}];
	if = if[{ func = Subtract[$elem];}];
	Do[$if];

	if=If[{ equal[4];}];
	if=if[{ func = Divide[$elem];}];
	Do[$if];

	elem = func[var = Increment[$var]];
	}];
	Do[$for];
}];
Do[$while];

Wypróbuj online!

Jak widać, zaczyna przypisując trzy zmienne n, ei a, które stanowią wkład, zmieniający się element w sekwencji i numer modyfikacji dla każdego nowego elementu odpowiednio. Następnie tworzymy pętlę while:

w=While[{m=Modulo[$e];Not[m[1]];}];

{}me % m$1$$0$$0 \to 1$$n \to 0, n \ne 0$ .

Następnie dochodzimy do absolutnej potworności składającej się z ciała pętli while:

w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];

$4$x

Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e]    ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e]      ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e]   ;}];Do[$i];
e=k[a=Increment[$a]];

Pierwsza instrukcja wypisuje każdą iterację sekwencji przed jej modyfikacją. Następnie tworzymy funkcję częściową w celu sprawdzenia równości ze zmienną pętli xi napotykamy cztery instrukcje if. Każdy sprawdza komunikat, jeśli xma wartość 1, 2, 3 lub 4, odpowiednio, a następnie przydziela się kdo każdej funkcji *, +, -i /, następnie wprowadza się do funkcji z częściowym ejako argument. Wreszcie możemy przypisać edo kuruchomienia z ajako drugi argument i przyrostu a.

Ruby , 52 bajty

->n{i=0.0;n=[p(n)/i+=1,n*i,n+i,n-i][i%4]until 0<n%1}

Wypróbuj online!

C (brzęk) , 80 bajtów

i;f(n){for(i=0;~i;n=++i%4?i%4-1?i%4-2?n-i:n+i:n*i:n%i?i=-1:n/i)printf("%d ",n);}

Wypróbuj online!

A golfed switch statement.   

Dzięki wielu ulepszeniom @ceilingcat.

dzaima / APL, 34 33 bajty

⌽1↓{⍵,⍨⊃⍵(⍎⊃'÷×+-'⌽⍨≢⍵)≢⍵}⍣{⍵≢⌊⍵}

Wypróbuj online!

-1 dzięki ngn

TI83 / 84 BASIC, 69 bajtów

1→A
DelVar L1Prompt N
Repeat fPart(N
N→L1(A
NA-1→O
augment(L1,{NA,Ans+A+2,Ans→L1
O/(A+3→N
A+4→A
End
Disp L1

Ustawiliśmy licznik w A i wyczyściliśmy L1, abyśmy mogli go użyć do śledzenia sekwencji. Następnie powtarzamy, aż krok podziału spowoduje ułamek. Wewnątrz pętli najpierw przechowujemy N na liście. Przechowywanie jednego elementu poza końcem listy lub pustą listą tworzy ten element, więc ten sklep zapisuje zarówno wynik podziału, gdy nie powoduje ułamka, jak i inicjuje listę podczas pierwszego przejścia. Następnie używamy augmentu, aby dołączyć kolejne 3 terminy sekwencji. Matematyka wylicza kilka bajtów mniejszych, obliczając składnik A4k + 3 w zmiennej O, a następnie bazując A4k + 2 i A4k + 4 poza O. Następnie wykonujemy podział oddzielnie, aby zresetować N w celu powtórzenia kontroli i dodać 4 do A.

Na końcu umieszczam Disp L1, ale nie jestem pewien, jak idealny jest, ponieważ nie ma dobrego sposobu na dopasowanie wszystkich warunków na ekranie. Realistycznie użytkownik wykona L1 po ręcznym uruchomieniu programu, aby przewijać wyniki.

Węgiel drzewny , 29 bajtów

ＮθＷ¬﹪θ¹«Ｉθ⸿≔§⟦∕θⅉ×θⅉ⁺θⅉ⁻θⅉ⟧ⅉθ

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｎθ

Wprowadź wartość początkową.

Ｗ¬﹪θ¹«

Powtarzaj, aż wartość nie będzie już liczbą całkowitą.

Ｉθ⸿

Wydrukuj wartość w swoim własnym wierszu.

≔§⟦∕θⅉ×θⅉ⁺θⅉ⁻θⅉ⟧ⅉθ

Oblicz cztery dostępne operacje arytmetyczne i wybierz poprawną w zależności od bieżącego numeru linii wyjściowej.

Python 3 , 78 76 bajtów

f=lambda n:n[-1]%1and n[:-1]or f(n+[eval(f"n[-1]{'/*+-'[len(n)%4]}len(n)")])

Wypróbuj online!

Pobiera dane wejściowe jako listę 1 elementu i rekurencyjnie dołącza następny element sekwencji, dopóki nie będzie liczbą całkowitą.

W przypadku, gdy przyjmowanie danych wejściowych jako listy jest niedozwolone, tutaj jest bardzo łatana wersja, która przyjmuje dane wejściowe jako int.

Wprowadź jako liczbę całkowitą, 102 bajty

f=lambda n:type(n)==int and f([n])or n[-1]%1and n[:-1]or f(n+[eval(f"n[-1]{'/*+-'[len(n)%4]}len(n)")])

Wypróbuj online!

+2 bajty dzięki, że zapomniałem nazwać funkcję rekurencyjną ...
-4 bajty, dzięki Jitse

Gałązka , 164 bajty

Okej, pisanie tego było strasznie okropne.

Ograniczenia:

• Nie returns! Możesz albo wysyłać, albo nie wysyłać
• Bez whilepętli. Państwo musi użyć rekurencji albo nic
• Nie ma łatwego sposobu na wyjście! Musisz powtarzać wyjście za każdym razem
• Nie można nadać zmiennym wartości bez użycia setznacznika
• Nie ma łatwego sposobu na wyjście z pętli. Nie ma to break, continue, gotolub podobny. To uniemożliwia użycie pętli.
• Jest tylko jedna pętla: for ... in ....i zapętla wszystkie elementy w tablicy, bez możliwości zatrzymania.

Wszystkie te spowodowały, że kod był ogromny!
Hej, zrobiłem to nawet dłużej niż odpowiedź Java!
To tak długo, jak @ Arnauld's odpowiedź JavaScript ! ... Ze wszystkimi 3 alternatywami łącznie.

Oto kod:

{%macro a(b,n=1)%}{{n<2?b}}{%set b=b*n%},{{b}}{%set b=b+n+1%},{{b}}{%set b=b-(n+2)%},{{b}}{%set b=b/(n+3)%}{%if(b//1)==b%},{{b~_self.a(b,n+4)}}{%endif%}{%endmacro%}

Możesz spróbować https://twigfiddle.com/zw5zls

Jak używać:

Wystarczy zaimportować plik i wywołać pierwsze makro.

{% import 'file.twig' as a %}

{{ a.a(21) }} {# 21,21,23,20,5,25,31,24,3,27,37,26 #}

Aby mieć użyteczną tablicę, możesz to zrobić a.a(21)|split(',') .

Nie golfowany:

{% macro calc(number, index = 1) %}
    {% if index < 2 %}
        {{ number }}
    {% endif %}

    {% set number = number * index %},{{ number }}
    {% set number = number + index + 1 %},{{ number }}
    {% set number = number - (index + 2) %},{{ number }}
    {% set number = number / (index + 3) %}

    {#
        verifies if it is an integer.
        this is done with an integer division with 1 and compare with itself
        if both values are the same, the number is an integer
        otherwise, it is a floating-point number
    #}
    {% if (number // 1) == number %}
        ,{{ number ~ _self.calc(number, index + 4) }}
    {% endif %}
{% endmacro %}

Powinien być łatwy do odczytania.
Ta odpowiedź bez odpowiedzi NIE da poprawnego wyniku, ponieważ będzie generować losowe białe spacje.
Istnieje tylko po to, aby być czytelnym dla ludzi.