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

Terinspirasi oleh Puzzle ini , diberi bilangan bulat $n>0$ , cetak urutan berikut sampai Anda mencapai non-Integer (rusak, jika Anda ingin menyelesaikan sendiri teka-teki itu)

$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)$
atau lebih intuitif: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

TestCases:

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

Input dan Output dapat diambil dalam format yang masuk akal, celah standar sama terlarang seperti biasanya.

Dalam semangat kode-golf , jawaban terpendek dalam byte menang!

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

05AB1E (warisan) , 18 17 byte

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

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

[                # 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

Saya menggunakan versi lawas 05AB1E di sini, dan juga pertama menghitung angka berikutnya sebelum mencetaknya, karena loop berbasis 0 dan akan dilakukan /0dalam iterasi pertama. Ini menyimpan byte dibandingkan dengan sebelumnya N>dan "*+-/". Ini hanya berfungsi, karena dalam versi lawas angka yang dibagi 0 tetap sama; sedangkan dalam versi baru itu akan menjadi 0; dan dalam matematika aktual itu akan memberikan pembagian dengan kesalahan nol.

Gores 3.0 39 blok / 323 byte

Cobalah garis awal!

Atau, seperti sintaks 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

Lihatlah kalian, bersenang-senang dengan evalpernyataan mewah Anda ! Yah, bukan aku! Tidak ... Scratch tidak memiliki evals, jadi saya harus melakukan hal-hal dengan cara yang sulit ... jika pernyataan.

Setidaknya itu bukan goto...

Ruang putih , 251 227 202 byte

[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]

Huruf S(spasi), T(tab), dan N(baris baru) ditambahkan hanya sebagai penyorotan.
[..._some_action]ditambahkan sebagai penjelasan saja.

Cobalah online (dengan spasi, tab, dan hanya baris baru).

-24 byte setelah komentar dari @JoKing menyarankan n%i > 0. Meskipun hanya if(x < 0)dan if(x == 0)tersedia di Whitespace, hanya memeriksa if(x*-1 < 0)pada dasarnya sama dengan if(x > 0).
Tambahan -25 byte berkat @ JoKing .

Penjelasan:

Kutipan dari jawaban Scratch :

Setidaknya itu bukan goto...

Apa ada yang bilang goto? Spasi tidak memiliki apa-apa selain gotomembuat loop dan pernyataan-if. xD Selain itu bahasa berbasis stack, jadi saya harus sering bertukar / membuang / menyalin. Dan yang terpenting: Whitespace bahkan tidak memiliki floating point dan hanya integer-division, jadi saya telah menggunakan n % i * -1 < 0untuk keluar dari program jika integer tidak dapat membagi angka saat ini.

Kode semu:

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 byte

Terima kasih -1 byte ke Will Ness -1 byte terima kasih kepada 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

Cobalah online!

Menghindari penggunaan int fraksional untuk menghemat byte

JavaScript (V8) , 52 byte

Mencetak grup dengan 4 istilah. Terinspirasi oleh jawaban Ruby di GB .

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

Cobalah online!

JavaScript (V8) , 54 byte

Mencetak ketentuan urutannya.

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

Cobalah online!

JavaScript (ES6),  59  58 byte

Mengembalikan array.

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

Cobalah online!

Perl 6 , 44 byte

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

Cobalah online!

Blok kode anonim yang mengambil nomor dan mengembalikan urutan. Jika kita bisa melewatkan elemen pertama (yang selalu sama dengan elemen kedua), kita bisa menyimpan 3 byte dengan menghapus$_,

Python 3 , 60 byte

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

Cobalah online!

Piet , 297 190 144 codels (432 bytes)

Mencoba pendekatan baru menggunakan pointerperintah sebagai saklar (k mod 4) untuk menyatukan kode output, menghasilkan gambar kode 10x19 yang lebih padat. Lalu saya pindahkan ke bawah sebanyak 1 baris dan 2 kolom ke 8x18.

Berikut ini adalah jejaknya, untuk melihat cara kerjanya:

Baris pertama mendorong 0 pada stack sebagai indeks awal (karena kita hanya bisa push bilangan asli, kita dorong 2 dan kemudian kurangi), kemudian membaca input sebagai angka.

Kolom paling kiri memiliki kode bersama untuk menduplikasi nomor dan memasukkannya ke dalam output, kemudian memindahkan indeks di atas tumpukan, menambahnya dan kemudian menduplikasinya tiga kali. Kita kemudian memasuki blok berbentuk r merah pastel melalui cyan codel gelap untuk pointerperintah yang memberi kita jalan yang berbeda untuk sisa mod indeks 4 kita.

Mod 1, kita keluar melalui atas untuk berkembang biak. Kami pertama-tama mengacak salinan indeks kami untuk nanti, kemudian melakukan perkalian. Setelah melewati putih untuk noop, kita masukkan kolom di atas untuk memperbaiki paritas cc (perlu dibalik beberapa kali agar loop tetap stabil), diikuti olehpointer (1) memasuki bar magenta: Bertindak sebagai tangkap empat jalur kita dan kirim kita kembali ke loop.

Mod 2, kita keluar mundur untuk menjumlahkan. Bentuk blok kode pastel berarti kita keluar dari baris di atas dari tempat kita masuk, dan kita menggunakan 3 yang kita dorong ke tumpukan dengan keluar melalui kode merah untukpointer (3) diri kita sendiri ke atas. Kolom ini memiliki ruang putih sebelum aritmatika dan urutan yang sedikit berbeda untuk mendorong dan mengganti cc, karena jika tidak kita akan memiliki tumpang tindih warna dengan codel bernilai integer di kolom tetangga.

Mod 3 mengirim kami ke bawah untuk pengurangan. Kesepakatan yang sama dengan perkalian, kecuali kita melewati jalur pembagian saat naik (Karena cc memiliki paritas yang berbeda ketika memasuki bilah warna hijau pastel, dua eksekusi keluar dari bilah itu pada ujung yang berbeda). Saat melakukannya, kita mengambil duplicateperintah yang tidak diinginkan , jadi kita popmundur dengan codel hijau gelap sebelum memasuki bilah koreksi dan pengumpulan cc.

Mod 4, kita langsung ke depan untuk membagi. Di sini, pertama-tama kita harus mengocok-ulang tumpukan dengan lebih parah untuk mendapatkan dua pasang n dan a untuk melakukan operasi, karena kita perlu menguji apakah itu bilangan bulat. Kami melakukan itu modpada pasangan pertama, kemudian notpada hasilnya, lalu menggunakannya untuk a pointer- jika tidak dapat dibagi, kami terus berjalan lurus, yang mengirimkan kami dengan dua pointerperintah ke sudut yang berlawanan ke blok yang tidak terhindarkan dan dengan demikian mengakhiri program. Kalau tidak, kita belok kanan dan dapatkan divideperintah dari memasuki bilah magenta.

Versi lama

Kode yang sangat mudah: Menekan 1 dan input pada tumpukan, kemudian mengulangi empat operasi dengan: Mengocok indeks di atas tumpukan, menambahnya dengan 1, menggandakannya, mengocok satu salinan kembali ke bawah, melakukan operasi aritmatika, menduplikasi nomor dan memasukkan satu ke dalam output.

Untuk pembagian, yang merupakan satu-satunya di mana urutan dapat berakhir, ia menciptakan tumpukan yang lebih rumit untuk memeriksa terlebih dahulu apakah n mod index == 0, jika tidak maka ia akan memasuki kodel yang tidak terhindarkan dan berakhir. Kalau tidak, ia menggunakan salinan kedua dari i dan n untuk melakukan pembagian.

C # (Visual C # Interactive Compiler) , 72 , 70 , 69 byte

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

Cobalah online!

Ruby , 56 54 52 byte

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

Cobalah online!

Setelah beberapa upaya (gagal) dengan eval, saya menemukan bahwa solusi paling bahagia adalah membangun array dengan 4 elemen sekaligus, setidaknya di ruby.

Terima kasih kepada Arnauld untuk -2 byte.

R , 90 byte , 87 byte 85 byte, 80 byte, 74, 73 byte

Implementasi aturan yang sederhana:

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]

