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

이 퍼즐 에서 영감을 얻은 정수 $n>0$ 지정하면 정수 가 아닌 사람이 될 때까지 다음 순서를 인쇄하십시오 (퍼즐을 먼저 풀고 싶다면 spoilered)

$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)$ 이상 직관적 : * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...
$a_{4k+4} = a_{4k+3} / (4k+4)$

테스트 사례 :

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

입력 및 출력 은 합리적인 형식으로 취해질 수 있으며 표준 허점은 평소와 같이 금지되어 있습니다.

code-golf 의 정신으로 바이트 단위의 최단 답변이 승리합니다!

샌드 박스 : https://codegolf.meta.stackexchange.com/a/18142/59642

05AB1E (레거시) , 18 17 바이트

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

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

여기에 05AB1E의 레거시 버전을 사용하고 있으며 루프가 0을 기반으로하고 /0첫 번째 반복에서 수행하기 때문에 인쇄하기 전에 다음 숫자를 먼저 계산하십시오 . 이전 N>과 비교하여 바이트를 절약했습니다 "*+-/". 레거시 버전에서 0으로 나눈 숫자는 동일하게 유지되므로이 방법 만 작동합니다. 반면 새 버전에서는 0이됩니다. 실제 수학에서는 0으로 나누기 오류가 발생합니다.

스크래치 3.0 39 블록 / 323 바이트

그것을 시도 줄 처음!

또는 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

당신의 멋진 eval진술 과 재미, 너희들을 봐 ! 글쎄, 난 아니야! 아니 ... 스크래치에는 회피가 없기 때문에 어려운 일을해야했습니다 ... if 문.

적어도 그것은 아닙니다 goto...

공백 , 251 227202 바이트

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

문자 S(공백), T(탭) 및 N(줄 바꾸기)가 강조 표시로만 추가되었습니다.
[..._some_action]설명으로 만 추가되었습니다.

온라인으로 시도하십시오 (원시 공백, 탭 및 줄 바꾸기 만).

@JoKing의 제안 후 -24 바이트 n%i > 0. 단지 있지만 if(x < 0)및 if(x == 0)공백에서 사용할 수있는, 간단하게 확인은 if(x*-1 < 0)기본적으로 동일하다 if(x > 0). @JoKing
덕분에 추가 -25 바이트 .

설명:

스크래치 답변 에서 인용 :

적어도 그것은 아닙니다 goto...

누군가가 말했 goto습니까? 공백은 goto루프와 if 문을 작성하는 것 외에는 아무것도 없습니다 . xD 또한 스택 기반 언어이므로 자주 교체 / 삭제 / 복사해야합니다. 그리고 공백 : 심지어 공백에는 부동 소수점이없고 정수 나누기가 없으므로 n % i * -1 < 0정수가 현재 숫자를 나눌 수없는 경우 프로그램을 종료하는 데 사용 했습니다.

의사 코드 :

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

하스켈 , 75 74 73 바이트

Will Ness 덕분에 -1 바이트 nimi 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

바이트를 절약하기 위해 분수 정수를 사용하지 않습니다.

자바 스크립트 (V8) , 52 바이트

4 개의 용어 그룹을 인쇄합니다. GB의 Ruby 답변에서 영감을 얻었습니다 .

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

온라인으로 사용해보십시오!

자바 스크립트 (V8) , 54 바이트

시퀀스의 항을 인쇄합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6),  59  58 바이트

배열을 반환합니다.

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

온라인으로 사용해보십시오!

펄 6 , 44 바이트

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

온라인으로 사용해보십시오!

숫자를 가져 와서 시퀀스를 반환하는 익명 코드 블록. 첫 번째 요소를 건너 뛸 수 있다면 (어쨌든 항상 두 번째 요소와 동일),$_,

파이썬 3 , 60 바이트

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

온라인으로 사용해보십시오!

선택 Piet , 297 190 144 codels (432 바이트)

pointer출력 코드를 통합하기 위해 switch (k mod 4) 명령을 사용하여 새로운 접근 방식을 시도하여 10x19 코드 그림이 더 조밀했습니다. 그런 다음 1 행과 2 열을 8x18로 줄였습니다.

작동 방식을 확인하기위한 추적은 다음과 같습니다.

첫 번째 줄은 스택에서 0을 시작 인덱스로 푸시합니다 ( push자연수 만 가능 하고 2를 푸시 한 다음 빼기 때문에) 입력을 숫자로 읽습니다.

