Stewieのシーケンス:+ *-/ + *-/


29

4つの基本的な操作、加算+、乗算*、減算-、除算/(整数ではなく浮動)を使用しましょう。

Stewieのシーケンスは次のように定義されます。

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.

チャレンジ:

入力として2つの非負整数(x(1), x(2))と1つの正整数Nを取ります。

x(1)そしてx(2)、シーケンスの最初の2つの番号でNあり、出力する必要があるシーケンスの長さです。(リストを0ベースにすることもできます。この場合N、長さよりも1つ少なくなります)。

  • あなたはそれを仮定することはできませんx(2) >= x(1)
  • N常に>21ベースの場合(>10ベースの場合)になります。
  • ゼロによる除算エラーを処理する必要はありません。
    • 2番目のテストケースに注意してください。あなたは得ることはありません0, 1し、N=6入力として、それがゼロ除算になりますので、していますが、サポートしなければならない0, 1N=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

関数はx(1)とx(2)をリストとして取ることができますか?または別の引数?
FlipTack

あなたにとって便利なものは何でも:)
Stewie Griffin

N0ベースにすることはできますか?したがって、例に示されているNより1少ない入力を使用してください。N-2をとるのはあまりにも多すぎると思います... :-P
ルイスメンドー

出力を任意の便利な形式で作成できる場合、最初に最後の要素があり、最後に開始要素があるリスト(逆のリスト)が含まれていますか?
エミグナ

1
@Emignaは、ノー私はストレッチのビットだと思う...番号が正しい順序でなければなりません
Stewieグリフィン

回答:


3

MATL19 18 17バイト

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

入力の形式である:N(0系)x(1)x(2)(文字列として)。すべて改行で区切られています。

オンラインでお試しください!または、すべてのテストケースを検証します(わずかに変更されたコード、空白行で区切られた出力シーケンス)。

説明

MATLには適切なeval関数はありませんが、Ustr2num)は中置演算子を使用して数値式を評価できます。

新しい用語はそれぞれ計算され、スタックにプッシュされ、前の用語が保持されます。スタック全体が最後に印刷されます。

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

7

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 

別のアプローチ、わずかに長い。引数の順序はNx2x1。使用例:( (.a).(.).take ) 8 3 1-> [1.0,3.0,4.0,12.0,-8.0,-1.5,-9.5,14.25]

定義4つの機能abcd二つの引数を取りyx そして置くことによって、リストを作成するxと、次の関数の呼び出しの前にy2番目の引数としておよびx op y最初のよう。たとえば、a次のとおりです。a y x = x : (b (x+y) y)b乗算を行います:b y x = x : (c (x*y) y)など。

編集:@Michael Kleinは、1番目のバリアントにバイトを保存しました(#)に。幸いにも、2番目のバリアントの1バイトが見つかったため、両方とも同じ長さになります。

編集II:@Zgarbは2番目のバージョンで2バイト、最初のバージョンでI 4を見つけたため、同じ長さではなくなりました。


バイトのために(許可)リストとして引数を受け入れる
マイケル・クライン

(.)他の機能で構成されている場合、私は常に混乱します:p
tomsmeding

g x=(`take`f)whereバイトを保存しません: - /
Bergi

:別のアプローチでは2バイトの保存(h%g)y x=x:g(h x y)y
Zgarb

@Zgarb:ああ、いいね。ありがとう!ところで、あなたの提案で編集するとき、最初のバージョンで途中で保存するために4バイトを見つけました。
-nimi

6

ES6(Javascript)、 7967、65バイト

更新

  • @ETHProductionsで示唆されているように、i = 2で始まる、マイナス2バイト
  • @Neilからの素晴らしいアドバイスのおかげで、3バイト節約されました!

ゴルフ

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, ...]

1
++i1からi2 を追加する必要を避けるために使用できませんか?
ニール

1
または、代わりに、書き込み?S(n,a,i+1,a.push(...)):aを行うと、バイト数を節約できます。
ニール

1
またはa.push、新しい長さを返すという事実を使用することもできますS=(n,a,i=2)=>i<n?S(n,a,a.push(...)):a
ニール

1
それでも、開始することでより多くのバイトを節約できると思いますi=2
ニール

1
ニールの提案では、S=(n,a,i=2)=>i<n?S(n,a,a.push(eval(a[i-2]+"+*-/"[i%4]+a[i-1]))):a2バイト節約することができると思います。
ETHproductions

5

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バイト


O一度しか使用しないので'-/+*'[i%4]、の宣言を実行して削除することにより、数バイトを節約できますO。また、のようなことを繰り返しstr行うことで、への繰り返しの呼び出しを回避できる場合がありますeval('%s'*3%(s[-2],'-/+*'[i%4],s[-1]))

ええ、そしてs+=[...]置き換えられますs+=...,(末尾のコンマに注意してください)。

