スターン- Brocot配列は Fibonnaci様配列次のように構成することが可能です。

1. シーケンスを初期化する s(1) = s(2) = 1
2. カウンターを設定 n = 1
3. s(n) + s(n+1)シーケンスに追加する
4. s(n+1)シーケンスに追加する
5. インクリメントn、ステップ3に戻る

これは次と同等です：

他のプロパティの中でも、Stern-Brocotシーケンスを使用して、可能なすべての正の有理数を生成できます。すべての有理数は一度だけ生成され、常に最も単純な用語で表示されます。たとえば、1/3シーケンスの第四有理数、同等の数字である2/6、3/9などがまったく表示されません。

上記のように、n番目の有理数をとして定義できますr(n) = s(n) / s(n+1)。ここでs(n)は、n番目のStern-Brocot数です。

あなたの課題は、Stern-Brocotシーケンスを使用して生成されたn番目の有理数を出力するプログラムまたは関数を作成することです。

• 上記のアルゴリズムは1から始まります。エントリのインデックスが0の場合は、回答に記載してください
• 説明されているアルゴリズムは説明のみを目的としており、出力は任意の方法で導出できます（ハードコーディング以外）
• 入力は、STDIN、関数パラメーター、またはその他の妥当な入力メカニズムを介して行うことができます
• Ouptutは、STDOUT、コンソール、関数の戻り値、またはその他の妥当な出力ストリームになります。
• 出力はの形式の文字列である必要がありますa/b。ここでaおよびbは、Stern-Brocotシーケンスの関連エントリです。出力前に端数を評価することはできません。たとえば、入力の12場合、出力はで2/5はなくである必要があり0.4ます。
• 標準の抜け穴は許可されていません

これはcode-golfなので、バイト単位の最短回答が勝ちます。

テストケース

ここでのテストケースは1から始まります。

n    r(n)
--  ------
1    1/1
2    1/2
3    2/1
4    1/3
5    3/2
6    2/3
7    3/1
8    1/4
9    4/3
10   3/5
11   5/2
12   2/5
13   5/3
14   3/4
15   4/1
16   1/5
17   5/4
18   4/7
19   7/3
20   3/8
50   7/12
100  7/19
1000 11/39

OEISエントリ：A002487
シーケンスについて説明している優秀なNumberphileビデオ：Infinite Fractions

ゼリー、14バイト

3ẋḶŒpḄċ
’Ç”/⁸Ç

オンラインでお試しください！

ああ、@ Dennisが受け入れた答えを、同じ言語で打ち負かすことができるようです。これは、OEISの数式を使用して機能します。ハイパーバイナリ（つまり、数字として0、1、2のバイナリ）で表現する方法の数（数-1）。ほとんどのJellyプログラム（完全なプログラムまたは関数のいずれかとして機能する）とは異なり、このプログラムは完全なプログラムとしてのみ機能します（出力の一部をstdoutに送信し、残りを返すためです;完全なプログラムとして使用される場合、戻り値暗黙的にstdoutに送信されるため、すべての出力は同じ場所にありますが、これは関数の送信では機能しません）。

このバージョンのプログラムは非常に非効率的です。最初の行の直後にnを配置することで、最大2 allまでのすべての入力に対して機能するはるかに高速なプログラムを作成できますẋ。プログラムのパフォーマンスはO（n ×3ⁿ）であるため、ここではnを小さく保つことが非常に重要です。書かれているプログラムは、nを入力に等しく設定します。これは明らかに十分に大きいですが、ほとんどすべての場合に明らかに大きすぎます（ただし、バイトを節約します）。

説明

私のJellyの説明でいつものように、中括弧内のテキスト（例{the input}）は、元のプログラムのオペランドが欠落しているためにJellyによって自動的に埋められたものを示しています。

ヘルパー関数（n番目の分母、つまりn +1番目の分子を計算）：

3ẋḶŒpḄċ
3ẋ       3, repeated a number of times equal to {the argument}
  Ḷ      Map 3 to [0, 1, 2]
   Œp    Take the cartesian product of that list
     Ḅ   Convert binary (or in this case hyperbinary) to a number
      ċ  Count number of occurrences of {the argument} in the resulting list

