Sekwencja plus-minus

Sekwencja plus-minus to taka, która zaczyna się od dwóch nasion a(0)i b(0). Każda iteracja tej sekwencji jest dodawaniem i odejmowaniem poprzednich dwóch elementów sekwencji. To znaczy a(N) = a(N-1) + b(N-1)i b(N) = a(N-1) - b(N-1).

Cel Wykonaj sekwencję plus-minus, w nieskończoności lub w podanych pierwszych Kkrokach K. Możesz to zrobić za pomocą nieskończonego programu wyjściowego, generatora lub funkcji / programu, który daje pierwsze Kkroki. Kolejność wyjściowa nie ma znaczenia, o ile jest spójna. (Tj. b(K) a(K)Lub a(K) b(K)z separatorem nieliczbowym, nie będącym znakiem nowej linii pomiędzy nimi.) Wyjście musi zaczynać się od wejścia.

Przypadki testowe

W przypadku danych wejściowych 10 2(z a(0) b(0)jest to możliwe wyjście dla pierwszego podejścia K (lub podsekcji podejścia nieskończonego):

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

Dla wejść 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

To jest golf golfowy , więc wygrywa najkrótszy program w bajtach.

Galaretka , 5 bajtów

ṄI;Sß

To jest podejście rekurencyjne. Ze względu na optymalizację wywołania ogonowego jedynym ograniczeniem jest możliwość dopasowania obu liczb całkowitych do pamięci. Dane wyjściowe to jedna lista w wierszu.

Wypróbuj online!

Jak to działa

Ṅ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.

Python 2, 31 bajtów

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

Drukuje na zawsze. Cóż, w końcu przekroczysz limit rekurencji, ale jest to ograniczenie systemowe.

MATL , 10 bajtów

`tDtswPdhT

Ta wersja wyświetli nieskończoną liczbę elementów w sekwencji plus-minus.

Wypróbuj online! (zatrzymaj go po uruchomieniu z powodu nieskończonej pętli)

Wyjaśnienie

    % 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

Haskell, 19 bajtów

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

Tworzy nieskończoną sekwencję liczb. Przykład użycia:

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

Dzięki @isaacg za 1 bajt.

#=Q,s
Q-F

Drukuje nieskończoną sekwencję par.

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

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

Używa metody first-k . Wprowadź następujące dane dla:

k
[a, b]

Kod:

FD=OsƂ

Wyjaśnienie:

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]

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

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

Można również nazwać w formie

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

APL, 37 znaków

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

Może być używany jako

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

lub

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

MathGolf , 8 bajtów

ô`αp‼+-∟

Wypróbuj online!

Pobiera dane wejściowe w odwrotnej kolejności, ale po prostu dlatego, że są one wypychane na stos. W przeciwnym razie byłby o 1 bajt dłuższy. 2-3 bajty pochodzą z wyjścia. Bez potrzeby drukowania jednej pary w wierszu program mógłby być æ`‼+-∟(wypełnia stos elementami sekwencji w nieskończoność) lub É‼+-∟(drukuje wszystkie elementy sekwencji oprócz pierwszej do debugowania, o ile -dflaga jest aktywna) .

Wyjaśnienie

ô      ∟   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 bajtów:

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

Drukuje prawidłową sekwencję pozornie na zawsze. Byłem w stanie pozwolić temu trwać przez około 30 minut bez zgłaszania żadnego błędu, a program wydrukował 2301 cyfr dla pierwszego numeru i 1150 cyfr dla drugiego! W oparciu o to, zgaduję, że przy zapewnieniu wystarczającego sprzętu do działania, może to trwać DŁUGO i wydrukować DOWOLNIE więcej cyfr, a także teoretycznie nie ma limitu rekurencji, dzięki whilepętli!

Reng v.3.2, 9 bajtów (samo-odpowiedź, niekonkurujący)

ii¤ææö±2.

Pobiera dwa wejścia ( a b) i wyjścia b a. Wypróbuj tutaj!

ipobiera dane wejściowe dwa razy, ¤duplikuje stos, ædrukuje liczbę i spację (i robi to dwa razy, są dwa), ödrukuje nowy wiersz, ±robi to, czego można się spodziewać, i 2.pomija kolejne dwa znaki, owijając się wokół danych wejściowych, uzyskując znaki.

Python 2.7, 56 , 42 bajtów:

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

Prosta pętla, która drukuje na zawsze (ish).

Partia, 54 bajty

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

Zauważ, że CMD.EXE jest ograniczony do 32-bitowych liczb całkowitych ze znakiem, więc szybko przepełni i wydrukuje śmieci i komunikaty o błędach.

Julia, 25 bajtów

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

Maksymalne nadużycie składni. Julia jest dziwna . Wypróbuj online!

Alternatywna wersja, 29 bajtów

Należy pamiętać, że wyjście będzie ostatecznie przepełnienia chyba zadzwonić <|na BigInt . Niestety w tym przypadku showpoprzedza każdą tablicę BigInt. Kosztem kolejnych czterech bajtów możemy wygenerować wyjście oddzielone spacjami dla wszystkich typów liczbowych.

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

Wypróbuj online!

Jak to działa

Definiujemy operatora binarnego <|dla naszych celów. Nie jest zdefiniowany w najnowszych wersjach Julii, ale nadal jest rozpoznawany przez parser jako operator. Chociaż \(nie zdefiniowany wyraźnie dla liczb całkowitych) jest o jeden bajt krótszy, jego wysoki priorytet wymagałby zastąpienia a+b<|a-bgo (a+b)\(a-b)(+3 bajtami) lub \(a+b,a-b)(+2 bajtami).

Kiedy a<|bjest wykonywany, zaczyna się od wywołania showdrukowania [ab] do STDOUT. Następnie a+b<|a-brekurencyjnie wywołuje <|sumę lub różnicę.

Ponieważ rekurencja jest (powinna być) nieskończona, porównanie <nigdy nie jest wykonywane; jego jedynym celem jest połączenie dwóch części kodu. To oszczędza dwa bajty w stosunku do prostszej alternatywy ([a b]|>show;a+b<|a-b).

Perl 6 , 23 bajtów (nieskończony)

Edycja: dzięki JoKing wersja sekwencji jest teraz najkrótsza (również usunięta .sayzgodnie z wyjaśnieniem z OP:

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

TIO: InfiniteSeq

Stara funkcjonalna odpowiedź

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

TIO: InfiniteFunc

Zauważ, że Perl 6 nie ma limitu rekurencji jako taki, opiera się wyłącznie na dostępnej pamięci, więc dotrze do milionów przed bombardowaniem.

Współczynnik, 62 bajty

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

recursive, inaczej wyczekiwanie skończy się zbyt szybko.

Rubin, 25 bajtów

Oparty na rozwiązaniu Python firmy xnor . Być może zrobię generator w innej odpowiedzi, ale to wydrukuje a, potem bnowe a, potem nowe b, ad infinitum.

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

Python 3, 42 bajty

Chciałem napisać generator dla tej funkcji i tak też zrobiłem.

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

W Pythonie 3 sekwencja jest generowana w następujący sposób:

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

Common Lisp, 57

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

Wykorzystuje psetf, co wpływa na wartości zmiennych równolegle, i prostą loopskładnię.

bash + GNU coreutils, 75 bajtów

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

Wezwanie:

./codegolf.sh 2 10 5

CP / M 8080, 47 bajtów

Z80 mnemoniki, ale nic, czego 8080 nie ma, źródło skomentowało, gdy zdecydowałem się policzyć dane wyjściowe, a nie dane wejściowe, ale nazwy funkcji zwięzłe zostały zachowane, ręcznie zmontowane, więc wybacz 'xx', w których znam liczbę bajtów, ale jeszcze się nie udało adresy wyjściowe lub przesunięcia:

# 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

Clojure, 44 bajty

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

Funkcja, która tworzy nieskończoną leniwą sekwencję.

Perl 5, 40 bajtów

wymaga -E(za darmo)

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

lub (ta sama długość)

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

(Przekreśliłem ten ostatni, ponieważ powinien on zawierać błędy zaokrąglania dla niektórych iteracji).

Czapka z daszkiem.

Ale podejrzewam, że musi istnieć krótsze rozwiązanie Perl 5.

ZWROT , 21 bajtów

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

Try it here.

Operator rekurencyjny-lambda. Stosowanie:

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

Wyjaśnienie

[                 ]=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 bajtów

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

Zadzwoń z a, b, nna stosie, gdzie njest liczba obrotów lub wartość ujemną na wyjściu nieskończonej. Wyjścia ai boddzielone spacją.

Jako wyjaśnienie, oto jak ewoluuje stos podczas działania:

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

Możesz go wypróbować na interprecie online z pozytywną liczbą obrotów, ale będziesz musiał użyć oficjalnego interpretera Pythona, aby przetestować tryb nieskończoności.

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

Rozmyte Octo Guacamole , 17 16 bajtów

(niekonkurencyjny, wykorzystuje funkcje później niż wyzwanie)

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

Było to trudne ze względu na błędy po stronie klienta. Ale mam to!

Przewodnik:

^^                # 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.

Poważnie, 12 bajtów

,,1WX■@│+)-1

Wysyła nieskończony strumień, format to b(n) a(n)jedna para wyjść na linię.

Brak linku online, ponieważ TryItOnline nie radzi sobie tak dobrze z nieskończonymi pętlami.

Wyjaśnienie:

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

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

Generuje tylko pierwsze wartości k dla sekwencji na podstawie podanych nasion.

Zaoszczędzono 4 bajty, używając sztuczki (lub cukru syntaktycznego) pokazanego przez @randomra w tym komentarzu .

Stosowanie

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

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

Pełne źródło, w tym przypadek testowy:

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

Używany jest typ danych BigInteger, więc liczby nie przepełniają się i stają się 0. Jednak ponieważ jest to rozwiązanie rekurencyjne, należy spodziewać się przepełnienia stosu.