ソリューションを破壊できるのはxnorだけではありません。別の人もいます:Dennis(the mod)。
エリックアウトゴルファー

i入力として取得することが保証されているので、デフォルト値は必要ありません(i=2ちょうどである場合もありますi)。2バイトオフ。
ArtOfCode

1
それが戻した場合はn代わりに順番に目のアイテムを、これは再帰で短い1バイトである:f=lambda x,n:n<2and x[n-1]or eval('%s'*3%(f(x,n-2),'*-/+'[n%4],f(x,n-1)))
mbomb007

5

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

  ]
}

4

Mathematica、68バイト

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

かろうじて3位に入りました!Stewieシーケンスの正確にn番目の要素x(n)である±ようなヘルパー単項演算子を使用する3つの引数の名前のない関数±n。最初の2つの引数はx(1)とx(2)で、3番目の引数は出力するx(N)を示すNです。

mod-4計算を使用して、前の2つの用語に適用するバイナリ関数を選択する直接実装。正しいバイナリ関数を選択することは1##[#-#2,#/#2,+##]これらの楽しいMathematicaゴルフのトリックを使用します。


3

05AB1E21 19 18バイト

入力はN(0ベース)、x(2)x(1)の順序で取得されます。carusocomputingの
おかげで1バイト節約されました

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

シーケンス内の最新の要素を先頭にして、以前のすべての要素を順番に保持しながらスタックを繰り返し構築します。
次に、スタックを最後にリストでラップして、すべての値を一度に表示します。


1
私はそれを理解できませんでしたが、使用するXYUVバイトを節約できます。
魔法のタコUr

1
@carusocomputing:いいね!UX:) を使用して暗黙的な入力で動作しないレジスタから失われたバイトを保存しました
Emigna

2

Common Lisp、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)

2

DC、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答えは超長くなることがあり、時には彼らはスーパー短くすることができます。他の多くの言語の場合と同様に、それはすべて手元の課題に依存しています。とにかく、これはスペースで区切られた1つのインデックス付きの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

2

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'

1

ルビー、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


1

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

1

x86-64マシンコード、34バイト

呼び出し規約= x86-64 System V x32 ABI(ロングモードで32ビットポインターを使用して引数を登録)。

関数のシグネチャはvoid stewie_x87_1reg(float *seq_buf, unsigned Nterms);です。この関数は、配列の最初の2つの要素のx0およびx1シード値を受け取り、シーケンスを少なくともN個以上の要素に拡張します。バッファは、2 + N-rounded-up-to-next-multiple-of-4にパディングする必要があります。(すなわち2 + ((N+3)&~3)、またはN + 5のみ)。

高性能またはSIMDベクトル化関数のアセンブリでは、パディングバッファが必要です。また、この展開されたループは類似しているため、ルールを過度に曲げているとは思いません。呼び出し元は、すべてのパディング要素を簡単に無視できます(そして、そうすべきです)。

System Vが2つの別個のXMMレジスターを渡すため、これは非標準の呼び出し規則ですが、バッファーにまだない関数引数としてx0とx1を渡すと3バイト(movlps [rdi], xmm0またはmovups [rdi], xmm0)になりますstruct{ float x,y; };

これは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は、以前の値を1つだけレジスタに保持するという、私がやったのと同じ戦略を選びます。

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

次のようなコードを持つ2レジスタ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は利用できませんでした)

subとdivの結果を順不同で保存できるので、エントリの1回ではなくループ内にメモリからのロードを配置すると役立つかもしれませんが、エントリのスタックを設定するには2つのFLD命令が必要です。

また、SSE / AVXスカラー演算(xmm0およびxmm1の値から開始)を使用してみましたが、より大きな命令サイズは致命的です。を使用するとaddps(1Bがaddss)より短くなるため、少し役立ちます。VSUBSSはSUBPSよりも1バイトだけ長い(そしてSUBSSと同じ長さである)ため、非可換命令にはAVX VEXプレフィックスを使用しました。

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




0

Bash、224バイト(コンテストなし)

BASHの非常に大きな実装。

文字通りにタスクを処理し、フロー構造や再帰を制御することなく、すべてを1つの連続したパイプで実行します。

入力

$ 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

パイプラインステージ

各出力シーケンス要素(行ごとに1つ)について、要素インデックス+ 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にフィードして、すべての仕事をさせます


0

Pyth-20バイト

すべての出力にはnコストがかかります。

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

evalのオンラインcuzで動作しません。


0

セイロン、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]

2番目の例は、これがゼロによる除算をどのように処理するかを示しています。最後の例は、使用している算術(および丸め)の種類によって結果が少し異なることを示しています。 。


0

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]いくつかの余分な文字をもたらす反復を開始することもできます。


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=@num2str2回使用されているため保存(MATLABでは不可能)
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.