最初の5バイトは基本的に、指定された長さまでのすべての可能なハイパーバイナリ数を生成するだけです。たとえば、入力3では、Ḷ[[0,1,2]、[0,1,2]、[0,1,2] ]]デカルト積は[[0,0,0]、[0,0,1]、[0,0,2]、[0,1,0]、…、[2,2,1]、 [2,2,2]]。Ḅ基本的には、最後のエントリに1を、最後から2番目にエントリを、最後から2番目にエントリを4倍するなどして、追加します。これは通常、バイナリを10進数に変換するために使用されますが、数字2をうまく処理できるため、ハイパーバイナリでも機能します。次に、シーケンス内の適切なエントリを取得するために、結果リストに入力が表示される回数をカウントします。（幸いなことに、分子と分母は同じシーケンスに従います）。

メインプログラム（分子と分母を要求し、出力をフォーマットします）：

’Ç”/⁸Ç
’Ç      Helper function (Ç), run on {the input} minus 1 (‘)
  ”/    {Output that to stdout}; start again with the constant '/'
    ⁸Ç  {Output that to stdout}; then run the helper function (Ç) on the input (⁸)

どういうわけか、実際の問題を解決するのと同じくらい多くのバイトをI / Oの処理に使用するプログラムを書き続けています…

CJam（20バイト）

1_{_@_2$%2*-+}ri*'/\

オンラインデモ。これは0から始まることに注意してください。それは1インデックスにするために、初期置き換える1_ことによってをT1。

解剖

これは、Moshe Newmanによる特性評価を使用しています。

画分はa(n+1)/a(n+2)、前の画分から生成することが可能a(n)/a(n+1) = xで1/(2*floor(x) + 1 - x)

場合はx = s/t、我々が得ます

  1 / (2 * floor(s/t) + 1 - s/t)
= t / (2 * t * floor(s/t) + t - s)
= t / (2 * (s - s%t) + t - s)
= t / (s + t - 2 * (s % t))

今、私たちがそれを仮定しs、t互いに素であれば

  gcd(t, s + t - 2 * (s % t))
= gcd(t, s - 2 * (s % t))
= gcd(t, -(s % t))
= 1

だから、a(n+2) = a(n) + a(n+1) - 2 * (a(n) % a(n+1))完璧に動作します。

1_           e# s=1, t=1
{            e# Loop...
  _@_2$%2*-+ e#   s, t = t, s + t - 2 * (s % t)
}
ri*          e# ...n times
'/\          e# Separate s and t with a /

Haskell、78 77 65 58バイト

最適化されたアプローチを恥知らずに盗むことにより、次のことが可能になります。

(s#t)0=show s++'/':show t
(s#t)n=t#(s+t-2*mod s t)$n-1
1#1

インフィックス関数を使用して数バイトをゴルフしてくれた@nimiに感謝します！

（それでも）0から始まるインデックスを使用します。

古いアプローチ：

s=(!!)(1:1:f 0)
f n=s n+s(n+1):s(n+1):(f$n+1)
r n=show(s n)++'/':(show.s$n+1)

出力形式をくそ...インデックス演算子。編集：そして優先順位。

面白い事実：異種リストが重要な場合、最後の行は次のようになります

r n=show>>=[s!!n,'/',s!!(n+1)]

ゼリー、16 バイト

L‘Hị⁸Sṭ
1Ç¡ṫ-j”/

オンラインでお試しください！または、すべてのテストケースを確認します。

使い方

1Ç¡ṫ-j”/  Main link. Argument: n

1         Set the return value to 1.
 Ç¡       Apply the helper link n times.
   ṫ-     Tail -1; extract the last two items.
     j”/  Join, separating by a slash.


L‘Hị⁸Sṭ   Helper link. Argument: A (array)

L         Get the length of A.
 ‘        Add 1 to compute the next index.
  H       Halve.
   ị⁸     Retrieve the item(s) of A at those indices.
          If the index in non-integer, ị floors and ceils the index, then retrieves
          the items at both indices.
    S     Compute the sum of the retrieved item(s).
     ṭ    Tack; append the result to A.

05AB1E、34 33 25 23バイト

XX‚¹GÂ2£DO¸s¦ìì¨}R2£'/ý

説明

XX‚                        # push [1,1]
   ¹G           }          # input-1 times do
     Â                     # bifurcate
      2£                   # take first 2 elements of reversed list
        DO¸                # duplicate and sum 1st copy, s(n)+s(n+1)
           s¦              # cut away the first element of 2nd copy, s(n)
             ìì            # prepend both to list
               ¨           # remove last item in list
                 R2£       # reverse and take the first 2 elements
                    '/ý    # format output
                           # implicitly print