가장 왼쪽의 collumn은 숫자를 복제하고 하나를 출력으로 튀어 나온 다음 스택의 맨 위로 인덱스를 이동하여 증가시킨 다음 세 번 복제하는 공유 코드를 가지고 있습니다. 그런 다음 어두운 청록색 코덱을 통해 파스텔 레드 r 모양의 블록으로 들어가서 pointer나머지 인덱스 모드 4에 대해 다른 경로를 제공합니다.

모드 1, 우리는 곱하기 위해 상단을 빠져 나옵니다. 먼저 색인 사본을 셔플 한 다음 곱셈을 수행합니다. noop에 대해 흰색을 통과 한 후 cc 패리티를 수정하기 위해 위의 콜럼에 들어갑니다 (루프를 안정적으로 유지하려면 짝수 번 뒤집어 야 함) pointer (1). 우리의 네 길을 잡아서 우리를 루프로 돌려 보내십시오.

모드 2, 우리는 요약하여 뒤로 나갑니다. 파스텔 코드 블록의 모양은 우리가 입력 한 곳에서 위의 행을 나가는 것을 의미하며, 빨간색 코덱을 통해 pointer (3)위쪽으로 나가서 스택에 밀어 넣은 3을 사용 합니다. 이 콜럼은 산술 전에 공백이 있고 cc를 밀고 전환하는 순서가 약간 다릅니다. 그렇지 않으면 이웃 콜럼의 정수 값 코덱과 색상이 겹치게됩니다.

Mod 3은 뺄셈을 위해 아래쪽으로 보냅니다. 도중에 나누기 경로를 건너는 것을 제외하고 곱셈과 같은 거래입니다 (파스텔 녹색 막대를 입력 할 때 cc의 패리티가 다르기 때문에 두 실행이 서로 다른 끝에서 해당 막대를 종료 함). 그렇게하는 동안 원치 않는 duplicate명령을 선택 하므로 popcc 수정 및 수집 표시 줄에 들어가기 전에 진한 녹색 코덱으로 되돌립니다.

모드 4, 우리는 나누기로 직진합니다. 여기서 우리는 정수를 테스트해야하기 때문에 먼저 스택을 다시 섞어서 n과 a의 두 쌍을 가져 와서 작업을 수행해야합니다. 우리는 mod첫 번째 쌍에서 그 일을 한 다음 not결과에 사용합니다. pointer분할 수없는 경우 계속 직진하여 두 개의 pointer명령을 사용하여 반대편 모서리에 피할 수없는 블록으로 보내 프로그램을 종료합니다. 그렇지 않으면 우회전 divide하여 자홍색 막대로 들어가는 명령을받습니다.

구 버전

매우 간단한 코드 : 1과 스택의 입력을 푸시 한 후 다음과 같이 4 가지 작업을 반복합니다. 숫자를 복제하고 하나를 출력에 띄웁니다.

시퀀스가 끝날 수있는 유일한 분할 인 경우에는 먼저 n mod index == 0인지 확인하는 더 복잡한 스택을 만들고 그렇지 않으면 피할 수없는 코덱에 들어가서 종료됩니다. 그렇지 않으면 i와 n의 두 번째 사본을 사용하여 나누기를 수행합니다.

C # (Visual C # Interactive Compiler) , 72 , 70 , 69 바이트

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

온라인으로 사용해보십시오!

루비 , 56 54 52 바이트

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

온라인으로 사용해보십시오!

로 (실패한) 시도를 한 후 eval, 가장 행복한 해결책은 적어도 루비로 한 번에 4 개의 요소로 배열을 작성하는 것입니다.

-2 바이트에 대한 Arnauld에게 감사합니다.

R , 90 바이트 , 87 바이트 85 바이트 80 바이트 74 73 바이트

규칙의 명확한 구현 :

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]

온라인으로 사용해보십시오!

와 T<13퍼즐의 깊은 분석에서 다음. 실제로 3 가지 종류의 서열이 존재한다 : a⁰가 1 모듈로 8과 일치하지 않는 길이 4의 서열; a⁰가 21 모듈로 32에 일치 할 때 길이 12의 것; 나머지 경우 길이는 8입니다.

루프를 피하는 대체 코드는 87 바이트로 길어집니다.

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

온라인으로 사용해보십시오!

하스켈 , 104 86 85 바이트

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

온라인으로 사용해보십시오!

는 h=이 테스트 용으로 만 사용되는 때문에 생략 할 수 있습니다.

아, 코드 골프는 시간 복잡성의 이차적 인 증가가 한 문자의 감소에 가치가 있습니다.

