Скористаємось чотирма основними операціями, додаванням +, множенням *, відніманням -та діленням /(плаваючий, не цілий).

Послідовність Стюі визначається наступним чином:

x = [x(1), x(2)]    // Two initial numbers (one indexed)
x(3) = x(1) + x(2)
x(4) = x(2) * x(3)
x(5) = x(3) - x(4)
x(6) = x(4) / x(5)
x(7) = x(5) + x(6)
... and so on.

Виклик:

Візьміть два невід’ємні цілі числа ( x(1), x(2)) та одне додатне ціле число Nяк вхідні дані.

x(1)і x(2)буде двома першими числами вашої послідовності, і Nбуде довжиною послідовності, яку ви повинні вивести. (Ви можете вибрати список на основі 0, в цьому випадку Nбуде на один менший за довжину).

• Ви не можете цього припустити x(2) >= x(1).
• Nзавжди буде, >2якщо на основі 1, ( >1якщо на основі 0).
• Вам не доведеться обробляти поділ за нульовими помилками.
  • Зверніть увагу на 2-й тестовий випадок. Ви не отримаєте 0, 1і N=6як вхід, оскільки це призведе до ділення на нуль, але ви повинні підтримати 0, 1і N=5.
• Припустимо, буде надано лише дійсне введення.
• Введення та вихід можуть бути у будь-якому зручному форматі, але ви повинні підтримувати принаймні 3 цифри після десяткових знаків, якщо вихід не є цілим.

Тестові приклади:

1 3
8
1, 3, 4, 12, -8, -1.5, -9.5, 14.25

0 1
5
0, 1, 1, 1, 0     // N=6 would give division by zero error. You don't need to handle that case.

1 0
9
1, 0, 1, 0, 1, 0, 1, 0, 1

6 3
25
6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96, -0.375, -79.335, 29.7506, -109.086, -0.272727, -109.358, 29.825, -139.183, -0.214286, -139.398, 29.8709, -169.269

MATL , 19 18 17 байт

q:"y'+*-/'@)hyhUV

Вхідні дані в форматі: N( від 0), x(1), x(2)(як рядки); всі розділені новими рядками.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки (злегка модифікований код; послідовності виведення, розділені порожнім рядком).

Пояснення

MATL не має належної evalфункції, але U( str2num) може оцінювати числові вирази за допомогою операторів infix.

Кожен новий термін обчислюється та висувається на стек, зберігаючи попередні умови. Весь стек друкується в кінці.

q          % Implicitly input N (0-based). Subtract 1
:"         % Repeat that many times
  y        %   Duplicate x(n-1), where n is the number of already computed terms
           %   In the first iteration, which corresponds to n=2, this implicitly 
           %   inputs x(1) and x(2) as strings (and then duplicates x(1))
  '+*-/'   %   Push this string
  @)       %   Push iteration number and apply as modular index into the string. 
           %   So this gives '+' in the first iteration, '*' in the second etc
  h        %   Concatenate horizontally. This gives a string of the form
           %   '*x(n-1)+', where '+' is the appropriate operator 
  &y       %   Duplicate x(n)
  hh       %   Concatenate horizontally. This gives a string of the form
           %   'x(n-1)+x(n)'
  U        %   Convert to number. This evaluates the string
  V        %   Convert back to string. This is the new term, x(n+1)
           % Implicitly end loop and display stack

Haskell, 69 68 64 байт

x#n=take n$x++zipWith3 id(cycle[(+),(*),(-),(/)])(x#n)(tail$x#n)

x1і x2приймаються як список. Приклад використання: [1,3] # 8-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Лінь дає можливість визначити нескінченний рекурсивний список, де ми беремо перші n елементів.

Haskell, 66 байт

(h%g)y x=x:g(h x y)y
a=(+)%b
b=(*)%c
c=(-)%d
d=(/)%a
(.a).(.).take 

Інший підхід, трохи довше. Порядок Аргумент N, x2, x1. Приклад використання: ( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25].

