더하기-빼기 순서

플러스 - 마이너스 시퀀스는 한 두 개의 씨앗의 시작이다 a(0)하고 b(0). 이 시퀀스의 각 반복은 시퀀스의 이전 두 멤버의 덧셈과 뺄셈입니다. 즉, a(N) = a(N-1) + b(N-1)하고 b(N) = a(N-1) - b(N-1).

목표 플러스 또는 마이너스 시퀀스를 무한 또는 K주어진 첫 번째 단계로 생성합니다 K. 무한 출력 프로그램, 생성기 또는 첫 K단계 를 제공하는 기능 / 프로그램을 사용하여이 작업을 수행 할 수 있습니다 . 출력 순서는 일관성이있는 한 중요하지 않습니다. (즉, b(K) a(K)또는 a(K) b(K), 그 사이에 어떤 숫자가 아닌 비 개행 세퍼레이터.)의 출력은 입력으로 시작한다.

테스트 사례

입력의 경우 10 2(of의 a(0) b(0)경우 첫 번째 K 접근 방식 (또는 무한 접근 방식의 하위 섹션)에 가능한 출력입니다.

10     2
12     8
20     4
24     16
40     8
48     32
80     16
96     64
160    32
192    128
320    64
384    256
640    128
768    512
1280   256
1536   1024
2560   512
3072   2048
5120   1024
6144   4096
10240  2048
12288  8192
20480  4096
24576  16384
40960  8192
49152  32768
81920  16384
98304  65536

입력 2 20 10( a(0) b(0) k) :

2     20
22   -18
4     40
44   -36
8     80
88   -72
16    160
176  -144
32    320
352  -288

이것은 code-golf 이므로 바이트 단위의 가장 짧은 프로그램이 승리합니다.

젤리 , 5 바이트

ṄI;Sß

이것은 재귀 적 접근입니다. 테일 콜 최적화로 인해 유일한 한계는 두 정수를 메모리에 맞추는 기능입니다. 출력은 라인 당 하나의 목록입니다.

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

작동 원리

ṄI;Sß  Main link. Argument: [b[n], a[n]] (n = 0 for original input)

Ṅ      Print [b[n], a[n]] to STDOUT.
 I     Compute the increments of the list, i.e., [a[n] - [b[n]].
   S   Compute the sum of the list, i.e., b[n] + a[n].
  ;    Concatenate the results to the left and to the right.
    ß  Recursively call the main link.

파이썬 2, 31 바이트

def f(a,b):print a,b;f(a+b,a-b)

영원히 인쇄합니다. 글쎄, 결국 재귀 제한을 초과하지만 이는 시스템 제한입니다.

MATL , 10 바이트

`tDtswPdhT

이 버전은 더하기-빼기 순서로 무한한 수의 요소를 출력합니다.

온라인으로 사용해보십시오! (무한 루프로 인해 실행 후 중지)

설명

    % Implicitly grab input as a two-element array [a,b]
`   % do...while loop
tD  % Duplicate and display the top of the stack
ts  % Duplicate [a,b] and add them together
w   % Swap the top two elements on the stack
P   % Swap the order of b and a in preparation for diff
d   % Compute the difference between b and a
h   % Horizontally concatenate [a+b, a-b]
T   % Explicit TRUE to make it an infinite loop
    % Implicit end of the do...while loop

하스켈, 19 바이트

a#b=a:b:(a+b)#(a-b)

무한한 숫자 시퀀스를 생성합니다. 사용 예 :

Prelude> take 20 $ 2#20

[2,20,22,-18,4,40,44,-36,8,80,88,-72,16,160,176,-144,32,320,352,-288]

Pyth, 10 9 바이트

1 바이트 동안 @isaacg에게 감사드립니다.

#=Q,s
Q-F

무한대 쌍을 인쇄합니다.

$ pyth plusminus.p <<< "[10,2]" | head -n 15
[10, 2]
[12, 8]
[20, 4]
[24, 16]
[40, 8]
[48, 32]
[80, 16]
[96, 64]
[160, 32]
[192, 128]
[320, 64]
[384, 256]
[640, 128]
[768, 512]
[1280, 256]

C, 81 바이트

a,b;main(c){for(scanf("%d%d%d",&a,&b,&c);c--;a+=b,b=a-b-b)printf("%d %d\n",a,b);}

05AB1E , 7 바이트

first-k 방법을 사용합니다 . 다음에 입력하십시오 :

k
[a, b]

암호:

FD=OsƂ

설명:

F        # For N in range(0, k).
 D=      # Duplicate top of the stack and print without popping.
   O     # Sum up the array.
    sÆ   # Swap and perform a reduced subtraction.
      ‚  # Pair the top two elements. a, b --> [a, b]

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

k, 12

{(+;-).\:x}\

.

k){(+;-).\:x}\[10;10 2]
10  2
12  8
20  4
24  16
40  8
48  32
80  16
96  64
160 32
192 128
320 64

또한의 형태로 호출 할 수 있습니다

k)10{(+;-).\:x}\10 2