オンラインで試す

Adnanのおかげで2バイト節約されました。

MATL、20バイト

FT+"@:qtPXnosV47]xhh

これは、OEISページで与えられた二項係数の観点から特徴付けを使用します。

このアルゴリズムは理論的にはすべての数値で機能しますが、実際にはMATLの数値精度によって制限されているため、大きなエントリでは機能しません。結果は20、少なくとも入力までは正確です。

オンラインでお試しください！

説明

FT+      % Implicitly take input n. Add [0 1] element-wise. Gives [n n+1]
"        % For each k in [n n+1]
  @:q    %   Push range [0 1 ... k-1]
  tP     %   Duplicate and flip: push [k-1 ... 1 0]
  Xn     %   Binomial coefficient, element-wise. Gives an array
  os     %   Number of odd entries in that array
  V      %   Convert from number to string
  47     %   Push 47, which is ASCII for '\'
]        % End for each
x        % Remove second 47
hh       % Concatenate horizontally twice. Automatically transforms 47 into '\'
         % Implicitly display

Python 2、85 81バイト

x,s=input(),[1,1]
for i in range(x):s+=s[i]+s[i+1],s[i+1]
print`s[x-1]`+"/"+`s[x]`

この投稿は1から始まります。

再帰関数を使用して、85バイト：

s=lambda x:int(x<1)or x%2 and s(x/2)or s(-~x/2)+s(~-x/2)
lambda x:`s(x)`+"/"+`s(x+1)`

次のような出力True/2が受け入れられる場合、81バイトに1つあります。

s=lambda x:x<1 or x%2 and s(x/2)or s(-~x/2)+s(~-x/2)
lambda x:`s(x)`+"/"+`s(x+1)`

JavaScript（ES6）、43バイト

f=(i,n=0,d=1)=>i?f(i-1,d,n+d-n%d*2):n+'/'+d

1インデックス付き。n=1インデックスが0に変更されます。リンクされたOEISページには、前の2つの用語に関して、各用語に対して有用な再帰関係があります。私は単に、前のフラクションに関して、各フラクションの繰り返しとして再解釈しました。残念ながら、インラインTeXがないため、別のサイトに貼り付けて、この形式を確認する必要があります。

Python 2、66バイト

f=lambda n:1/n or f(n/2)+n%2*f(-~n/2)
lambda n:`f(n)`+'/'+`f(n+1)`

再帰式を使用します。

C（GCC）、79バイト

0ベースのインデックスを使用します。

s(n){return!n?:n%2?s(n/2):s(-~n/2)+s(~-n/2);}r(n){printf("%d/%d",s(n),s(n+1));}

イデオネ

実際には、18バイト

11,`│;a%τ@-+`nk'/j

オンラインでお試しください！

このソリューションでは、ピーターの式を使用していますを、同様に0インデックスが付けられています。Leaky Nunに感謝します。

説明：

11,`│;a%τ@-+`nk'/j
11                  push 1, 1
  ,`│;a%τ@-+`n      do the following n times (where n is the input):
                      stack: [t s]
    │                 duplicate the entire stack ([t s t s])
     ;                dupe t ([t t s t s])
      a               invert the stack ([s t s t t])
       %              s % t ([s%t s t t])
        τ             multiply by 2 ([2*(s%t) s t t])
         @-           subtract from s ([s-2*(s%t) s t])
           +          add to t ([t+s-2*(s%t) t])
                      in effect, this is s,t = t,s+t-2*(s%t)
              k'/j  push as a list, join with "/"