Визначає 4 функції a, b, cі dякі приймають два аргументи y, x і зробити список, поставивши xперед викликом наступної функції з в yякості другого аргументу , і x op yяк перший. Наприклад aце: a y x = x : (b (x+y) y), bробить множення: b y x = x : (c (x*y) y)і т.д.

Редагувати: @Michael Klein зберегла байт у 1-му варіанті ( #). На щастя, я також знайшов один байт для другого варіанту, тому обидва знову мають однакову довжину.

Редагування II: @ Zgarb знайшов 2 байти у другій версії, щоб зберегти, а я 4 у першій, тому вони вже не однакової довжини.

ES6 (Javascript), 79, 67, 65 байт

ОНОВЛЕННЯ

• мінус 2 байти, починаючи з i = 2, як це запропоновано @ETHProductions
• Збережено 3 байти, завдяки чудовій раді від @Neil!

Гольф

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

Тест

S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"-/+*"[i%4]+a[i-1]))):a

>S(8,[1,3])
Array [ 1, 3, 4, 12, -8, -1.5, -9.5, 14.25 ]

>S(5,[0,1])
Array [ 0, 1, 1, 1, 0 ]

>S(9,[1,0])
Array [ 1, 0, 1, 0, 1, 0, 1, 0, 1 ]

>S(25,[6,3])
Array [ 6, 3, 9, 27, -18, -1.5, -19.5, 29.25, -48.75, -0.6, ...]

Python 3, 90 80 74 байт

xnor, ймовірно, прийде і знищить це рішення ...

def F(s,n,i=2):
 while i<n:s+=eval('%s'*3%(s[-2],'-/+*'[i%4],s[-1])),;i+=1

Функція змінює список, переданий їй. Використовуйте так:

s = [1,3] 
F(s,8)

Спробуйте на repl.it!

-6 байт завдяки міді

Perl 6 ,  75 71  61 байт

->\a,\b,\c{$_=[|(&[+],&[*],&[-],&[/])xx*];(a,b,{.shift.($^a,$^b)}...*)[^c]}

Перевірте це

{$_=[|(&[+],&[*],&[-],&[/])xx*];($^a,$^b,{.shift.($^a,$^b)}...*)[^$^c]}

Перевірте це

{($^a,$^b,{(&[+],&[*],&[-],&[/])[$++%4]($^a,$^b)}...*)[^$^c]}

Перевірте це

Розширено:

{ # bare block lambda with placeholder parameters ｢$a｣ ｢$b｣ ｢$c｣

  # generate sequence
  (
    # initialize sequence
    $^a, # declare and use first argument
    $^b, # second argument

    {  # bare block lambda with two placeholder parameters ｢$a｣ ｢$b｣

      (

        &[+], &[*], &[-], &[/] # the four operators

      )[             # index into the list of operators

         $++        # increment (++) an anonymous state variable ($)
         % 4        # modulo 4

      ]( $^a, $^b ) # and use it on the previous two values in sequence

    }

    ...  # repeat that until

    *    # indefinitely

  )[     # take only

    ^    # upto and excluding:     ( Range object )
    $^c  # third argument

  ]
}

Математика, 68 байт

(±1=#;±2=#2;±n_:=1##[#-#2,#/#2,+##][[n~Mod~4]]&[±(n-2),±(n-1)];±#3)&

Ледве притулившись до 3-го місця! Безіменна функція з трьох аргументів, в якій використовується допоміжний одинарний оператор, ±такий, що ±nє саме n-м елементом x (n) послідовності Stewie. Перші два аргументи - це х (1) і х (2), а третій аргумент - N, який вказує, який х (N) виводимо.

Пряма реалізація, використовуючи обчислення mod-4, щоб вибрати, яку бінарну функцію застосувати до попередніх двох термінів. Вибір правильної бінарної функції, в чому саме це 1##[#-#2,#/#2,+##]допомагає, використовує декілька цих прикольних прийомів з гольфу в Mathematica .

05AB1E , 21 19 18 байт

Введення приймається у порядку N (на основі 0), x (2) , x (1) .
Збережено 1 байт завдяки carusocomputing .

GUDXsX"/+*-"Nè.V})