Cobalah online!

dengan T<13berikut dari analisis teka-teki yang lebih dalam. Memang hanya ada tiga macam urutan: yang panjang 4, ketika a⁰ tidak sama dengan 1 modulo 8; mereka yang panjangnya 12 ketika a⁰ kongruen dengan 21 modulo 32; dan yang panjangnya 8 untuk kasus yang tersisa.

Kode alternatif yang menghindari pengulangan menjadi lebih lama dengan 87 byte:

`~`=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]

Cobalah online!

Haskell , 104 86 85 byte

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

Cobalah online!

The h=dapat dihilangkan karena itu hanya digunakan untuk pengujian.

Ah, golf kode, di mana peningkatan kuadrat dalam kompleksitas waktu sepadan untuk pengurangan satu karakter.

104 byte

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

Cobalah online!

Saya suka jawaban ini lebih baik, tetapi sayangnya lebih lama.

Japt , 25 24 byte

Adaptasi lain dari solusi Ruby GB .

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

Cobalah

Trik utama di sini adalah kelebihan cmetode untuk array. Berikan array lain sebagai argumen dan menggabungkannya ke array asli. Berikan nomor sebagai argumen, seperti yang terjadi pada panggilan rekursif terakhir, dan meratakan array asli dengan banyak tingkatan - 1dalam hal ini, setelah pembulatan. Tetapi, karena array hanya sedalam satu level, perataannya tidak berpengaruh.