APL, 37 자

{⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z}

로 사용할 수 있습니다

    {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2
10 2
12 8
20 4
24 16
40 8
48 32
80 16
[...]

또는

      {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2 6
10 2
12 8
20 4
24 16
40 8
48 32

MathGolf , 8 바이트

ô`αp‼+-∟

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

입력을 역순으로 가져 오지만 이는 단순히 스택으로 푸시되는 방식이기 때문입니다. 그렇지 않으면 1 바이트 더 길어집니다. 2-3 바이트는 출력에서 ​​나옵니다. 실제로 한 줄에 한 쌍을 인쇄 할 필요없이 프로그램은 æ`‼+-∟(시퀀스 요소로 스택을 무기한으로 채 웁니다) 또는 É‼+-∟( -d플래그가 활성화 되어있는 한 디버그 할 첫 번째 요소를 제외한 모든 시퀀스 요소를 인쇄합니다 ) .

설명

ô      ∟   do-while-true
 `         duplicate the top two items
  αp       wrap last two elements in array and print
    ‼      apply next two operators to the top stack elements
     +     pop a, b : push(a+b)
      -    pop a, b : push(a-b)

Python 3.5, 55 43 바이트 :

def q(a,b):
 while 1:print(a,b);a,b=a+b,a-b

겉보기에는 영원히 올바른 순서를 인쇄합니다. 나는 오류가 발생하지 않고 약 30 분 동안이 작업을 계속 할 수 있었고 프로그램은 첫 번째 숫자의 경우 2301 자리, 두 번째의 경우 1150 자리를 인쇄했습니다! 이를 바탕으로 실행하기에 충분한 하드웨어가 제공되면 WAY가 더 길어지고 더 많은 자릿수를 인쇄 할 수 있으며 이론적으로 while루프 제한으로 인해 재귀 제한이 없습니다 !

Reng v.3.2, 9 바이트 (자체 응답, 비경쟁)

ii¤ææö±2.

두 개의 입력 ( a b)과 출력을 b a받습니다. 여기 사용해보십시오!

i입력을 두 번하고, ¤스택을 복제하고, æ숫자와 공백을 인쇄하고 (두 번, 두 개가 있음), ö줄 바꿈을 인쇄하고, ±예상되는 것을 수행하고 2., 다음 두 문자를 건너 뛰고 입력되는 문자를 감 쌉니다.

파이썬 2.7, 56 , 42 바이트 :

a,b=input()
while 1:print a,b;a,b=a+b,a-b

영원히 인쇄하는 간단한 루프 (ish).

배치, 54 바이트

@echo %1 %2
@set/aa=%1+%2
@set/ab=%1-%2
@%0 %a% %b%

CMD.EXE는 32 비트 부호있는 정수로 제한되므로 가비지 및 오류 메시지가 빠르게 오버플로되어 인쇄됩니다.

줄리아, 25 바이트

a<|b=[a b]|>show<a+b<|a-b

최대 구문 남용. 줄리아는 이상하다 . 온라인으로 사용해보십시오!

대체 버전, 29 바이트

출력이 결국 오버 플로우는 호출하지 않는 것을 참고 <|A의 에서 BigInt . 불행히도이 경우 show각 배열 앞에 접두사가 붙습니다 BigInt. 4 바이트 추가 비용으로 모든 숫자 유형에 대해 공백으로 구분 된 출력을 생성 할 수 있습니다.

a<|b="$a $b
"|>print<a+b<|a-b

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

작동 원리

이진 연산자 <|를 목적에 맞게 정의합니다 . 최근 버전의 Julia에서는 정의되지 않았지만 여전히 파서에서 연산자로 인식됩니다. 동안 \(명시 적으로 정수에 대해 정의되지 않음) 한 바이트 짧은, 높은 우선 순위는 교체 요구 a+b<|a-b로 (a+b)\(a-b)(3 바이트) 또는 \(a+b,a-b)(2 바이트).

a<|b실행 되면 [ab] 를 STDOUT show으로 인쇄하기 위해 호출 하여 시작합니다 . 그런 다음 합계 또는 차이를 재귀 적으로 호출 합니다.a+b<|a-b<|

재귀는 무한대이기 때문에 비교 <는 수행되지 않습니다. 유일한 목적은 코드의 두 부분을 연결하는 것입니다. 이것은보다 간단한 대안에 비해 2 바이트를 절약 ([a b]|>show;a+b<|a-b)합니다.

Perl 6 , 23 바이트 (무한)

편집 : JoKing 덕분에 시퀀스 버전이 가장 짧습니다 ( .sayOP에서 설명마다 제거 됩니다).

{@_,{.sum,[-] |$_}...*}

TIO : InfiniteSeq

이전 기능 답변

->\a,\b {(a,b).say;f(a+b,a -b)}

TIO : 무한함

Perl 6에는 자체 재귀 제한이 없으며 순전히 사용 가능한 메모리를 기반으로하므로 폭발하기 전에 수백만에 도달합니다.

팩터, 62 바이트

:: f ( a b -- x ) a b "%s %s" printf a b + a b - f ; recursive

recursive그렇지 않으면 콜 스택이 너무 빨리 소모됩니다.

루비, 25 바이트

xnor의 Python 솔루션을 기반으로 합니다 . 아마도 내가 다른 대답 발전기를 만들거야,하지만이 인쇄됩니다 a다음 b, 새로운 a, 새로운 b, 무한히.

f=->a,b{p a,b;f[a+b,a-b]}

파이썬 3, 42 바이트

이 함수에 대한 생성기를 작성하고 싶었습니다.

def f(a,b):
 while 1:yield a,b;a,b=a+b,a-b

Python 3에서 시퀀스는 다음과 같이 생성됩니다.

>>> gen = f(2, 20)
>>> next(gen)
(2, 20)
>>> next(gen)
(22, -18)
>>> next(gen)
(4, 40)
>>> next(gen)
(44, -36)
>>> next(gen)
(8, 80)

커먼 리스프, 57

(lambda(a b)(loop(print`(,a,b))(psetf a(+ a b)b(- a b))))