Спробуйте в Інтернеті!

Пояснення

 G                   # for N in [0 ... n-1] do:
  U                  # save top element of stack in X
   D                 # duplicate top of stack
    X                # push X
     s               # swap top 2 elements on stack
      X              # push X
       "/+*-"Nè      # index into the string with the current iteration number
               .V    # evaluate
                 }   # end loop
                  )  # wrap stack in list

Ми ітеративно будуємо стек з останнім елементом у послідовності зверху, зберігаючи всі попередні елементи в порядку.
Потім ми загортаємо стек у список в кінці, щоб відобразити всі значення одразу.

Ліпп звичайний, 158

(lambda(x y n)(loop repeat n for a = x then b for b = y then r for o in '#1=(+ * - / . #1#)for r =(ignore-errors(funcall o a b))collect(coerce a'long-float)))

Не дуже конкурентоспроможний, але мені подобається, як це виражається цілком природно:

(lambda (x y n)
  (loop 
    repeat n
    for a = x then b
    for b = y then r
    for o in '#1=(+ * - / . #1#)
    for r = (ignore-errors (funcall o a b))
    collect (coerce a 'long-float)))

Ми ігноруємо помилки при обчисленні R, через що R (а потім B) можливо приймає значення NIL. Це дозволяє вивести поточний результат, навіть якщо наступне значення не визначене. Тоді з часом цикл вийде з ладу, але це в межах правил.

Тести

Назвемо функцію Fта перевіримо, чи очікувані значення приблизно рівні випробуваному.

(loop
  for (args expected)
    in
  '(((1 3 8)
     (1 3 4 12 -8 -1.5 -9.5 14.25))

    ((0 1 5)
     (0 1 1 1 0))

    ((1 0 9)
     (1 0 1 0 1 0 1 0 1))

    ((6 3 25)
     (6 3 9 27 -18 -1.5 -19.5 29.25 -48.75 -0.6 -49.35 29.61 -78.96 -0.375 -79.335 29.7506 -109.086 -0.272727 -109.358 29.825 -139.183 -0.214286 -139.398 29.8709 -169.269)))

  for result = (apply #'f args)
  always (every (lambda (u v) (< (abs (- u v)) 0.001)) result expected))

=> T

Причина приблизного тесту полягає в тому, що обчислені значення трохи точніші, ніж потрібно; тут, для (f 6 3 25):

(6.0d0 3.0d0 9.0d0 27.0d0 -18.0d0 -1.5d0 -19.5d0 29.25d0 -48.75d0 -0.6d0
 -49.35d0 29.61d0 -78.96d0 -0.375d0 -79.335d0 29.750625d0 -109.085625d0
 -0.2727272727272727d0 -109.35835227272727d0 29.825005165289255d0
 -139.18335743801654d0 -0.21428571428571427d0 -139.39764315230224d0
 29.870923532636194d0 -169.26856668493843d0)

постійного струму, 112 110 108 байт

5k?sarfsmsn[pSnla1-Sa]sh[lmlndSm]sv[lvx/lhx]sb[lvx+lhx]sc[lvx*lhx]sd[lvx-lhx]se[lcx2la>d2la>e2la>b2la>j]dsjx

Іноді dcвідповіді можуть бути надто довгими, а іноді можуть бути надто короткими. Все залежить лише від проблеми, що стоїть перед нами, як це стосується багатьох інших мов. У будь-якому разі, це вимагає ввести одноіндексований вхідний командний рядок із 3-х цілих чисел x(1), x(2), Nпісля виклику та виводить кожен елемент послідовності в окремі рядки з не цілими виходами, що містять 5 цифр після десяткової крапки.

Наприклад, введення 6 3 25призводить до наступного виходу:

6
3
9
27
-18
-1.50000
-19.50000
29.25000
-48.75000
-.60000
-49.35000
29.61000
-78.96000
-.37500
-79.33500
29.75062
-109.08562
-.27272
-109.35834
29.82420
-139.18254
-.21428
-139.39682
29.86995
-169.26677

Perl, 62 + 3 ( -plaпрапор) = 65 байт

push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"

Використання:

perl -plae 'push@F,eval$F[-2].qw(* - / +)[$_%4].$F[-1]for 3..pop@F;$_="@F"' <<< '1 3 8'

Рубін, 79 байт

->(b,c,d){a=[b,c];(d-2).times{|i|a<<a[i].send(%i{+ * - /}[i%4],a[i+1]).to_f};a}

Я підозрюю, що це дуже далеко від оптимального (і я ще не розглядав інші відповіді), але все-таки це весело.

Я хотів трохи повеселитися Enumerable#cycle, але, на жаль, на 4 символи менше, ніж просто використовувати %4.

C ++ 14, 118 байт

[](auto&v,int N){for(int i=0;++i<N-1;){auto p=v.rbegin(),q=p+1;v.push_back(i%4?i%4<2?*q+*p:i%4<3?*q**p:*q-*p:*q/ *p);}

Як безіменна лямбда змінює свій вхід. Потрібно vбути vector<double>або vector<float>.

Безголівки та використання:

#include<iostream>
#include<vector>

auto f=
[](auto&v,int N){
  for(int i=0; ++i<N-1;){
    auto p=v.rbegin(),q=p+1;
    v.push_back(
      i%4 ?
        i%4<2 ? *q+*p : 
          i%4<3 ? *q**p : *q-*p
      : *q/ *p
    );
  }
};

int main(){
  std::vector<double> v={1,3};
  f(v,8);
  for (auto x:v) std::cout << x << ", ";
  std::cout << "\n";
}

машинний код x86-64, 34 байти

Конвенція виклику = x86-64 Система V x32 ABI (зареєструйте аргументи з 32-бітовими вказівниками у тривалому режимі).

Підпис функції є void stewie_x87_1reg(float *seq_buf, unsigned Nterms);. Функція отримує значення x0 і x1 насіння в перших двох елементах масиву і розширює послідовність на щонайменше ще N елементів. Буфер повинен бути зафіксований до 2 + N-округленням до наступного-кратного-4. (тобто 2 + ((N+3)&~3), або просто N + 5).

Потрібні вкладені буфери - це нормально в зборах для високоефективних функцій або функцій, що векторують SIMD, і цей розкручений цикл схожий, тому я не думаю, що він занадто сильно згинає правила. Абонент може легко (і повинен) ігнорувати всі елементи підкладки.

Передача x0 та x1 як аргумент функції, що вже не знаходиться в буфері, коштувала б нам всього 3 байтів (для a movlps [rdi], xmm0або movups [rdi], xmm0), хоча це було б нестандартним умовою виклику, оскільки System V проходить struct{ float x,y; };у двох окремих регістрах XMM.

Це objdump -drw -Mintelвиводиться з невеликим форматуванням для додавання коментарів

0000000000000100 <stewie_x87_1reg>:
       ;; load inside the loop to match FSTP at the end of every iteration
       ;; x[i-1] is always in ST0
       ;; x[i-2] is re-loaded from memory
 100:   d9 47 04                fld    DWORD PTR [rdi+0x4]
 103:   d8 07                   fadd   DWORD PTR [rdi]
 105:   d9 57 08                fst    DWORD PTR [rdi+0x8]
 108:   83 c7 10                add    edi,0x10            ; 32-bit pointers save a REX prefix here

 10b:   d8 4f f4                fmul   DWORD PTR [rdi-0xc]
 10e:   d9 57 fc                fst    DWORD PTR [rdi-0x4]

 111:   d8 6f f8                fsubr  DWORD PTR [rdi-0x8]
 114:   d9 17                   fst    DWORD PTR [rdi]

 116:   d8 7f fc                fdivr  DWORD PTR [rdi-0x4]
 119:   d9 5f 04                fstp   DWORD PTR [rdi+0x4]

 11c:   83 ee 04                sub    esi,0x4
 11f:   7f df                   jg     100 <stewie_x87_1reg>
 121:   c3                      ret    

0000000000000122 <stewie_x87_1reg.end>:
## 0x22 = 34 bytes

Ця реалізація посилань на C компілюється (з gcc -Os) дещо схожим кодом. gcc вибирає ту саму стратегію, що і я, зберігаючи лише одне попереднє значення в реєстрі.

void stewie_ref(float *seq, unsigned Nterms)
{
    for(unsigned i = 2 ; i<Nterms ; ) {
        seq[i] = seq[i-2] + seq[i-1];       i++;
        seq[i] = seq[i-2] * seq[i-1];       i++;
        seq[i] = seq[i-2] - seq[i-1];       i++;
        seq[i] = seq[i-2] / seq[i-1];       i++;
    }
}

Я експериментував з іншими способами, включаючи версію x87 з двома реєстраціями, яка має код, наприклад:

; part of loop body from untested 2-register version.  faster but slightly larger :/
; x87 FPU register stack    ;       x1, x2   (1-based notation)
fadd    st0, st1            ; x87 = x3, x2
fst     dword [rdi+8 - 16]  ; x87 = x3, x2

fmul    st1, st0            ; x87 = x3, x4
fld     st1                 ; x87 = x4, x3, x4
fstp    dword [rdi+12 - 16] ; x87 = x3, x4
; and similar for the fsubr and fdivr, needing one fld st1

Ви зробили б це так, якби їхали на швидкість (а SSE недоступний)

Виведення навантажень із пам’яті всередині циклу, а не один раз при вході, могло б допомогти, оскільки ми могли просто зберігати підзаконні та ділові результати не в порядку, але все-таки для встановлення стека на запис потрібні дві інструкції FLD.

Я також спробував використовувати скалярну математику SSE / AVX (починаючи зі значень у xmm0 та xmm1), але більший розмір інструкцій є вбивчим. Використання addps(оскільки це на 1В коротше addss) допомагає крихітно. Я використовував AVX VEX-префікси для некомутативних інструкцій, оскільки VSUBSS лише на один байт довший, ніж SUBPS (і така ж довжина, що і SUBSS).

; untested.  Bigger than x87 version, and can spuriously raise FP exceptions from garbage in high elements
addps   xmm0, xmm1      ; x3
movups  [rdi+8 - 16], xmm0
mulps   xmm1, xmm0      ; xmm1 = x4,  xmm0 = x3
movups  [rdi+12 - 16], xmm1
vsubss  xmm0, xmm1, xmm0      ; not commutative.  Could use a value from memory
movups  [rdi+16 - 16], xmm0
vdivss  xmm1, xmm0, xmm1      ; not commutative
movups  [rdi+20 - 16], xmm1

Випробуваний за допомогою цього тестового джгута:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int main(int argc, char**argv)
{
    unsigned seqlen = 100;
    if (argc>1)
        seqlen = atoi(argv[1]);
    float first = 1.0f, second = 2.1f;
    if (argc>2)
        first = atof(argv[2]);
    if (argc>3)
        second = atof(argv[3]);

    float *seqbuf = malloc(seqlen+8);  // not on the stack, needs to be in the low32
    seqbuf[0] = first;
    seqbuf[1] = second;

    for(unsigned i=seqlen ; i<seqlen+8; ++i)
        seqbuf[i] = NAN;

    stewie_x87_1reg(seqbuf, seqlen);
//  stewie_ref(seqbuf, seqlen);
    for (unsigned i=0 ; i< (2 + ((seqlen+3)&~3) + 4) ; i++) {
        printf("%4d: %g\n", i, seqbuf[i]);
    }

    return 0;
}

Компілювати з nasm -felfx32 -Worphan-labels -gdwarf2 golf-stewie-sequence.asm &&
gcc -mx32 -o stewie -Og -g golf-stewie-sequence.c golf-stewie-sequence.o

Запустіть перший тестовий зразок за допомогою ./stewie 8 1 3

Якщо у вас не встановлені бібліотеки x32, використовуйте nasm -felf64та залишайте gcc, використовуючи типовий параметр -m64. Я використовував mallocзамість float seqbuf[seqlen+8](у стеці), щоб отримати низьку адресу, не будуючи насправді x32.

Факт забави: YASM має помилку: він використовує rel32 jcc для гілки циклу, коли ціль гілки має таку ж адресу, що і глобальний символ.

global stewie_x87_1reg
stewie_x87_1reg:
   ;; ended up moving all prologue code into the loop, so there's nothing here
.loop:

...
sub    esi, 4
jg     .loop

збирає ... 11f: 0f 8f db ff ff ff jg 100 <stewie_x87_1reg>

05AB1E , 12 байт

λ£"-/+*"Nè.V

Спробуйте в Інтернеті!

Japt , 20 байт

@OxVs2n)q"-/+*"gY}hV

Спробуй це

Bash, 224 байт (НЕ КОНКУРС)

Надзвичайно велика реалізація в BASH .

Завдання приймає досить буквально, і виконує все в одній безперервній трубі, без будь-яких недобросовісних керуючих структур потоку або рекурсії.

Вхідні дані

$ 1, $ 2 - початкові елементи

$ 3 - розмір цільової послідовності

Гольф

{ echo "a[0]=$1;a[1]=$2;a[0];a[1]";paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);}|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/'|bc -l