%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 byte

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

Cobalah online.

Membuat array dengan keempat nilai diinspirasikan oleh @GB 's Ruby answer , walaupun sekarang saya perhatikan bahwa menggunakan pernyataan terary if adalah jumlah byte yang sama:

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

Cobalah online.

Perl 5 , 53 byte

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

Cobalah online!

Merah , 102 byte

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]]

Cobalah online!

AWK , 57 byte

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

Cobalah online!

Rutger , 310 byte

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

Cobalah online!

Sudah saatnya saya menggunakan Rutger lagi. Sayangnya, ini mungkin bukan bahasa terbaik untuk tugas tersebut, karena tidak memiliki bentukeval , memaksa saya untuk menggunakan empat pernyataan if

Bagaimana itu bekerja

Bagaimana Rutger bekerja

Kata pengantar singkat tentang cara kerja bahasa: Semuanya bisa berupa tugas atau fungsi, dan setiap fungsi hanya membutuhkan satu argumen. Untuk operasi yang memerlukan lebih dari satu argumen (mis. Multiplikasi), panggilan pertama mengembalikan fungsi parsial , yang, ketika dipanggil lagi dengan argumen kedua, mengembalikan hasil yang diharapkan. Sebagai contoh:

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

akan mencetak 30: Cobalah online!. Meskipun biasanya ini lebih panjang dari alternatif yang biasa, kadang-kadang dapat menyimpan byte, jika suatu fungsi dipanggil berulang kali dengan satu argumen konstan, dan satu argumen berubah, misalnya saat mencetak tabel waktu.

Aturan satu argumen ini berlaku untuk semua yang bukan konstanta atau variabel, termasuk loop dan kondisional. Namun, loop dan conditional ( For, Each, While, DoWhile, Ifdan IfElse) yang bisa dilakukan , yang berarti bahwa untuk benar-benar menjalankan mereka,Do fungsi harus dipanggil (lihat baris terakhir dalam jawaban). Sekali lagi, ini dapat menyimpan byte ketika berulang kali menjalankan loop yang sama, atau memungkinkan Anda untuk menjalankan kode arbitrer antara definisi dan menjalankan loop.

Akhirnya, ada tiga cara merujuk ke variabel, yang semuanya digunakan dalam program ini. Yang pertama adalah referensi langsung , di mana nama variabel diawali dengan $simbol. Ini mengakses nilai variabel secara langsung dan mengembalikannya. Yang kedua adalah referensi fungsional , yang tidak memiliki karakter awalan. Ini memungkinkan kode untuk membedakan antara fungsi (berpotensi parsial) yang ditugaskan untuk variabel, dan variabel aktual yang mengandung nilai tertentu. Akhirnya, referensi tidak langsung , diawali dengan @simbol, membuat variabel (jika belum ada) dan mengembalikan objek variabel dalam ruang lingkup yang diberikan. Ini memungkinkan Anda untuk membuat variabel loop (misalnya idalam for i in range(...)).

Cara kerja solusi yang sebenarnya

Berikut adalah kode yang tidak dipisahkan:

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

Cobalah online!

Seperti yang Anda lihat, itu dimulai dengan menetapkan tiga variabel n, edan a, yang mewakili input, elemen perubahan dalam urutan, dan nomor modifikasi untuk masing-masing elemen baru. Kami kemudian membuat loop sementara:

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

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

Selanjutnya kita sampai pada monstrositas absolut yang terdiri dari tubuh while loop:

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

