La sequenza più-meno

La sequenza più-meno è quella che inizia con due semi a(0)e b(0). Ogni iterazione di questa sequenza è l'aggiunta e la sottrazione dei due membri precedenti della sequenza. Cioè, a(N) = a(N-1) + b(N-1)e b(N) = a(N-1) - b(N-1).

Obiettivo Produce la sequenza più-meno, in infinito o i primi Kpassi indicati K. Puoi farlo usando un programma di output infinito, un generatore o una funzione / programma che fornisce i primi Kpassi. L'ordine di uscita non ha importanza, purché sia ​​coerente. (Vale a dire, b(K) a(K)o a(K) b(K), con qualche separatore non numerico, non newline tra.) L'output deve iniziare con l'input.

Casi test

Per gli input 10 2(di a(0) b(0), questo è un possibile output per il primo approccio K (o una sottosezione dell'approccio infinito):

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

Per input 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

Questo è un codice-golf , quindi vince il programma più breve in byte.

Gelatina , 5 byte

ṄI;Sß

Questo è un approccio ricorsivo. Grazie all'ottimizzazione delle chiamate di coda, l'unico limite è la capacità di adattare entrambi i numeri interi alla memoria. L'output è un elenco per riga.

Provalo online!

Come funziona

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

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

Stampa per sempre. Bene, alla fine superi il limite di ricorsione, ma questa è una limitazione del sistema.

MATL , 10 byte

`tDtswPdhT

Questa versione genererà un numero infinito di elementi nella sequenza più-meno.

Provalo online! (fermalo dopo l'esecuzione a causa di un ciclo infinito)

Spiegazione

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

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

Produce una sequenza infinita di numeri. Esempio di utilizzo:

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 byte

Grazie a @isaacg per 1 byte.

#=Q,s
Q-F

Stampa una sequenza infinita di coppie.

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

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 byte

Utilizza il metodo first-k . Immettere quanto segue per:

k
[a, b]

Codice:

FD=OsƂ

Spiegazione:

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]

Utilizza la codifica CP-1252 . Provalo 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

Potrebbe anche essere chiamato sotto forma di

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

APL, 37 caratteri

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

Può essere usato come

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

o

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

MathGolf , 8 byte

ô`αp‼+-∟

Provalo online!

Accetta l'input in ordine inverso, ma è semplicemente perché è così che vengono inseriti nello stack. Altrimenti sarebbe 1 byte più lungo. 2-3 byte provengono dall'output. Senza la necessità di stampare effettivamente una coppia per riga, il programma potrebbe essere æ`‼+-∟(riempie lo stack con gli elementi della sequenza indefinitamente), oppure É‼+-∟(stampa tutti gli elementi della sequenza tranne il primo da eseguire il debug, purché il -dflag sia attivo) .

Spiegazione

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

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

Stampa la sequenza corretta apparentemente per sempre. Sono stato in grado di lasciarlo andare avanti per circa 30 minuti senza che si siano generati errori e il programma ha stampato 2301 cifre per il primo numero e 1150 cifre per il secondo! Sulla base di questo, suppongo che, essendo fornito hardware sufficiente per funzionare, questo può continuare per MODO più lungo e stampare MODO più cifre, e teoricamente non ha limiti di ricorsione, per gentile concessione del whileloop!

Reng v.3.2, 9 byte (risposta automatica, non competitiva)

ii¤ææö±2.

Accetta due input ( a b) e output b a. Provalo qui!

iaccetta due volte l'input, ¤duplica la pila, æstampa un numero e uno spazio (e lo fa due volte, ce ne sono due), östampa una nuova riga, ±fa quello che ti aspetteresti e 2.salta i due caratteri successivi, avvolgendo l'input ottenendo caratteri.

Python 2.7, 56 , 42 byte:

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

Ciclo semplice che stampa per sempre (ish).

Lotto, 54 byte

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

Si noti che CMD.EXE è limitato a numeri interi con segno a 32 bit, pertanto trabocca rapidamente e stampa messaggi di immondizia e di errore.

Julia, 25 byte

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

Abuso massimo di sintassi. Julia è strana . Provalo online!

Versione alternativa, 29 byte

Si noti che l'output finirà per l'overflow a meno che non si chiami <|un BigInt . Sfortunatamente, showanteporrà ogni array con BigIntin questo caso. Al costo di altri quattro byte, possiamo generare output separati da spazi bianchi per tutti i tipi numerici.

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

Provalo online!

Come funziona

Definiamo l'operatore binario <|per i nostri scopi. Non è definito nelle ultime versioni di Julia, ma è ancora riconosciuto come operatore dal parser. Mentre \(non definito esplicitamente per numeri interi) è più corto di un byte, la sua precedenza elevata richiederebbe la sostituzione a+b<|a-bcon (a+b)\(a-b)(+3 byte) o \(a+b,a-b)(+2 byte).

Quando a<|bviene eseguito, inizia chiamando showper stampare [ab] su STDOUT. Quindi, a+b<|a-bricorsivamente chiama <|la somma o la differenza.

Poiché la ricorsione è (presumibilmente) infinita, il confronto <non viene mai eseguito; l'unico scopo è concatenare le due parti del codice. Ciò consente di risparmiare due byte rispetto all'alternativa più semplice ([a b]|>show;a+b<|a-b).

Perl 6 , 23 byte (infinito)

Modifica: grazie a JoKing, la versione della sequenza è ora la più breve (rimossa anche .sayper chiarimenti dall'OP:

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

TIO: InfiniteSeq

Vecchia risposta funzionale

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

TIO: InfiniteFunc

Nota che Perl 6 non ha limiti di ricorsione di per sé, è basato esclusivamente sulla memoria disponibile, quindi questo raggiungerà i milioni prima di bombardare.

Fattore, 62 byte

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

recursive, altrimenti il ​​callstack si esaurisce troppo rapidamente.

Rubino, 25 byte

Basato sulla soluzione Python di xnor . Forse creerò un generatore in un'altra risposta, ma questo stamperà a, quindi b, il nuovo a, quindi il nuovo b, all'infinito.

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

Python 3, 42 byte

Volevo scrivere un generatore per questa funzione, e così ho fatto.

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

In Python 3, la sequenza viene generata in questo modo:

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

Lisp comune, 57

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

Usi psetf, che influisce sui valori delle variabili in parallelo e sulla loopsintassi semplice .

bash + GNU coreutils, 75 byte

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

Invocazione:

./codegolf.sh 2 10 5

CP / M 8080, 47 byte

z80 mnemonica ma niente che l'8080 non abbia, commentato dalla fonte una volta ho deciso di contare l'output piuttosto che l'input ma i nomi delle funzioni terse mantenuti, assemblati a mano in modo da perdonare gli 'xx dove conosco il numero di byte ma non ho risolto gli indirizzi di output o offset:

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

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

Funzione che produce una sequenza pigra infinita.

Perl 5, 40 byte

richiede -E(gratuito)

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

o (stessa lunghezza)

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

(Ho superato quest'ultimo perché dovrebbe contenere errori di arrotondamento per alcune iterazioni.)

Hat-punta.

Ma sospetto che ci debba essere una soluzione Perl 5 più breve.

INVIO , 21 byte

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

Try it here.

Operatore ricorsivo-lambda. Uso:

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

Spiegazione

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

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

Chiamare con a, b, nin pila, in cui nè il numero di spire o un valore negativo per l'uscita infinito. Output ae bseparati da uno spazio.

Come spiegazione, ecco come si evolve lo stack durante il runtime:

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

Puoi provarlo sull'interprete online con un numero positivo di turni ma dovrai usare l'interprete ufficiale di Python per testare la modalità infinita.

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

(non concorrenziale, utilizza funzionalità successive alla sfida)

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

Questo è stato difficile da fare, a causa di errori sul lato client. Ma ho capito!

Procedura dettagliata:

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

Scherzi a parte, 12 byte

,,1WX■@│+)-1

Emette un flusso infinito, il formato è b(n) a(n), una coppia di output per riga.

Nessun collegamento online perché TryItOnline non funziona così bene con loop infiniti.

Spiegazione:

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

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

Produce solo i primi k valori per la sequenza in base ai semi dati.

Hai salvato 4 byte usando il trucco (o lo zucchero sintattico) mostrato da @randomra in questo commento .

uso

   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 byte

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

Fonte completa, compreso il caso di test:

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

Il tipo di dati BigInteger viene utilizzato in modo che i numeri non trabocchino e diventino 0. Tuttavia, poiché si tratta di una soluzione ricorsiva, si prevede un overflow dello stack.