Менше гольф

{ 
 echo "a[0]=$1;a[1]=$2;a[0];a[1]";
 paste <() <(seq 2 $[$3-1]) <(seq 0 $[$3-3]) <(printf '%.0s+*-/' `seq $[$3/4]`|fold -1|head -$[$3-2]) <(seq 1 $[$3-2]);
}\
|sed -r '1 ! s/(.+)\s(.+)\s(.+)\s(.)/a[\1]=a[\2]\3a[\4];a[\1];/' \
|bc -l

Тест

>./stewie.sh 1 3 8
1
3
4
12
-8
-1.50000000000000000000
-9.50000000000000000000
14.25000000000000000000

Етапи трубопроводу

Створіть таблицю індексів елементів + ​​op для кожного елемента послідовності виводу (по одному на рядок):

...
2   0   +   1
3   1   *   2
4   2   -   3
5   3   /   4
6   4   +   5
7   5   *   6
...

Використовуйте sed, щоб перетворити це в лінійну програму bc :

...
a[2]=a[0]+a[1];a[2];
a[3]=a[1]*a[2];a[3];
a[4]=a[2]-a[3];a[4];
a[5]=a[3]/a[4];a[5];
a[6]=a[4]+a[5];a[6];
a[7]=a[5]*a[6];a[7];
...

