ノードが重心座標を使用してラベル付けされている標準の正三角形を考えてみましょう。

この3つのノードの三角形を6つのノードの三角形に変えるには、3つの頂点の新しい線（元の3つのノードの三角形の側面にあるものよりも多く）を追加し、内部エッジ（内部ノードではなく）を削除し、座標を正規化する：

（再び、一つ以上のオリジナル6ノード三角形の側に存在していた）、4つの頂点の行を追加し、10ノードの三角形に6ノード三角形から行くためのプロセスを繰り返すこと、任意の内部エッジ（ただし、削除しない内部ノードを）座標を再正規化します：

このプロセスは無期限に繰り返すことができます。このチャレンジの目標には、Nこのプロセスが実行された回数を表す整数が与えられ、重心座標で関連する三角形のすべてのノードが出力されます。

入力

プログラム/関数は、Nこのプロセスが適用された回数を表す単一の負でない整数を入力として受け取る必要があります。N=0では、3つのノードを持つ元の三角形を出力する必要があることに注意してください。

入力は、任意のソース（関数パラメーター、stdioなど）から取得できます。

出力

プログラム/関数は、すべてのノードを正規化された重心座標で出力する必要があります。ノードの順序は関係ありません。数値は、分数（分数の削減は不要）または浮動小数点数として指定できます。「スケーリングされた」ベクトルを出力してノードを指定することもできます。たとえば、次の3つの出力はすべて同等であり、許可されます。

0.5,0.5,0

1/2,2/4,0

[1,1,0]/2

浮動小数点出力を使用する場合、出力は1％以内の精度である必要があります。出力は、必要なシンク（stdio、戻り値、戻りパラメーターなど）になります。重心座標はノードごとに2つの数値によってのみ一意に決定されますが、ノードごとに3つの数値すべてを出力する必要があることに注意してください。

例

サンプルケースの形式は次のとおりです。

N
x0,y0,z0
x1,y1,z1
x2,y2,z2
...

ここで、最初の行は入力Nであり、後続のすべての行x,y,zは、出力に1回だけ存在するノードを形成します。すべての数値は、近似浮動小数点数として与えられます。

0
1,0,0
0,1,0
0,0,1

1
1,0,0
0,1,0
0,0,1
0.5,0,0.5
0.5,0.5,0
0,0.5,0.5

2
1,0,0
0,1,0
0,0,1
0.667,0,0.333
0.667,0.333,0
0.333,0,0.667
0.333,0.333,0.333
0.333,0.667,0
0,0.333,0.667
0,0.667,0.333

3
1,0,0
0.75,0,0.25
0.75,0.25,0
0.5,0,0.5
0.5,0.25,0.25
0.5,0.5,0
0.25,0,0.75
0.25,0.25,0.5
0.25,0.5,0.25
0.25,0.75,0
0,0,1
0,0.25,0.75
0,0.5,0.5
0,0.75,0.25
0,1,0

得点

これはコードゴルフです。バイト単位の最短コードが優先されます。標準の抜け穴が適用されます。必要なビルトインを使用できます。

CJam（22バイト）

{):X),3m*{:+X=},Xdff/}

これは、Nスタックを取得し、スタックにdoubleの配列の配列を残す匿名ブロック（関数）です。オンラインデモ

解剖

{         e# Define a block
  ):X     e# Let X=N+1 be the number of segments per edge
  ),3m*   e# Generate all triplets of integers in [0, X] (inclusive)
  {:+X=}, e# Filter to those triplets which sum to X
  Xdff/   e# Normalise
}

Haskell、53バイト

f n|m<-n+1=[map(/m)[x,y,m-x-y]|x<-[0..m],y<-[0..m-x]]

Python 3、87バイト

これは、実際にはTheBikingVikingによるソリューションへのコメントであるはずですが、コメントに対する評判が十分ではありません。

変数i,jを反復処理するだけで、3番目の変数では合計するという事実を使用することで、数バイトを節約できますn+1。

def f(n):d=n+1;r=range(n+2);print([[i/d,j/d,(d-i-j)/d]for i in r for j in r if d>=i+j])

Mathematica、 44  43バイト