104 바이트

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

온라인으로 사용해보십시오!

나는이 대답을 더 좋아하지만 아쉽게 더 길다.

Japt , 25 24 바이트

GB의 루비 솔루션의 또 다른 적응 .

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

시도 해봐

여기서 주요 요령은 c배열 에 대한 메소드 의 오버로드입니다 . 다른 배열을 인수로 전달하면 원래 배열에 연결됩니다. 마지막 재귀 호출에서와 같이 숫자를 인수로 전달하고 1반올림 후 여러 수준만큼 원래 배열을 평탄화합니다 . 그러나 배열이 한 수준 깊기 때문에 평탄화해도 효과가 없습니다.

%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

자바 8, 84 바이트

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

온라인으로 사용해보십시오.

4 개의 모든 값으로 배열을 만드는 것은 @GB 의 Ruby answer 에서 영감을 얻었 지만 이제는 삼항 if 문을 사용하는 것이 같은 양의 바이트임을 알 수 있습니다.

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

온라인으로 사용해보십시오.

펄 5 , 53 바이트

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

온라인으로 사용해보십시오!

빨강 , 102 바이트

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

온라인으로 사용해보십시오!

AWK , 57 바이트

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

온라인으로 사용해보십시오!

Rutger , 310 바이트

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

온라인으로 사용해보십시오!

Rutger를 다시 사용한 시간입니다. 불행히도, 형식이 없으므로 작업에 가장 적합한 언어가 아닐 수 eval있으므로 4 개의 if 문을 사용해야합니다.

작동 원리

Rutger 작동 방식

언어의 작동 방식에 대한 간략한 서문 : 모든 것이 할당 또는 함수이며 모든 함수는 정확히 하나의 인수를 갖습니다. 둘 이상의 인수가 필요한 연산 (예 : 곱하기)의 경우 첫 번째 호출은 부분 함수를 반환하며 , 두 번째 인수로 다시 호출하면 예상 결과가 반환됩니다. 예를 들면 다음과 같습니다.

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

30을 출력합니다 : 온라인으로 사용해보십시오! . 일반적으로 이것은 일반적인 대안보다 길지만 함수가 하나의 상수 인수와 하나의 변경 인수로 반복적으로 호출되는 경우 (예 : 시간 테이블을 인쇄 할 때) 바이트를 절약 할 수 있습니다.

이 하나의 인수 규칙은 루프 및 조건을 포함하여 상수 또는 변수가 아닌 모든 항목에 적용됩니다. 그러나, 루프와 조건문이 ( For, Each, While, DoWhile, If과 IfElse)이다 행할 실제로 실행하기 위해, 즉, Do함수가 호출되어야합니다 (대답의 마지막 줄 참조). 다시 말하지만, 동일한 루프를 반복해서 실행할 때 바이트를 절약하거나 루프 정의와 실행 사이에 임의의 코드를 실행할 수 있습니다.

마지막으로, 변수를 참조하는 세 가지 방법이 있으며,이 방법은 모두이 프로그램에서 사용됩니다. 첫 번째는 직접 참조 이며 여기서 변수 이름 앞에 $기호 가 붙습니다 . 변수의 값에 직접 액세스하여 반환합니다. 두 번째는 기능 참조 이며 접두사 문자가 없습니다. 이를 통해 코드는 변수에 할당 된 (잠재적으로 부분적인) 함수와 특정 값을 포함하는 실제 변수를 구별 할 수 있습니다. 마지막으로, 기호가 앞에 붙은 간접 참조@ 는 변수가 존재하지 않는 경우 변수를 만들고 지정된 범위 내에서 변수 개체를 반환합니다. 이를 통해 루프 변수를 만들 수 있습니다 (예 : iin for i in range(...)).

실제 솔루션 작동 방식

ungolfed 코드는 다음과 같습니다.

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

온라인으로 사용해보십시오!

보는 바와 같이, 상기 세 개의 변수를 할당함으로써 시작 n, e및 a각각 각각의 새로운 요소는 입력 시퀀스 내의 변화 요소 및 변형을 나타낼 수있는. 그런 다음 while 루프를 만듭니다.

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

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

다음으로 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]];

첫 번째 문장은 수정하기 전에 시퀀스의 각 반복을 인쇄합니다. 그런 다음 루프 변수와의 동등성을 검사 x하고 4 개의 if 문을 발견 하는 부분 함수를 만듭니다 . 각 문장의 경우는 검사 x되고, 각각 1, 2, 3 또는 4와 동일하고 양수인 k각 기능에 *, +, -및 /다음으로 부분적으로 기능하게, e인수로서. 마지막으로, 우리는 지정 e하는 k실행 a두 번째 인자 및 증가로 a.