годуйте це до bc і нехай він виконує всю роботу

Pyth - 20 байт

Виведення всіх nвитрат на мене.

u+Gvj@"+*-/"H>2GttEQ

Не працює в Інтернеті, тому що eval.

Цейлон, 195 байт

Float[]s(Integer a,Integer b,Integer n)=>loop([a.float,b.float,[Float.divided,Float.plus,Float.times,Float.minus].cycled.rest])(([x,y,o])=>[y,(o.first else nothing)(x)(y),o.rest]).take(n)*.first;

Відформатовано та прокоментовано:

// Print the first n entries of the Stewies sequence with given starting entries.
//
// Question:  http://codegolf.stackexchange.com/q/101145/2338
// My answer: http://codegolf.stackexchange.com/a/101251/2338

// Declare a function `s` which takes three integers, and returns a tuple
// of floats. (The more common syntax for the return value is [Float*],
// but Float[] is shorter.)
Float[] s(Integer a, Integer b, Integer n)
       // it is implemented by evaluating the following expression for each call.
         =>
        // start a loop with ...
        loop([
              // ... float versions of the integers, and ...
              a.float, b.float,
              // ... an infinite sequence of the four operators, ever repeating.
              // I needed the `.rest` here so the whole thing gets a {...*} type
              // instead of {...+}, which doesn't fit to what o.rest returns.
              // Each operator has the type Float(Float)(Float), i.e. you apply
              // it twice to one float each to get a Float result.
              [Float.divided, Float.plus, Float.times, Float.minus].cycled.rest])
               // in each iteration of the loop, map the triple of two numbers
               // and a sequence of operators to a triple of ... 
            (([x, y, o]) => [
               // the second number, 
                y,
               //the result of the first operator with both numbers
               // (using this "else nothing" here to convince the
               //  compiler that o.first is not null),
                   (o.first else nothing)(x)(y),
               // and the sequence of operators without its first element.
               // (that one unfortunately has a {...*} type, i.e. a possibly
               //  empty sequence.)
                                                 o.rest])
            // now we got an infinite sequence of those triples.
            // We just want the first n of them ...
                .take(n)
            // and of each triple just the first element.
            // (The *. syntax produces a tuple, non-lazily.
            //  We could also have used .map((z) => z.first)
            //  or .map(Iterable.first) or .map((z) => z[0]), each of
            //  which would return a (lazy) sequence, but they all would be
            //  longer.)
                *.first;