psetf변수에 병렬로 값에 영향을 미치는을 사용 하고 간단한 loop구문을 사용합니다.

bash + GNU coreutils, 75 바이트

a=$1
b=$2
for i in `seq $3`;{ echo -e "$a\t$b";c=$a;a=$((c+b));b=$((c-b));}

기도:

./codegolf.sh 2 10 5

CP / M 8080, 47 바이트

z80 니모닉이지만 8080에는없는 것이 있습니다. 소스는 입력보다는 출력을 계산하기로 결정했지만 간결한 함수 이름은 그대로 유지하고 손으로 조립했기 때문에 바이트 수를 알고 있지만 해결되지 않은 'xx'를 용서하십시오. 출력 주소 또는 오프셋 :

# setup
ld c, 2     0e 02

# loop
.s

# update H (temporarily in B)
ld a, h     7c
add l       85
daa         27
ld b, a     46

# update L
ld a, h     7c
sub l       95
daa         27
ld l, a     6f

# copy B back to H, output H
ld h, b     60
call +o     cd xx xx

# output L
ld b, l     45
call +o     cd xx xx

# repeat
jr -s       18 xx

# output a two-digit BCD value followed by a space
.o

# output high digit
ld a, b     78
rra         1f
rra         1f
rra         1f
rra         1f
call +ob    cd xx xx

# output low digit
ld a, b     78
call +ob    cd xx xx

# output a space
ld e, #$20  1e 20
call 5      cd 00 05

# return
ret         c9

# output a single BCD digit
.ob
and #$f     e6 0f
add #$30    c6 30
ld e, a     5f
call 5      cd 00 05
ret         c9

클로저, 44 바이트

#(iterate(fn[[a b]][(+ a b)(- a b)])[%1 %2])

무한 게으른 시퀀스를 생성하는 함수입니다.

펄 5, 40 바이트

필요 -E(무료)

sub a{say"@_";($c,$d)=@_;a($c+$d,$c-$d)}

또는 (같은 길이)