루비 , 52 바이트

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

온라인으로 사용해보십시오!

C (클랑) , 80 바이트

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

온라인으로 사용해보십시오!

A golfed switch statement.   

많은 @ceilingcat 개선 덕분에.

dzaima / APL, 34 33 바이트

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

온라인으로 사용해보십시오!

ngn 덕분에 -1

TI83 / 84 기본, 69 바이트

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

A에 카운터를 설정하고 L1을 클리어하여 시퀀스를 추적하는 데 사용할 수 있습니다. 그런 다음 나누기 단계에서 분수가 발생할 때까지 반복합니다. 루프 내부에서 먼저 N을 목록에 저장합니다. 목록의 끝을지나 하나의 요소에 저장하거나 빈 목록을 저장하면 해당 요소가 만들어 지므로이 저장소는 분수를 발생시키지 않을 때 나눗셈 결과를 추가하고 첫 번째 통과 중에 목록을 초기화합니다. 그런 다음 기능 보강을 사용하여 순서의 다음 3 개의 항을 추가합니다. 수학은 변수 O에서 항 A4k + 3을 계산 한 다음 A4k + 2와 A4k + 4를 O에서 기본으로 계산하여 몇 바이트 더 작습니다. 그런 다음 반복 검사를 위해 N을 재설정하고 4를 A에 더하기 위해 나눗셈을 별도로 수행합니다.

마지막에 Disp L1을 넣었지만 화면의 모든 용어를 맞추는 좋은 방법이 없기 때문에 그것이 얼마나 이상적인지 잘 모르겠습니다. 실제로 사용자는 프로그램을 수동으로 실행 한 후 L1을 실행하여 결과를 스크롤합니다.

숯 , 29 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

초기 값을 입력하십시오.

Ｗ¬﹪θ¹«

값이 더 이상 정수가 될 때까지 반복하십시오.

Ｉθ⸿

자체 행에 값을 인쇄하십시오.

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

사용 가능한 4 개의 산술 연산을 계산하고 현재 출력 라인 번호에 따라 올바른 것을 선택하십시오.

파이썬 3 , 78 76 바이트

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

온라인으로 사용해보십시오!

입력을 1 개의 항목 목록으로 가져오고 정수가 아닌 순서가 될 때까지 다음 항목을 반복적으로 추가합니다.

입력을 목록으로 사용하는 것이 허용되지 않는 경우 입력을 int로 취하는 매우 빠르게 패치 된 버전이 있습니다.

정수 102 바이트로 입력

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

온라인으로 사용해보십시오!

재귀 함수의 이름을 잊어 버린 덕분에 +2 바이트 ...
Jitse 덕분에 -4 바이트

나뭇 가지 , 164 바이트

좋아, 이것은 실제로 쓰는 것이 끔찍한 일이었습니다.

한계 :

• 안돼 returns! 당신은 출력하거나 출력하지 않습니다
• while루프가 없습니다 . 당신은 해야한다 재귀 또는 아무것도를 사용
• 쉬운 출력 방법은 없습니다! 매번 출력을 반복해야합니다
• 변수를 사용하지 않으면 변수에 값을 줄 수 없습니다 set태그
• 루프에서 벗어날 수있는 쉬운 방법은 없습니다. 아무 없다 break, continue, goto또는 유사한. 이로 인해 루프를 사용할 수 없습니다.
• 하나의 loop : 만 for ... in ....있으며, 배열의 모든 요소를 ​​멈추지 않고 반복합니다.

모든 사람들이 코드를 방대하게 만들었습니다!
야, 나는 심지어 자바 답변보다 길게 만들었습니다! @Arnauld의 JavaScript 답변
만큼 깁니다 ! ... 3 가지 대안이 모두 결합되었습니다.

코드는 다음과 같습니다.

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

https://twigfiddle.com/zw5zls에서 시도해 볼 수 있습니다

사용하는 방법:

파일을 가져 와서 첫 번째 매크로를 호출하면됩니다.

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

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

사용 가능한 배열을 갖기 위해 할 수 있습니다 a.a(21)|split(',').

언 골프 드 :

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

읽기 쉬워야합니다.
이 ungolfed 답변은 임의의 공백을 던지므로 올바른 출력을 제공하지 않습니다.
단지 인간이 읽을 수 있어야합니다.