Приклад використання:

shared void run() {
    print(s(1, 3, 8));
    print(s(0,1,11));
    print(s(1,0,9));
    print(s(6, 3, 29));
}

Приклад виводу:

[1.0, 3.0, 4.0, 12.0, -8.0, -1.5, -9.5, 14.25]
[0.0, 1.0, 1.0, 1.0, 0.0, Infinity, Infinity, Infinity, NaN, NaN, NaN]
[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]
[6.0, 3.0, 9.0, 27.0, -18.0, -1.5, -19.5, 29.25, -48.75, -0.6, -49.35, 29.61, -78.96000000000001, -0.37499999999999994, -79.33500000000001, 29.750625, -109.08562500000001, -0.2727272727272727, -109.35835227272727, 29.825005165289255, -139.18335743801651, -0.2142857142857143, -139.39764315230224, 29.870923532636194, -169.26856668493843, -0.17647058823529413, -169.44503727317374, 29.90206540114831, -199.34710267432206]

Другий приклад показує, як це впоралося б з поділом на нуль. Останній приклад показує, що результати дещо відхиляються залежно від того, який тип арифметики (і округлення) використовується ... Я думаю, що 64-бітна арифметика з плаваючою точкою Цейлона трохи ближче до того, що має бути, ніж того, що було розміщено у запитанні .