$_=<>;{say;/ /;$_=$`+$'.$".($`-$');redo}

(일부 반복에서는 반올림 오류가 있어야하기 때문에 후자를 쳤다.)

모자 끝.

그러나 더 짧은 Perl 5 솔루션이 있어야한다고 생각합니다.

RETURN , 21 바이트

[¤.' ,$.'
,¤¤+2ª-F]=F

Try it here.

재귀 연산자 람다. 용법:

[¤.' ,$.'
,¤¤+2ª-F]=F10 2F

설명

[                 ]=F  declare function F for recursion
 ¤.' ,$.'␊,            output top 2 stack items along with trailing newline
           ¤¤+2ª-      get plus and minus of top 2 stack items
                 F     recurse!

> <> , 26 바이트

:?!;1-r:n48*o:@@:nao:@+}-$

콜 a, b, n스택, 여기서 n권수 나 무한 출력 음의 값이다. 출력 a과 b공간에 의해 분리된다.

설명으로, 런타임 중에 스택이 어떻게 진화하는지는 다음과 같습니다.

abn
nba
nbaa
naab
naabb
nabab
nab+
+nab
+n-
+-n

온라인 인터프리터 에서 양의 턴 으로 시도해 볼 수 있지만 공식 파이썬 인터프리터를 사용하여 무한 모드를 테스트해야합니다.

$ python fish.py -c ':?!;1-r:n48*o:@@:nao:@+}-$' -t 0.01 -v 10 2 -1
10 2
12 8
20 4
24 16
40 8
48 32
80 16
96 64
160 32
192 128
320 64
384 256
640 128
768 512
1280 256
1536 1024
2560 512
3072 2048
5120 1024
6144 4096
10240 2048
12288 8192
20480 4096
24576 16384
40960 8192
49152 32768
81920 16384
98304 65536
163840 32768
196608 131072
327680 65536
393216 262144
655360 131072
786432 524288
1310720 262144
[...]

퍼지 옥토 과카 몰리 , 17 16 바이트

(비경쟁, 도전 이후의 기능 사용)

^^(:C.Zs.aZ.s.-)

클라이언트 쪽 오류로 인해 만들기가 어려웠습니다. 그러나 나는 그것을 얻었다!

연습 :

^^                # Get input twice, pushes it to the stack.
  (               # Start a infinite loop.
   :              # Prints the stack, and since it has [a,b] is just the output.
    C             # Copy the active stack to the inactive stack.
     .            # Shift the active stack.
      Z           # Reverse the stack.
       s          # Move the top item on the active stack to the top of the inactive.
        .         # Switch stacks again.
         a        # Add the top 2 items, giving the first new item.
          Z       # Reverse the stack, so we keep the 'a' safe and prepare for the 'b'.
           .      # Switch stacks.
            s     # Move the top item on the active stack to the top of the inactive stack.
             .    # Switch stacks.
              -   # Minus the top 2 items, giving 'b'.
               )  # End infinite loop.

정말 12 바이트

,,1WX■@│+)-1

무한 스트림을 출력합니다. format은 b(n) a(n)라인 당 한 쌍의 출력입니다.

TryItOnline은 무한 루프에서 제대로 작동하지 않기 때문에 온라인 링크가 없습니다.

설명:

,,1WX■@│+)-1
,,1           push a(0), push b(0), push 1
   W          while loop:
    X           discard the 1 (only used to make sure the while loop always runs)
     ■          print all stack elements, separated by spaces, without popping
      @│        swap, duplicate entire stack
        +)      push a(n) + b(n) (a(n+1)) and move it to the bottom of the stack
          -     push a(n) - b(n) (b(n+1))
           1    push 1 to make sure the loop continues

J, 16 12 바이트

0&(]+/,-/)~<

주어진 시드를 기반으로 시퀀스 의 첫 번째 k 값만 생성합니다.

이 의견 에서 @randomra가 보여주는 트릭 (또는 구문 설탕)을 사용하여 4 바이트를 절약했습니다 . .

용법

   f =: 0&(]+/,-/)~<
   2 20 f 10
  2   20
 22  _18
  4   40
 44  _36
  8   80
 88  _72
 16  160
176 _144
 32  320
352 _288

C #, 50 바이트

f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};

테스트 케이스를 포함한 전체 소스 :

using System;
using System.Numerics;

namespace PlusMinusSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<BigInteger,BigInteger>f=null;
            f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};
            BigInteger x=10, y=2;
            f(x,y);
        }
    }
}

BigInteger 데이터 유형이 사용되므로 숫자가 오버 플로우되지 않고 0이됩니다. 그러나 재귀 솔루션이므로 스택 오버 플로우가 예상됩니다.