MATL、32 30バイト

1i:"tt@TF-)sw@)v]tGq)V47bG)Vhh

これは直接的なアプローチを使用します：シーケンスの十分なメンバーを生成し、必要な2つを選択し、出力をフォーマットします。

オンラインでお試しください！

R、93バイト

f=function(n)ifelse(n<3,1,ifelse(n%%2,f(n/2-1/2)+f(n/2+1/2),f(n/2)))
g=function(n)f(n)/f(n+1)

文字通り最も単純な実装。ゴルフに少し取り組んでいます。

m4、131バイト

define(s,`ifelse($1,1,1,eval($1%2),0,`s(eval($1/2))',`eval(s(eval(($1-1)/2))+s(eval(($1+1)/2)))')')define(r,`s($1)/s(eval($1+1))')

マクロ定義するrようにr(n)評価するには仕様に応じ。まったくゴルフをしていませんが、フォーミュラをコーディングしました。

ルビー、49バイト

これは0から始まり、Peter Taylorの式を使用します。ゴルフの提案を歓迎します。

->n{s=t=1;n.times{s,t=t,s+t-2*(s%t)};"#{s}/#{t}"}

> <>、34 + 2 = 36バイト

ピーターテイラーの優れた答えを見た後、テストの答えを書き直しました（これは非常に不器用な再帰を使用して、恥ずかしい82バイトでした）。

&01\$n"/"on;
&?!\:@}:{:@+@%2*-&1-:

入力がスタックに存在することを想定しているため、-vフラグは+2バイトです。オンラインでお試しください！

オクターブ、90バイト

function f(i)S=[1 1];for(j=1:i/2)S=[S S(j)+S(j+1) (j+1)];end;printf("%d/%d",S(i),S(i+1));end

C＃、91 90バイト

n=>{Func<int,int>s=_=>_;s=m=>1==m?m:s(m/2)+(0==m%2?0:s(m/2+1));return$"{s(n)}/{s(n+1)}";};

にキャストしFunc<int, string>ます。これは再帰的な実装です。

ゴルフをしていない：

n => 
{
    Func<int,int> s = _ => _; // s needs to be set to use recursively. _=>_ is the same byte count as null and looks cooler.
    s = m =>
        1 == m ? m               // s(1) = 1
        : s(m/2) + (0 == m%2 ? 0 // s(m) = s(m/2) for even
        : s(m/2+1));             // s(m) = s(m/2) + s(m/2+1) for odd
    return $"{s(n)}/{s(n+1)}";
};

編集：-1バイト。C＃の判明には、間にスペースを必要としないreturnし、$補間された文字列を。

Python 2、59バイト

s,t=1,1;exec"s,t=t,s+t-2*(s%t);"*input();print'%d/%d'%(s,t)

用途 Peterの式を、同様に0インデックスが付けられます。

オンラインで試す

J、29バイト

([,'/',])&":&([:+/2|]!&i.-)>:

使用法

nの大きな値にxは、拡張整数の使用を示す接尾辞が必要です。

   f =: ([,'/',])&":&([:+/2|]!&i.-)>:
   f 1
1/1
   f 10
3/5
   f 50
7/12
   f 100x
7/19
   f 1000x
11/39

Mathematicaの、108の 106 101バイト

(s={1,1};n=1;a=AppendTo;t=ToString;Do[a[s,s[[n]]+s[[++n]]];a[s,s[[n]]],#];t@s[[n-1]]<>"/"<>t@s[[n]])&

R、84バイト

function(n,K=c(1,1)){for(i in 1:n)K=c(K,K[i]+K[i+1],K[i+1])
paste0(K[i],"/",K[i+1])}

オンラインでお試しください！

古いRの実装では、文字列ではなく浮動小数点を返し、ないので、ここでの1を仕様に従っていません。