barycentric 좌표를 사용하여 레이블이 지정된 노드가있는 표준 정삼각형을 고려하십시오 .

우리는 (하나의 원래 3 노드 삼각형 측에 존재보다 더), 내부 에지 (단, 삭제 (3 개)의 정점의 새로운 라인을 추가하여 6 노드를 삼각형으로이 3 노드 삼각형을 켤 수 없는 내부 노드) 및 재 좌표를 정규화하십시오.

10 노드 삼각형 6 노드 삼각형에서 이동하는 과정을 반복하여, 4 개 정점 (다시, 하나는 원래 6 노드 삼각형 측에 존재보다 더), 내부 에지 (단, 삭제 라인을 추가 하지 내부 노드 ) 좌표를 다시 정규화하십시오.

이 과정은 무한정 반복 될 수 있습니다. 이 과제의 목표는이 N프로세스가 몇 번 수행되었는지 나타내는 정수를 제공하며 , 관련 삼각형에 대한 모든 노드를 무게 중심 좌표로 출력합니다.

입력

프로그램 / 함수는 N이 프로세스가 몇 번 적용되었는지 나타내는 음이 아닌 단일 정수를 입력 으로 가져와야합니다. 의 경우 N=03 개의 노드가있는 원래 삼각형을 출력해야합니다.

입력은 모든 소스 (기능 매개 변수, stdio 등)에서 올 수 있습니다.

산출

프로그램 / 기능은 모든 노드를 정규화 된 무게 중심 좌표로 출력해야합니다. 노드의 순서는 중요하지 않습니다. 숫자는 분수 (분수 감소가 필요하지 않음) 또는 부동 소수점 숫자로 지정할 수 있습니다. "스케일 된"벡터를 출력하여 노드를 지정할 수도 있습니다. 예를 들어, 다음 출력 중 3 개가 모두 동일하며 허용됩니다.

0.5,0.5,0

1/2,2/4,0

[1,1,0]/2

부동 소수점 출력을 사용하는 경우 출력은 1 % 이내로 정확해야합니다. 출력은 원하는 싱크 (stdio, return value, return parameter 등) 일 수 있습니다. 무게 중심 좌표는 노드 당 2 개의 숫자만으로 고유하게 결정되지만 노드 당 3 개의 숫자를 모두 출력해야합니다.

예

사례의 형식은 다음과 같습니다.

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

여기서 첫 번째 라인은 input N이고, 다음 라인은 모두 x,y,z정확히 한 번 출력에 있어야 하는 노드 를 형성합니다 . 모든 숫자는 대략적인 부동 소수점 숫자로 제공됩니다.

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스택 을 차지하고 스택에 이중 배열을 남깁니다. 온라인 데모

해부

{         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
}

하스켈, 53 바이트

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

파이썬 3, 87 바이트

이것은 실제로 TheBikingViking의 솔루션에 대한 의견 이어야 하지만 의견에 대한 평판이 충분하지 않습니다.

변수를 반복 i,j하고 세 번째 변수를 합하면 몇 바이트 만 절약 할 수 있습니다 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])

매스 매 티카,  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에 해당하는 튜플을 선택합니다. 나는 레이아웃에 완전히 만족하지 않고 후크 또는 포크로 일부 바이트를 저장할 수 있는지 궁금합니다. 하지만 나중에 살펴 봐야합니다.

펄 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]}}}

퍼즐에서 잠복 한 조언을 받아 첫 두 노드를 빼고 두 번째 노드 옵션을 계산합니다.

Brachylog , 24 바이트

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

온라인으로 사용해보십시오!

파이썬 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])

함수는 인수를 통해 입력을 받아 float 목록을 STDOUT에 인쇄합니다.

파이썬은 데카르트 제품을 잘하지 않습니다 ...

작동 원리

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

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]}}}

자바 스크립트 (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]]

부동 소수점 숫자의 배열로 구성된 배열을 반환합니다. 편집 : 세 번째 좌표를 직접 계산하여 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]]