Последовательность плюс-минус

Последовательность плюс-минус - та, которая начинается с двух семян, a(0)и b(0). Каждая итерация этой последовательности представляет собой сложение и вычитание двух предыдущих членов последовательности. То есть a(N) = a(N-1) + b(N-1)и b(N) = a(N-1) - b(N-1).

Цель Произведите последовательность плюс-минус, в бесконечности или первых Kшагах K. Вы можете сделать это с помощью бесконечной программы вывода, генератора или функции / программы, которая дает первые Kшаги. Порядок вывода не имеет значения, если он согласован. (Т. Е. b(K) a(K)Или a(K) b(K)с некоторым нечисловым разделителем без перевода строки между ними.) Вывод должен начинаться с ввода.

Контрольные примеры

Для входных данных 10 2(из a(0) b(0), это возможный выход для первого подхода K (или подраздела бесконечного подхода):

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

Для входов 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

Это код-гольф , поэтому выигрывает самая короткая программа в байтах.

Желе , 5 байт

ṄI;Sß

Это рекурсивный подход. Из-за оптимизации хвостовых вызовов единственным ограничением является возможность помещать оба целых числа в память. Выход - один список на строку.

Попробуйте онлайн!

Как это работает

Ṅ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 байт

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

Отпечатки навсегда. Ну, в конце концов вы превышаете предел рекурсии, но это системное ограничение.

MATL , 10 байт

`tDtswPdhT

Эта версия будет выводить бесконечное количество элементов в последовательности плюс-минус.

Попробуйте онлайн! (остановите его после запуска из-за бесконечного цикла)

объяснение

    % 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 байтов

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

Создает бесконечную последовательность чисел. Пример использования:

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 байтов

Спасибо @isaacg за 1 байт.

#=Q,s
Q-F

Печатает бесконечную последовательность пар.

$ 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 байт

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 байтов

Использует метод first-k . Введите следующее для:

k
[a, b]

Код:

FD=OsƂ

Объяснение:

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]

Использует кодировку CP-1252 . Попробуйте онлайн!

к, 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)10{(+;-).\:x}\10 2

APL, 37 символов

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

Может использоваться как

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

или

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

MathGolf , 8 байт

ô`αp‼+-∟

Попробуйте онлайн!

Принимает ввод в обратном порядке, но это просто потому, что именно так они помещаются в стек. В противном случае это было бы на 1 байт длиннее. 2-3 байта приходит с выхода. Без необходимости фактической печати по одной паре на строку программа может быть æ`‼+-∟(заполняет стек элементами последовательности бесконечно) или É‼+-∟(печатает все элементы последовательности, кроме первого для отладки, пока -dфлаг активен) ,

объяснение

ô      ∟   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 байт:

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

Распечатывает правильную последовательность, казалось бы, навсегда. Я был в состоянии позволить этому продолжаться в течение приблизительно 30 минут без каких-либо ошибок, и программа напечатала 2301 цифру для первого номера и 1150 цифр для второго! Исходя из этого, я предполагаю, что при наличии достаточного количества оборудования для работы это может продолжаться WAY дольше и печатать WAY больше цифр, а также теоретически не имеет предела рекурсии, любезно предоставлено whileциклом!

Reng v.3.2, 9 байт (самоотвечающий, не конкурирующий)

ii¤ææö±2.

Принимает два входа ( a b) и выходы b a. Попробуй это здесь!

iпринимает входные данные дважды, ¤дублирует стек, æпечатает число и пробел (и делает это дважды, если их два), öпечатает новую строку, ±делает то , что вы ожидаете, и 2.пропускает следующие два символа, оборачивая ввод, получая символы.

Python 2.7, 56 , 42 байта:

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

Простой цикл, который либо печатает навсегда (иш).

Пакетная, 54 байта

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

Обратите внимание, что CMD.EXE ограничен 32-разрядными знаковыми целыми числами, поэтому он быстро переполняется и печатает сообщения об ошибках и ошибках.

Юлия, 25 байт

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

Максимальное злоупотребление синтаксисом. Джулия странно . Попробуйте онлайн!

Альтернативная версия, 29 байт

Обратите внимание , что выход будет в конечном итоге переполнения , если вы звоните <|в BigInt . К сожалению, showпрефикс каждого массива BigIntв этом случае. За счет еще четырех байтов мы можем сгенерировать разделенный пробелами вывод для всех числовых типов.

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

Попробуйте онлайн!

Как это работает

Мы определяем бинарный оператор <|для наших целей. Он не определен в последних версиях Julia, но все еще распознается синтаксическим анализатором как оператор. Хотя \(не определено явно для целых чисел) на один байт короче, его высокий приоритет потребует замены a+b<|a-bна (a+b)\(a-b)(+3 байта) или \(a+b,a-b)(+2 байта).

Когда a<|bвыполняется, он начинается с вызова showпечати [ab] для STDOUT. Затем a+b<|a-bрекурсивно вызывает <|сумму или разницу.

Поскольку рекурсия (предполагается) бесконечна, сравнение <никогда не выполняется; единственная цель - объединение двух частей кода. Это экономит два байта по сравнению с более простой альтернативой ([a b]|>show;a+b<|a-b).

Perl 6 , 23 байта (бесконечно)

Изменить: благодаря JoKing, версия последовательности теперь самая короткая (также удалена .sayза разъяснение из OP:

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

TIO: InfiniteSeq

Старый функциональный ответ

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

TIO: InfiniteFunc

Обратите внимание, что Perl 6 не имеет предела рекурсии как такового, он основан исключительно на доступной памяти, поэтому он достигнет миллионов перед бомбардировкой.

Фактор, 62 байта

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

recursiveили же вызов стека заканчивается слишком быстро.

Рубин, 25 байт

Основано на решении xnor's Python . Возможно, я сделаю генератор в другом ответе, но это напечатает a, затем b, затем новый a, затем новый b, до бесконечности.

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

Python 3, 42 байта

Я хотел написать генератор для этой функции, и я так и сделал.

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

В Python 3 последовательность генерируется следующим образом:

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

Common Lisp, 57

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

Использование psetf, которое влияет на значения переменных параллельно, и простой loopсинтаксис.

bash + GNU coreutils, 75 байт

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

Призвание:

./codegolf.sh 2 10 5

CP / M 8080, 47 байтов

Мнемоника z80, но ничего, чего нет у 8080, прокомментировал источник, как только я решил посчитать вывод, а не ввод, но краткие имена функций сохранились, собранные вручную, так что простите хх, где я знаю количество байтов, но не сработало выходные адреса или смещения:

# 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 байта

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

Функция, которая производит бесконечную ленивую последовательность.

Perl 5, 40 байт

требует -E(бесплатно)

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

или (той же длины)

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

(Я выбрал последнее, потому что в некоторых итерациях должны быть ошибки округления.)

Шапка-наконечник.

Но я подозреваю, что должно быть более короткое решение Perl 5.

ВОЗВРАТ , 21 байт

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

Try it here.

Рекурсивный оператор-лямбда. Использование:

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

объяснение

[                 ]=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 байт

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

Вызов с a, b, nв стеке, где nэто число витков или значение отрицательного для бесконечной мощности. Выходы aи bразделены пробелом.

В качестве объяснения, вот как эволюционирует стек во время выполнения:

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

Вы можете попробовать его на онлайн-переводчике с положительным количеством поворотов, но вам нужно будет использовать официальный интерпретатор python для тестирования бесконечного режима.

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

Нечеткое окто гуакамоле , 17 16 байтов

(не конкурирует, использует функции позже, чем вызов)

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

Это было трудно сделать из-за ошибок на стороне клиента. Но я понял!

Прохождение:

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

Серьезно, 12 байт

,,1WX■@│+)-1

Выводит бесконечный поток, формат - b(n) a(n)одна пара выходов на строку.

Нет онлайн-ссылки, потому что TryItOnline не очень хорошо справляется с бесконечными циклами.

Объяснение:

,,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 байт

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

Производит только первые значения k для последовательности на основе заданных начальных чисел.

Сохранено 4 байта с использованием трюка (или синтаксического сахара), показанного @randomra в этом комментарии .

использование

   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 байтов

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

Полный исходный код, включая контрольный пример:

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

Тип данных BigInteger используется, чтобы числа не переполнялись и не становились равными 0. Однако, поскольку это рекурсивное решение, следует ожидать переполнения стека.