Pernyataan pertama mencetak setiap iterasi dari urutan sebelum mengubahnya. Kami kemudian membuat fungsi parsial untuk memeriksa kesetaraan dengan variabel loop x, dan menemukan empat pernyataan if. Setiap cek pernyataan jika xsama dengan 1, 2, 3 atau 4 masing-masing, dan kemudian ditunjuk kuntuk setiap fungsi dalam *, +, -dan /, kemudian membuatnya menjadi fungsi parsial dengan esebagai argumen. Akhirnya, kami menetapkan euntuk kmenjalankan dengan aargumen kedua, dan kenaikan a.

Ruby , 52 byte

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

Cobalah online!

C (dentang) , 80 byte

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

Cobalah online!

A golfed switch statement.   

Berkat banyak perbaikan @ceilingcat.

dzaima / APL, 34 33 byte

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

Cobalah online!

-1 terima kasih kepada ngn

TI83 / 84 BASIC, 69 Bytes

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

Kami menyiapkan penghitung di A dan menghapus L1 sehingga kami dapat menggunakannya untuk melacak urutan. Kami kemudian ulangi sampai langkah pembagian menyebabkan sebagian kecil. Di dalam loop kita pertama kali menyimpan N ke daftar. Menyimpan ke satu elemen melewati akhir daftar atau daftar kosong membuat elemen itu, jadi yang satu ini menyimpan hasil pembagian ketika itu tidak menyebabkan pecahan, dan menginisialisasi daftar selama lintasan pertama. Kami kemudian menggunakan augment untuk menambahkan 3 syarat urutan berikutnya. Matematika bekerja beberapa byte lebih kecil dengan menghitung istilah A4k + 3 dalam variabel O dan kemudian mendasarkan A4k + 2 dan A4k + 4 dari O. Kemudian kita melakukan pembagian secara terpisah untuk mengatur ulang N untuk pemeriksaan ulang dan menambahkan 4 ke A.

Saya meletakkan Disp L1 di akhir tetapi saya tidak yakin seberapa ideal itu karena tidak ada cara yang baik untuk memenuhi semua persyaratan di layar. Secara realistis pengguna akan menjalankan L1 setelah program berjalan secara manual untuk menggulir hasil.

Arang , 29 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

Masukkan nilai awal.

Ｗ¬﹪θ¹«

Ulangi sampai nilainya tidak lagi bilangan bulat.

Ｉθ⸿

Cetak nilai pada barisnya sendiri.

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

Hitung empat operasi aritmatika yang tersedia dan pilih yang benar tergantung pada nomor jalur keluaran saat ini.

Python 3 , 78 76 byte

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

Cobalah online!

Mengambil input sebagai daftar 1 item dan secara berulang menambahkan item berikutnya dari urutan hingga non-integer.

Dalam hal tidak diperbolehkan memasukkan input sebagai daftar, berikut adalah versi yang sangat cepat ditambal yang mengambil input sebagai int.

Input sebagai integer, 102 byte

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)")])

Cobalah online!

+2 byte terima kasih karena saya lupa menyebutkan nama fungsi rekursif ...
-4 byte terima kasih kepada Jitse

Ranting , 164 byte

Oke, ini benar-benar mengerikan untuk ditulis.

Keterbatasan:

• Tidak returns ! Anda baik output atau tidak output
• Tidak ada whileloop. Kamu harus menggunakan rekursi atau tidak sama sekali
• Tidak ada cara mudah untuk menghasilkan! Anda harus mengulang output setiap kali
• Anda tidak dapat memberikan nilai pada variabel tanpa menggunakan set tag
• Tidak ada cara mudah untuk keluar dari lingkaran. Tidak ada break, continue,goto atau serupa. Ini membuat loop tidak mungkin digunakan.
• Hanya ada 1 loop:, for ... in ....dan loop atas semua elemen dalam array, tanpa ada cara untuk berhenti.

Semua itu membuat kodenya luar biasa!
Hei, aku bahkan membuatnya lebih lama dari jawaban Java!
Ini sepanjang jawaban JavaScript dari Arnauld ! ... Dengan ketiga alternatif tersebut digabungkan.

Ini kodenya:

{%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%}

Anda dapat mencobanya di https://twigfiddle.com/zw5zls

Bagaimana cara menggunakan:

Cukup impor file dan panggil makro pertama.

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

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

Untuk memiliki array yang dapat digunakan, Anda bisa melakukannya a.a(21)|split(',').

Tidak Disatukan:

{% 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 %}

Seharusnya mudah dibaca.
Jawaban yang tidak diklik ini TIDAK akan memberikan hasil yang benar, karena akan membuang spasi putih acak.
Itu ada hanya agar bisa dibaca secara manusiawi.