La séquence plus-moins

La séquence plus-moins est celle qui commence par deux graines, a(0)et b(0). Chaque itération de cette séquence est l'addition et la soustraction des deux membres précédents de la séquence. C'est, a(N) = a(N-1) + b(N-1)et b(N) = a(N-1) - b(N-1).

Objectif Produire la séquence plus-moins, à l'infini ou aux premières Kétapes données K. Vous pouvez le faire en utilisant un programme de sortie infini, un générateur ou une fonction / programme qui donne les premières Kétapes. L'ordre de sortie n'a pas d'importance, tant qu'il est cohérent. (C'est-à-dire, b(K) a(K)ou a(K) b(K), avec un séparateur non numérique, non-nouvelle ligne entre les deux.) La sortie doit commencer par l'entrée.

Cas de test

Pour les entrées 10 2(de a(0) b(0), c'est une sortie possible pour la première approche K (ou une sous-section de l'approche infinie):

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

Pour les entrées 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

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

Gelée , 5 octets

ṄI;Sß

Il s'agit d'une approche récursive. En raison de l'optimisation des appels de queue, la seule limite est la possibilité d'ajuster les deux entiers en mémoire. La sortie est une liste par ligne.

Essayez-le en ligne!

Comment ça marche

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

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

Imprime pour toujours. Eh bien, vous finissez par dépasser la limite de récursivité, mais c'est une limitation du système.

MATL , 10 octets

`tDtswPdhT

Cette version affichera un nombre infini d'éléments dans la séquence plus-moins.

Essayez-le en ligne! (arrêtez-le après avoir exécuté en raison de la boucle infinie)

Explication

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

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

Produit une séquence infinie de nombres. Exemple d'utilisation:

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 octets

Merci à @isaacg pour 1 octet.

#=Q,s
Q-F

Imprime une séquence infinie de paires.

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

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 octets

Utilise la méthode first-k . Saisissez les informations suivantes pour:

k
[a, b]

Code:

FD=OsƂ

Explication:

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]

Utilise l' encodage CP-1252 . Essayez-le en ligne!

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

Pourrait également être appelé sous la forme de

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

APL, 37 caractères

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

Peut être utilisé comme

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

ô`αp‼+-∟

Essayez-le en ligne!