Select[Range[0,x=#+1]~Tuples~3/x,Tr@#==1&]&

これは、単一の整数引数を取る名前のない関数です。出力は、正確な（削減された）分数のリストのリストです。

1/(N+1)0〜1の範囲のすべての3タプルの倍数を生成し、合計が1であるものを選択します（重心座標の必要に応じて）。

05AB1E、10バイト

ÌL<¤/3ãDOÏ

説明

ÌL<          # range(1,n+2)-1
   ¤/        # divide all by last element (n+1)
     3ã      # cartesian product repeat (generate all possible triples)
       DO    # make a copy and sum the triples
         Ï   # keep triples with sum 1

オンラインで試す

MATL、17バイト

2+:qGQ/3Z^t!s1=Y)

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

説明

アプローチは他の回答と同じです：

1. 配列を生成します。[0, 1/(n+1), 2/(n+1), ..., 1]ここnで入力です。
2. これらの値ですべての3タプルを生成します。
3. 合計がであるもののみを保持し1ます。

すなわち：

2+     % Take input and add 2: produces n+2
:q     % Range [0 1 ... n+1]
GQ/    % Divide by n+1 element-wise: gives [0, 1/(n+1), 2/(n+1)..., 1]
3Z^    % Cartesian power with exponent 3. Gives (n+1)^3 × 3 array. Each row is a 3-tuple
t      % Duplicate
!s     % Sum of each row
1=     % Logical index of entries that equal 1
Y)     % Use that index to select rows of the 2D array of 3-tuples

クラゲ、37 33バイト

4バイトを節約してくれたZgarbに感謝します。

p
*%
# S
`
=E   S
`/
1+r#>>i
   3

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

MathematicaとPeterのCJamの回答のように、これは候補タプルのセットを生成し、合計が1になるタプルのみを選択します。まだレイアウトに完全には満足していません。しかし、後で調べる必要があります。

Perl 6：50 40バイト

{grep *.sum==1,[X] (0,1/($_+1)...1)xx 3}

（正確な）有理数の3要素リストのシーケンスを返します。

説明：

• $_
  ラムダの暗黙的に宣言されたパラメーター。
• 0, 1/($_ + 1) ... 1
  シーケンス演算子...を使用して、可能な座標値に対応する算術シーケンスを構築します。
• [X] EXPR xx 3
  EXPRの3つのコピーのデカルト積を取ります。つまり、考えられるすべての3タプルを生成します。
• grep *.sum == 1, EXPR
  タプルを合計1でフィルターします。

ルビー、62

これを改善できない場合、私は驚くでしょう：

->x{0.step(1,i=1.0/(x+1)){|a|0.step(1-a,i){|b|p [a,b,1-a-b]}}}

パズルに潜んでいるアドバイスを利用して、最初の2つを差し引くことで、最初のノードと3番目のノードに基づいて2番目のノードオプションを計算します。

Brachylog、24バイト

+:1f
yg:2j:eaL+?/g:Lz:*a

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

Python 3、106バイト

def f(n):r=range(n+2);print([x for x in[[i/-~n,j/-~n,k/-~n]for i in r for j in r for k in r]if sum(x)==1])

引数を介して入力を受け取り、フロートのリストのリストをSTDOUTに出力する関数。

Pythonはデカルト製品が苦手です...

使い方

def f(n):                         Function with input iteration number n
r=range(n+2)                      Define r as the range [0, n+1]
for i in r for j in r for k in r  Length 3 Cartesian product of r
[i/-~n,j/-~n,k/-~n]               Divide each element of each list in the product
                                  by n+1
[x for x in ... if sum(x)==1]     Filter by summation to 1
print(...)                           Print to STDOUT

Ideoneでお試しください

実際には、15バイト

これは、TheBikingVikingのPython answerのアルゴリズムに似たアルゴリズムを使用します。ゴルフの提案を歓迎します。オンラインでお試しください！

u;ur♀/3@∙`Σ1=`░

ゴルフをしていない：

u;                Increment implicit input and duplicate.
  ur              Range [0..n+1]
    ♀/            Divide everything in range by (input+1).
      3@∙         Take the Cartesian product of 3 copies of [range divided by input+1]
         `Σ1=`    Create function that takes a list checks if sum(list) == 1.
              ░   Push values of the Cartesian product where f returns a truthy value.

ルビー、77 74バイト

TheBikingVikingのPython answerのアルゴリズムを使用した別の回答。ゴルフの提案を歓迎します。

->n{a=[*0.step(1,i=1.0/(n+1))];a.product(a,a).reject{|j|j.reduce(&:+)!=1}}

Not that CharlesのRubyの回答に基づく別の74バイトのアルゴリズム。

->x{y=x+1;z=1.0/y;[*0..y].map{|a|[*0..y-a].map{|b|p [a*z,b*z,(y-a-b)*z]}}}

JavaScript（Firefox 30-57）、88 81バイト

n=>[for(x of a=[...Array(++n+1).keys()])for(y of a)if(x+y<=n)[x/n,y/n,(n-x-y)/n]]

浮動小数点数の配列の配列を返します。編集：3番目の座標を直接計算して7バイトを保存しました。ifの範囲をy直接計算して排除しようとしましたが、余分なバイトがかかりました：

n=>[for(x of a=[...Array(++n+1).keys()])for(y of a.slice(x))[x/n,(y-x)/n,(n-y)/n]]