A sequência mais-menos

A sequência mais-menos é aquela que começa com duas sementes a(0)e b(0). Cada iteração dessa sequência é a adição e subtração dos dois membros anteriores da sequência. Isto é, a(N) = a(N-1) + b(N-1)e b(N) = a(N-1) - b(N-1).

Objetivo Produza a sequência mais-menos, em infinitude ou nos primeiros Kpassos dados K. Você pode fazer isso usando um programa de saída infinita, um gerador ou uma função / programa que fornece os primeiros Kpassos. A ordem de saída não importa, desde que seja consistente. ( b(K) a(K)Ou seja, ou a(K) b(K)com algum separador não numérico e não nova linha no meio.) A saída deve começar com a entrada.

Casos de teste

Para entradas 10 2(de a(0) b(0), essa é uma saída possível para a primeira abordagem K (ou uma subseção da abordagem infinita):

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 é um código de golfe , portanto o programa mais curto em bytes vence.

Gelatina , 5 bytes

ṄI;Sß

Essa é uma abordagem recursiva. Devido à otimização da chamada de cauda, ​​o único limite é a capacidade de ajustar os dois números inteiros na memória. A saída é uma lista por linha.

Experimente online!

Como 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 sempre. Bem, eventualmente você excede o limite de recursão, mas isso é uma limitação do sistema.

MATL , 10 bytes

`tDtswPdhT

Esta versão produzirá um número infinito de elementos na sequência mais-menos.

Experimente Online! (pare depois de executar devido ao loop infinito)

Explicação

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

Produz uma sequência infinita de números. Exemplo 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]

Pitão, 10 9 bytes

Graças a @isaacg por 1 byte.

#=Q,s
Q-F

Imprime uma sequência 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

Usa o primeiro método -k . Insira o seguinte para:

k
[a, b]

Código:

FD=OsƂ

Explicação:

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]

Usa a codificação CP-1252 . Experimente 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

Também poderia ser chamado na forma de

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

APL, 37 caracteres

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

Pode ser usado como

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

ou

      {⍺←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‼+-∟

Experimente online!

Recebe entrada na ordem inversa, mas isso é simplesmente porque é assim que eles são colocados na pilha. Caso contrário, seria 1 byte a mais. 2-3 bytes vem da saída. Sem a necessidade de realmente imprimir um par por linha, o programa poderia ser æ`‼+-∟(preenche a pilha com os elementos da sequência indefinidamente) ou É‼+-∟(imprime todos os elementos da sequência, exceto o primeiro a depurar, desde que o -dsinalizador esteja ativo) .

Explicação

ô      ∟   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 a sequência correta aparentemente para sempre. Consegui deixar isso continuar por cerca de 30 minutos sem que nenhum erro fosse gerado, e o programa imprimiu 2301 dígitos para o primeiro número e 1150 dígitos para o segundo! Com base nisso, eu acho que, sendo fornecido hardware suficiente para rodar, isso pode durar MUITO MAIS e imprimir mais dígitos MUITO, além de teoricamente não ter limite de recursão, cortesia do whileloop!

Reng v.3.2, 9 bytes (resposta automática, não concorrente)

ii¤ææö±2.

Toma duas entradas ( a b) e saídas b a. Experimente aqui!

irecebe entrada duas vezes, ¤duplica a pilha, æimprime um número e um espaço (e o faz duas vezes, sendo dois), öimprime uma nova linha, ±faz o que você pode esperar e 2.pula os próximos dois caracteres, envolvendo a entrada obtendo caracteres.

Python 2.7, 56 , 42 bytes:

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

Loop simples que imprime para sempre (ish).

Lote, 54 bytes

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

Observe que o CMD.EXE é limitado a números inteiros assinados de 32 bits; portanto, ele excederá rapidamente e imprimirá mensagens de erro e lixo.

Julia, 25 bytes

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

Máximo abuso de sintaxe. Julia é estranha . Experimente online!

Versão alternativa, 29 bytes

Observe que a saída acabará excedendo, a menos que você chame <|um BigInt . Infelizmente, showprefixaremos cada array BigIntnesse caso. Ao custo de mais quatro bytes, podemos gerar saída separada por espaço em branco para todos os tipos numéricos.

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

Experimente online!

Como funciona

Definimos o operador binário <|para propósitos externos. Ele é indefinido nas versões recentes do Julia, mas ainda é reconhecido como operador pelo analisador. Embora \(não definido explicitamente para números inteiros) seja um byte mais curto, sua alta precedência exigiria a substituição a+b<|a-bpor (a+b)\(a-b)(+3 bytes) ou \(a+b,a-b)(+2 bytes).

Quando a<|bé executado, começa chamando showpara imprimir [ab] em STDOUT. Em seguida, a+b<|a-brecursivamente chama <|a soma ou a diferença.

Como a recursão é (supostamente) infinita, a comparação <nunca é realizada; seu único objetivo é encadear as duas partes do código. Isso economiza dois bytes sobre a alternativa mais direta ([a b]|>show;a+b<|a-b).

Perl 6 , 23 bytes (infinito)

Edit: graças ao JoKing, a versão da sequência agora é a mais curta (também removida .saypor esclarecimento do OP:

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

TIO: InfiniteSeq

Resposta funcional antiga

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

TIO: InfiniteFunc

Observe que o Perl 6 não tem limite de recursão per se, é puramente baseado na memória disponível, portanto, isso atingirá os milhões antes de bombardear.

Fator, 62 bytes

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

recursive, ou a pilha de chamadas acaba muito rapidamente.

Ruby, 25 bytes

Baseado na solução Python da xnor . Talvez eu faça um gerador em outra resposta, mas isso imprimirá a, então b, então o novo a, depois o novo b, ad infinitum.

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

Python 3, 42 bytes

Eu queria escrever um gerador para esta função, e foi o que fiz.

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

No Python 3, a sequência é gerada desta maneira:

>>> 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 comum, 57

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

Usa psetf, que afeta valores para variáveis ​​em paralelo, e a loopsintaxe simples .

bash + coreutils GNU, 75 bytes

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

Invocação:

./codegolf.sh 2 10 5

CP / M 8080, 47 bytes

mnemônicos do z80, mas nada que o 8080 não tenha, fonte comentou uma vez que eu decidi contar a saída em vez dos nomes de função de entrada mas concisos retidos, montados à mão para perdoar os 'xx's onde eu sei o número de bytes, mas não funcionou os endereços de saída ou compensações:

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

Função que produz uma sequência preguiçosa infinita.

Perl 5, 40 bytes

requer -E(grátis)

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

ou (mesmo comprimento)

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

(Procurei no último porque ele deve ter erros de arredondamento para algumas iterações.)

Gorro.

Mas suspeito que deve haver uma solução Perl 5 mais curta.

RETURN , 21 bytes

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

Try it here.

Operador-lambda recursivo. Uso:

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

Explicação

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

Chamada com a, b, nna pilha, onde né o número de voltas ou um valor negativo para a saída infinito. Saídas ae bseparadas por um espaço.

Como explicação, veja como a pilha evolui durante o tempo de execução:

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

Você pode experimentá-lo no intérprete on-line com uma quantidade positiva de turnos, mas precisará usar o intérprete python oficial para testar o 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

(não concorrente, usa recursos depois do desafio)

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

Isso foi difícil de executar devido a erros do lado do cliente. Mas entendi!

Passo a passo:

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

Sério, 12 bytes

,,1WX■@│+)-1

Emite um fluxo infinito, o formato é b(n) a(n)um par de saídas por linha.

Nenhum link on-line porque o TryItOnline não funciona tão bem com loops infinitos.

Explicação:

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

Produz apenas os primeiros valores de k para a sequência com base nas sementes especificadas.

Economizou 4 bytes usando o truque (ou açúcar sintático) mostrado por @randomra neste comentário .

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

Fonte completa, incluindo caso de teste:

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

O tipo de dados BigInteger é usado para que os números não excedam e se tornem 0. No entanto, como é uma solução recursiva, espere um estouro de pilha.