La secuencia más-menos

La secuencia más-menos es una que comienza con dos semillas, a(0)y b(0). Cada iteración de esta secuencia es la suma y resta de los dos miembros anteriores de la secuencia. Es decir, a(N) = a(N-1) + b(N-1)y b(N) = a(N-1) - b(N-1).

Objetivo Producir la secuencia más-menos, en infinitud o los primeros Kpasos dados K. Puede hacer esto usando un programa de salida infinita, un generador o una función / programa que dé los primeros Kpasos. El orden de salida no importa, siempre que sea coherente. (Es decir, b(K) a(K)o a(K) b(K)con algún separador no numérico, no de nueva línea en el medio). La salida debe comenzar con la entrada.

Casos de prueba

Para entradas 10 2(de a(0) b(0), esta es una salida posible para el primer enfoque K (o una subsección del enfoque 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

Para entradas 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

Este es un código de golf , por lo que gana el programa más corto en bytes.

Jalea , 5 bytes

ṄI;Sß

Este es un enfoque recursivo. Debido a la optimización de la cola de llamadas, el único límite es la capacidad de encajar ambos enteros en la memoria. La salida es una lista por línea.

Pruébalo en línea!

Cómo funciona

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

Imprime para siempre. Bueno, eventualmente excedes el límite de recurrencia, pero eso es una limitación del sistema.

MATL , 10 bytes

`tDtswPdhT

Esta versión generará un número infinito de elementos en la secuencia más-menos.

Pruébalo en línea! (deténgalo después de ejecutarlo debido al bucle infinito)

Explicación

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

Produce una secuencia infinita de números. Ejemplo de uso:

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

Gracias a @isaacg por 1 byte.

#=Q,s
Q-F

Imprime una secuencia infinita de pares.

$ 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

Utiliza el método first-k . Ingrese lo siguiente para:

k
[a, b]

Código:

FD=OsƂ

Explicación:

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]

Utiliza la codificación CP-1252 . Pruébalo en línea!

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

También podría llamarse en forma de

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

APL, 37 caracteres

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

Puede ser utilizado como

    {⍺←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 bytes

ô`αp‼+-∟

Pruébalo en línea!

Toma la entrada en orden inverso, pero eso es simplemente porque así es como se empujan a la pila. De lo contrario, sería 1 byte más. 2-3 bytes provienen de la salida. Sin la necesidad de imprimir realmente un par por línea, el programa podría ser æ`‼+-∟(llena la pila con los elementos de la secuencia indefinidamente) o É‼+-∟(imprime todos los elementos de la secuencia excepto el primero para depurar, siempre que la -dbandera esté activa) .

Explicación

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

Imprime la secuencia correcta aparentemente para siempre. ¡He podido dejar que esto continúe durante unos 30 minutos sin que se produzca ningún error, y el programa imprimió 2301 dígitos para el primer número y 1150 dígitos para el segundo! Basado en esto, supongo que, si se le proporciona suficiente hardware para ejecutar, esto puede continuar por MUCHO más tiempo e imprimir MUCHO más dígitos, y también teóricamente no tiene límite de recursión, ¡cortesía del whileciclo!

Reng v.3.2, 9 bytes (auto-respuesta, no competitiva)

ii¤ææö±2.

Toma dos entradas ( a b) y salidas b a. Pruébalo aquí!

itoma la entrada dos veces, ¤duplica la pila, æimprime un número y un espacio (y lo hace dos veces, hay dos), öimprime una nueva línea, ±hace lo que podría esperar y 2.omite los siguientes dos caracteres, envolviendo la entrada obteniendo caracteres.

Python 2.7, 56 , 42 bytes:

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

Bucle simple que se imprime para siempre (ish).

Lote, 54 bytes

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

Tenga en cuenta que CMD.EXE está limitado a enteros con signo de 32 bits, por lo que se desbordará rápidamente e imprimirá mensajes basura y de error.

Julia, 25 bytes

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

Máximo abuso de sintaxis. Julia es rara . Pruébalo en línea!

Versión alternativa, 29 bytes.

Tenga en cuenta que la salida eventualmente se desbordará a menos que llame <|a un BigInt . Desafortunadamente, showprefijará cada matriz con BigInten este caso. A costa de cuatro bytes más, podemos generar resultados separados por espacios en blanco para todos los tipos numéricos.

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

Pruébalo en línea!

Cómo funciona

Definimos el operador binario <|para fines externos. No está definido en las versiones recientes de Julia, pero el analizador aún lo reconoce como operador. Si bien \(no está definido explícitamente para enteros) es un byte más corto, su alta prioridad requeriría reemplazarse a+b<|a-bcon (a+b)\(a-b)(+3 bytes) o \(a+b,a-b)(+2 bytes).

Cuando a<|bse ejecuta, comienza llamando showa print [ab] a STDOUT. Luego, a+b<|a-brecurrentemente recurre <|a la suma o la diferencia.

Como la recursividad es (se supone que es) infinita, la comparación <nunca se realiza; Su único propósito es encadenar las dos partes del código. Esto ahorra dos bytes sobre la alternativa más sencilla ([a b]|>show;a+b<|a-b).

Perl 6 , 23 bytes (infinito)

Editar: gracias a JoKing, la versión de secuencia ahora es la más corta (también eliminada .saypor aclaración de OP:

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

TIO: InfiniteSeq

Antigua respuesta funcional

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

TIO: InfiniteFunc

Tenga en cuenta que Perl 6 no tiene límite de recursión per se, se basa únicamente en la memoria disponible, por lo que alcanzará los millones antes de bombardear.

Factor, 62 bytes

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

recursive, o bien la pila de llamadas se agota demasiado rápido.

Rubí, 25 bytes

Basado en la solución Python de xnor . Quizás haga un generador en otra respuesta, pero esto imprimirá a, luego b, lo nuevo a, luego lo nuevo b, hasta el infinito.

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

Python 3, 42 bytes

Quería escribir un generador para esta función, y así lo hice.

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

En Python 3, la secuencia se genera de esta manera:

>>> 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 común, 57

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

Usos psetf, que afectan los valores de las variables en paralelo, y la loopsintaxis simple .

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

Invocación:

./codegolf.sh 2 10 5

CP / M 8080, 47 bytes

z80 mnemónicos pero nada que no tenga el 8080, comentó la fuente una vez que decidí contar la salida en lugar de la entrada, pero conservaron los nombres de funciones concisos, ensamblados a mano, así que perdone los 'xx' donde sé la cantidad de bytes pero no funcionó las direcciones de salida o compensaciones:

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

Función que produce una secuencia perezosa infinita.

Perl 5, 40 bytes

requiere -E(gratis)

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

o (misma longitud)

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

(He tachado este último porque debería tener errores de redondeo para algunas iteraciones).

Punta de sombrero.

Pero sospecho que debe haber una solución Perl 5 más corta.

RETORNO , 21 bytes

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

Try it here.

Operador recursivo-lambda. Uso:

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

Explicación

[                 ]=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:@+}-$

Llamada con a, b, nen la pila, donde nes el número de vueltas o un valor negativo para la salida infinito. Salidas ay bseparadas por un espacio.

Como explicación, así es como evoluciona la pila durante el tiempo de ejecución:

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

Puede probarlo en el intérprete en línea con una cantidad positiva de turnos, pero deberá usar el intérprete oficial de Python para probar el modo infinito.

$ 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

(no competidor, utiliza características posteriores al desafío)

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

Esto fue difícil de hacer, debido a errores del lado del cliente. Pero lo tengo!

Tutorial:

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

En serio, 12 bytes

,,1WX■@│+)-1

Emite un flujo infinito, el formato es b(n) a(n), un par de salidas por línea.

No hay enlace en línea porque TryItOnline no funciona muy bien con bucles infinitos.

Explicación:

,,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&(]+/,-/)~<

Produce solo los primeros k valores para la secuencia en función de las semillas dadas.

Guardado 4 bytes usando el truco (o azúcar sintáctico) que muestra @randomra en este comentario .

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 bytes

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

Fuente completa, incluido el caso de prueba:

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

El tipo de datos BigInteger se usa para que los números no se desborden y se conviertan en 0. Sin embargo, dado que es una solución recursiva, espere un desbordamiento de la pila.