Die Plus-Minus-Reihenfolge

Die Plus-Minus-Sequenz beginnt mit zwei Startwerten a(0)und b(0). Jede Iteration dieser Sequenz ist die Addition und Subtraktion der beiden vorherigen Mitglieder der Sequenz. Das ist a(N) = a(N-1) + b(N-1)und b(N) = a(N-1) - b(N-1).

Zielsetzung Produzieren Sie die Plus-Minus-Sequenz in unendlich oder die ersten angegebenen KSchritte K. Sie können dies mit einem unendlichen Ausgabeprogramm, einem Generator oder einer Funktion / einem Programm tun, die / das die ersten KSchritte vorgibt. Die Ausgabereihenfolge spielt keine Rolle, solange sie konsistent ist. (Das heißt, b(K) a(K)oder a(K) b(K), mit einem nicht numerischen Trennzeichen, das keine Zeilenumbrüche enthält.) Die Ausgabe muss mit der Eingabe beginnen.

Testfälle

Für Eingaben 10 2(von a(0) b(0)ist dies eine mögliche Ausgabe für den ersten K-Ansatz (oder einen Unterabschnitt des unendlichen Ansatzes):

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

Für Eingänge 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

Dies ist ein Code-Golf , also gewinnt das kürzeste Programm in Bytes.

Gelee , 5 Bytes

ṄI;Sß

Dies ist ein rekursiver Ansatz. Aufgrund der Tail-Call-Optimierung besteht die einzige Einschränkung darin, dass beide Ganzzahlen in den Speicher passen. Ausgabe ist eine Liste pro Zeile.

Probieren Sie es online!

Wie es funktioniert

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

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

Druckt für immer. Nun, irgendwann überschreiten Sie das Rekursionslimit, aber das ist eine Systembeschränkung.

MATL , 10 Bytes

`tDtswPdhT

Diese Version gibt eine unendliche Anzahl von Elementen in der Plus-Minus-Sequenz aus.

Probieren Sie es online! (stoppen Sie es nach dem Laufen wegen Endlosschleife)

Erläuterung

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

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

Erzeugt eine unendliche Folge von Zahlen. Anwendungsbeispiel:

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 Bytes

Vielen Dank an @isaacg für 1 Byte.

#=Q,s
Q-F

Gibt eine unendliche Folge von Paaren aus.

$ 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 Bytes

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 Bytes

Verwendet die first-k- Methode. Geben Sie Folgendes ein für:

k
[a, b]

Code:

FD=OsƂ

Erläuterung:

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]

Verwendet die CP-1252- Codierung. Probieren Sie es 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

Könnte auch in Form von genannt werden

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

APL, 37 Zeichen

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

Kann als verwendet werden

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

oder

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

MathGolf , 8 Bytes

ô`αp‼+-∟

Probieren Sie es online!

Nimmt die Eingabe in umgekehrter Reihenfolge vor, aber das liegt einfach daran, dass sie auf den Stapel geschoben werden. Sonst wäre es 1 Byte länger. 2-3 Bytes kommen von der Ausgabe. Ohne dass tatsächlich ein Paar pro Zeile gedruckt werden muss, könnte das Programm æ`‼+-∟(füllt den Stapel auf unbestimmte Zeit mit den Elementen der Sequenz) oder É‼+-∟(druckt alle Elemente der Sequenz mit Ausnahme des ersten zu debuggenden Elements, solange das -dFlag aktiv ist) sein. .

Erläuterung

ô      ∟   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 Bytes:

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

Gibt scheinbar für immer die richtige Reihenfolge aus. Ich habe dies ungefähr 30 Minuten lang laufen lassen, ohne dass ein Fehler aufgetreten ist, und das Programm hatte 2301 Stellen für die erste und 1150 Stellen für die zweite Zahl ausgedruckt! Ausgehend davon, denke ich, kann dies viel länger dauern, wenn genügend Hardware zum Laufen bereitgestellt wird, und es werden viel mehr Ziffern ausgedruckt, und es gibt theoretisch auch keine Rekursionsbeschränkung, dank der whileSchleife!

Reng v.3.2, 9 Bytes (Selbstantwort, nicht konkurrierend)

ii¤ææö±2.

Nimmt zwei Ein- ( a b) und Ausgänge b a. Probieren Sie es hier aus!

iNimmt die Eingabe zweimal vor, ¤dupliziert den Stapel, gibt æeine Zahl und ein Leerzeichen aus (und zwar zweimal, wenn es zwei gibt), ödruckt eine neue Zeile, ±führt die erwarteten Schritte aus und 2.überspringt die nächsten beiden Zeichen, wobei die eingegebenen Zeichen umbrochen werden .

Python 2.7, 56 , 42 Bytes:

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

Einfache Schleife, die entweder für immer (ish) druckt.

Batch, 54 Bytes

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

Beachten Sie, dass CMD.EXE auf 32-Bit-Ganzzahlen mit Vorzeichen beschränkt ist, sodass es schnell überläuft und Müll- und Fehlermeldungen ausgibt.

Julia, 25 Bytes

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

Maximaler Syntaxmissbrauch. Julia ist komisch . Probieren Sie es online!

Alternative Version, 29 Byte

Beachten Sie, dass die Ausgabe möglicherweise überläuft, es sei denn, Sie rufen auf <| ein BigInt auf . Leider showwird BigIntin diesem Fall jedem Array ein Präfix vorangestellt . Auf Kosten von vier weiteren Bytes können wir eine durch Leerzeichen getrennte Ausgabe für alle numerischen Typen generieren.

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

Probieren Sie es online!

Wie es funktioniert

Wir definieren den binären Operator <| für Out-Zwecke. Es ist in neueren Versionen von Julia nicht definiert, wird jedoch vom Parser weiterhin als Operator erkannt. Während \(nicht explizit für Ganzzahlen definiert) ein Byte kürzer ist, müsste es a+b<|a-bbei hoher Priorität durch (a+b)\(a-b)(+3 Byte) oder \(a+b,a-b)(+2 Byte) ersetzt werden.

Wann a<|b es ausgeführt wird, ruft es showauf, um [ab] an STDOUT zu drucken. Ruft dann a+b<|a-brekursiv <|die Summe oder die Differenz auf.

Da die Rekursion unendlich ist (sein soll), wird der Vergleich <niemals durchgeführt; Der einzige Zweck ist die Verkettung der beiden Teile des Codes. Dies spart zwei Bytes gegenüber der einfacheren Alternative([a b]|>show;a+b<|a-b) .

Perl 6 , 23 Bytes (unendlich)

Edit: dank JoKing ist die Sequenzversion jetzt die kürzeste (auch .sayper Klarstellung aus OP entfernt:

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

TIO: InfiniteSeq

Alte funktionale Antwort

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

TIO: InfiniteFunc

Beachten Sie, dass Perl 6 an sich kein Rekursionslimit hat. Es basiert ausschließlich auf dem verfügbaren Speicher, sodass dieser die Millionen erreicht, bevor er bombardiert wird.

Faktor 62 Bytes

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

recursiveSonst geht der Callstack zu schnell aus.

Ruby, 25 Bytes

Basierend auf der Python-Lösung von xnor . Vielleicht werde ich einen Generator in einer anderen Antwort, aber dies wird gedruckt a, dann b, dann wird die neue a, dann wird die neue b, ad infinitum.

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

Python 3, 42 Bytes

Ich wollte einen Generator für diese Funktion schreiben, und das tat ich auch.

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

In Python 3 wird die Sequenz folgendermaßen generiert:

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

Gemeiner Lisp, 57

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

Verwendet psetf, was Werte zu Variablen parallel beeinflusst, und die einfache loopSyntax.

Bash + GNU Coreutils, 75 Bytes

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

Aufruf:

./codegolf.sh 2 10 5

CP / M 8080, 47 Bytes

z80-Mnemonik, aber nichts, was der 8080 nicht hat, kommentierte die Quelle, als ich mich entschied, die Ausgabe statt der Eingabe zu zählen, aber knappe Funktionsnamen beizubehalten die Ausgangsadressen oder Offsets:

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

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

Funktion, die eine unendliche Lazy-Sequenz erzeugt.

Perl 5, 40 Bytes

benötigt -E(kostenlos)

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

oder (gleiche Länge)

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

(Letzteres habe ich durchgestrichen, da es bei einigen Iterationen Rundungsfehler geben sollte.)

Hutspitze.

Ich vermute aber, dass es eine kürzere Perl 5-Lösung geben muss.

RETURN , 21 Bytes

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

Try it here.

Rekursives Operator-Lambda. Verwendung:

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

Erläuterung

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

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

Rufen mit a, b, nauf dem Stapel, wobei ndie Anzahl der Windungen oder ein negativer Wert für unendlichen Ausgang. Ausgängea und bdurch ein Leerzeichen getrennt.

Im Folgenden wird erklärt, wie sich der Stack zur Laufzeit entwickelt:

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

Sie können es mit dem Online-Interpreter mit einer positiven Anzahl von Umdrehungen versuchen, aber Sie müssen den offiziellen Python-Interpreter verwenden, um den unendlichen Modus zu testen.

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

Fuzzy Octo Guacamole , 17 16 Bytes

(Nicht konkurrierend, verwendet Funktionen später als die Herausforderung)

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

Dies war aufgrund clientseitiger Fehler schwer zu bewerkstelligen. Aber ich habe es verstanden!

Exemplarische Vorgehensweise:

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

Im Ernst, 12 Bytes

,,1WX■@│+)-1

Gibt einen unendlichen Stream aus, das Format ist b(n) a(n)ein Ausgangspaar pro Zeile.

Kein Online-Link, da TryItOnline mit Endlosschleifen nicht so gut funktioniert.

Erläuterung:

,,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 Bytes

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

Erzeugt nur die ersten k- Werte für die Sequenz basierend auf den angegebenen Startwerten.

Mit dem von @randomra gezeigten Trick (oder syntaktischen Zucker) wurden 4 Bytes gespeichert Kommentar .

Verwendung

   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 Bytes

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

Vollständige Quelle, einschließlich Testfall:

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

Der BigInteger-Datentyp wird verwendet, damit die Zahlen nicht überlaufen und zu 0 werden. Da es sich jedoch um eine rekursive Lösung handelt, müssen Sie mit einem Stapelüberlauf rechnen.