Prend l'entrée dans l'ordre inverse, mais c'est simplement parce que c'est comme ça qu'ils sont poussés sur la pile. Sinon, ce serait 1 octet de plus. 2-3 octets proviennent de la sortie. Sans avoir besoin d'imprimer réellement une paire par ligne, le programme pourrait être æ`‼+-∟(remplit la pile avec les éléments de la séquence indéfiniment), ou É‼+-∟(imprime tous les éléments de la séquence à l'exception du premier à déboguer, tant que le -ddrapeau est actif) .

Explication

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

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

Imprime la séquence correcte pour toujours. J'ai pu laisser cela se poursuivre pendant environ 30 minutes sans aucune erreur, et le programme avait imprimé 2301 chiffres pour le premier numéro, et 1150 chiffres pour le second! Sur cette base, je suppose que, étant donné le matériel suffisant pour fonctionner, cela peut continuer WAY plus longtemps et imprimer WAY plus de chiffres, et n'a également théoriquement aucune limite de récursivité, grâce à la whileboucle!

Reng v.3.2, 9 octets (auto-réponse, non concurrent)

ii¤ææö±2.

Prend deux entrées ( a b) et sorties b a. Essayez-le ici!

iprend l'entrée deux fois, ¤duplique la pile, æimprime un nombre et un espace (et le fait deux fois, il y en a deux), öimprime une nouvelle ligne, ±fait ce que vous attendez et 2.saute les deux caractères suivants, encapsulant l'entrée en obtenant les caractères.

Python 2.7, 56 , 42 octets:

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

Boucle simple qui imprime pour toujours (ish).

Lot, 54 octets

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

Notez que CMD.EXE est limité aux entiers signés 32 bits, donc il débordera rapidement et imprimera les messages inutiles et d'erreur.

Julia, 25 octets

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

Abus de syntaxe maximum. Julia est bizarre . Essayez-le en ligne!

Version alternative, 29 octets

Notez que la sortie finira par déborder, sauf si vous appelez <|un BigInt . Malheureusement, showpréfixe chaque tableau BigIntdans ce cas. Au prix de quatre octets supplémentaires, nous pouvons générer une sortie séparée par des espaces pour tous les types numériques.

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

Essayez-le en ligne!

Comment ça marche

Nous définissons l'opérateur binaire <|à des fins de sortie. Il n'est pas défini dans les versions récentes de Julia, mais est toujours reconnu comme opérateur par l'analyseur. Bien que \(non explicitement défini pour les entiers) soit un octet plus court, sa priorité élevée nécessiterait le remplacement a+b<|a-bpar (a+b)\(a-b)(+3 octets) ou \(a+b,a-b)(+2 octets).

Une fois a<|bexécuté, il commence par appeler showpour imprimer [ab] sur STDOUT. Puis, a+b<|a-brécursivement appelle <|la somme ou la différence.

Puisque la récursivité est (supposée être) infinie, la comparaison <n'est jamais effectuée; son seul but est de chaîner les deux parties du code. Cela économise deux octets sur l'alternative la plus simple ([a b]|>show;a+b<|a-b).

Perl 6 , 23 octets (infini)

Edit: grâce à JoKing, la version de séquence est désormais la plus courte (également supprimée .saypar clarification d'OP:

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

TIO: InfiniteSeq

Ancienne réponse fonctionnelle

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

TIO: InfiniteFunc

Notez que Perl 6 n'a pas de limite de récursivité en soi, il est purement basé sur la mémoire disponible, donc cela atteindra les millions avant le bombardement.

Facteur, 62 octets

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

recursive, sinon la pile d'appels s'épuise trop rapidement.

Rubis, 25 octets

Basé sur la solution Python de xnor . Je ferai peut-être un générateur dans une autre réponse, mais cela imprimera a, puis b, le nouveau a, puis le nouveau b, à l'infini.

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

Python 3, 42 octets

Je voulais écrire un générateur pour cette fonction, et c'est ce que j'ai fait.

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

En Python 3, la séquence est générée de cette façon:

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

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

Utilise psetf, qui affecte les valeurs des variables en parallèle, et la loopsyntaxe simple .

bash + GNU coreutils, 75 octets

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

Invocation:

./codegolf.sh 2 10 5

CP / M 8080, 47 octets

mnémoniques z80 mais rien que le 8080 n'a pas, a commenté la source une fois que j'ai décidé de compter la sortie plutôt que l'entrée mais les noms de fonction concis conservés, assemblés à la main alors pardonnez les 'xx's où je connais le nombre d'octets mais je n'ai pas travaillé les adresses ou décalages de sortie:

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

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

Fonction qui produit une séquence paresseuse infinie.

Perl 5, 40 octets

nécessite -E(gratuit)

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

ou (même longueur)

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

(J'ai barré cette dernière car elle devrait contenir des erreurs d'arrondi pour certaines itérations.)

Pointe de chapeau.

Mais je pense qu'il doit y avoir une solution Perl 5 plus courte.

RETOUR , 21 octets

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

Try it here.

Opérateur lambda récursif. Usage:

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

Explication

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

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

Appel avec a, b, nsur la pile, où nest le nombre de tours ou une valeur négative pour la sortie infinie. Sorties aet bséparées par un espace.

À titre d'explication, voici comment la pile évolue pendant l'exécution:

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

Vous pouvez l'essayer sur l'interpréteur en ligne avec un nombre de tours positif mais vous devrez utiliser l'interpréteur python officiel pour tester le mode infini.

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

Octo Guacamole flou , 17 16 octets

(non concurrentiel, utilise des fonctionnalités plus tard que le défi)

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

Cela a été difficile à faire, en raison d'erreurs côté client. Mais je l'ai compris!

Procédure pas à pas:

^^                # 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érieusement, 12 octets

,,1WX■@│+)-1

Produit un flux infini, le format est b(n) a(n)une paire de sorties par ligne.

Pas de lien en ligne car TryItOnline ne fonctionne pas très bien avec des boucles infinies.

Explication:

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

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

Produit uniquement les k premières valeurs de la séquence en fonction des graines données.

Enregistré 4 octets en utilisant l'astuce (ou sucre syntaxique) montré par @randomra dans ce commentaire .

Usage

   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 octets

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

Source complète, y compris le cas de 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);
        }
    }
}

Le type de données BigInteger est utilisé pour que les nombres ne débordent pas et deviennent 0. Cependant, comme il s'agit d'une solution récursive, attendez-vous à un débordement de pile.