Clojure, 99 байт

#(let[ops[+ * - /]](take %3(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[%1 %2 0]))))

Цю версію приємніше використовувати на практиці, але вона має 110 байт:

(defn f[a b n](let[ops[+ * - /]](take n(map first(iterate(fn[[a b i]][b((ops i)a b)(mod(inc i)4)])[a b 0])))))

У мене виникли проблеми із плавленням повтореної функції та циклічною послідовністю операцій, тому мені довелося замість цього використовувати лічильник. Також спробував використовувати таблицю переходу FSM, як, {+ * * - - / / +}але я не зміг її видавити до меншого коду.

Може виражатися як анонімна функція

Без гольфу:

(defn f [a b n]
  (let [ops [+ * - /]]
    (->> [a b 0]
         (iterate (fn [[a b i]]
                    [b
                     ((ops i) a b)
                     (mod (inc i) 4)]))
         (map first)
         (take n))))

Потрібно називати поплавками, як (f 6.0 3.0 25)інакше ви отримуєте раціональні числа. Можна також запустити ітерацію, [a (float b) 0]яка приносить кілька додаткових символів.

Октава , 91 байт

@(x,n)eval 'for i=3:n,x(i)=eval([(n=@num2str)(x(i-2)),"*-/+"(mod(i,4)+1),n(x(i-1))]);end,x'

Спробуйте в Інтернеті!

Деякі гольфи:

• Немає дужок для першого evalдзвінка
• Для першого evalдзвінка немає контактів
• Вбудоване присвоєння *-/+(неможливо в MATLAB)
• У поєднанні 'та "уникати втечі апострофи (неможливо в MATLAB)
• Зберігання, n=@num2strоскільки використовується два рази (неможливо в MATLAB)