मानक समबाहु त्रिभुज पर विचार करें, जिसमें नोड्स के साथ बेरेंट्रिक निर्देशांक का उपयोग किया गया है :

हम 3 कोने की एक नई लाइन जोड़ कर (एक से अधिक मूल 3 नोड त्रिकोण का एक पक्ष पर मौजूद था), किसी भी आंतरिक किनारों (लेकिन निकालें एक 6 नोड त्रिकोण में यह 3 नोड त्रिकोण बदल सकते हैं नहीं आंतरिक नोड्स) और फिर निर्देशांक को सामान्य करें:

6 नोड त्रिकोण से 10 नोड त्रिकोण तक जाने की प्रक्रिया को दोहराते हुए, 4 वर्टीकल की रेखा जोड़ें (फिर से, मूल 6 नोड त्रिकोण के एक तरफ एक से अधिक मौजूद था), किसी भी आंतरिक किनारों को हटा दें (लेकिन आंतरिक नोड नहीं ) ) और निर्देशांक को फिर से सामान्य करें:

इस प्रक्रिया को अनिश्चित काल तक दोहराया जा सकता है। इस चुनौती के लक्ष्य को एक पूर्णांक Nदिया गया है, जिसमें यह दर्शाया गया है कि इस प्रक्रिया को कितनी बार किया गया है, बायोरिएंटिक निर्देशांक में संबंधित त्रिकोण के लिए सभी नोड्स को आउटपुट करता है।

इनपुट

आपके प्रोग्राम / फ़ंक्शन को एक एकल गैर-नकारात्मक पूर्णांक इनपुट के रूप में लेना चाहिए, जो यह Nदर्शाता है कि यह प्रक्रिया कितनी बार लागू की गई है। ध्यान दें कि N=0, आपको मूल नोड को 3 नोड्स के साथ आउटपुट करना चाहिए।

इनपुट किसी भी स्रोत (फ़ंक्शन पैरामीटर, stdio, आदि) से आ सकता है।

उत्पादन

आपके प्रोग्राम / फ़ंक्शन को सामान्यीकृत बेरेंट्रिक निर्देशांक में सभी नोड्स का उत्पादन करना चाहिए। नोड्स का क्रम मायने नहीं रखता है। एक संख्या को एक अंश के रूप में निर्दिष्ट किया जा सकता है (अंश में कमी की आवश्यकता नहीं) या एक अस्थायी बिंदु संख्या। आप नोड निर्दिष्ट करने के लिए "स्केल्ड" वैक्टर का उत्पादन भी कर सकते हैं। उदाहरण के लिए, निम्न आउटपुट के सभी 3 समतुल्य और अनुमत हैं:

0.5,0.5,0

1/2,2/4,0

[1,1,0]/2

फ्लोटिंग पॉइंट आउटपुट का उपयोग करते समय, आपका आउटपुट 1% के भीतर सटीक होना चाहिए। आउटपुट वांछित (stdio, रिटर्न वैल्यू, रिटर्न पैरामीटर, आदि) किसी भी सिंक के लिए हो सकता है। ध्यान दें कि भले ही barycentric निर्देशांक केवल 2 संख्या प्रति नोड द्वारा निर्धारित किए गए हों, आपको सभी 3 नंबर प्रति नोड आउटपुट करना चाहिए।

उदाहरण

उदाहरण मामलों के रूप में स्वरूपित हैं:

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

जहां पहली पंक्ति इनपुट है 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

स्कोरिंग

यह कोड गोल्फ है; बाइट्स में सबसे छोटा कोड जीतता है। मानक खामियां लागू होती हैं। आप किसी भी अंतर्निहित इन्स का उपयोग कर सकते हैं।

code-golf geometry

— helloworld922
स्रोत

आप कहते हैं " यदि फ्लोटिंग पॉइंट आउटपुट का उपयोग कर रहे हैं "। क्या विकल्प हैं? भिन्न? यदि हां, तो क्या उन्हें कम करना होगा? कैसे स्केल किए गए वैक्टर के बारे में [1,2,3]/6?

— पीटर टेलर

हां, उन सभी विकल्पों की अनुमति है। मैं समस्या कथन को अद्यतन करूँगा।

— helloworld922

7

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
}

— पीटर टेलर
स्रोत

6

हास्केल, 53 बाइट्स

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

— डेमियन
स्रोत

5

पायथन 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])

— Elvorfirilmathredia
स्रोत

4

गणितज्ञ, ४४ ४३ बाइट्स

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

यह एक एकल पूर्णांक तर्क लेने वाला एक अनाम कार्य है। आउटपुट सटीक (कम) अंशों की सूची की एक सूची है।

1/(N+1)समावेशी 0 और 1 के बीच के गुणकों के सभी 3-टुपल्स उत्पन्न करता है, और फिर उन लोगों का चयन करता है जिनकी राशि 1 है (जैसा कि बैरिएट्रिक निर्देशांक द्वारा आवश्यक है)।

— मार्टिन एंडर
स्रोत

4

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

इसे ऑनलाइन आज़माएं

— Emigna
स्रोत

चूंकि ¤सरणी का उपभोग करता है, इसलिए /उस सरणी को विभाजित क्यों करता है? क्या यह "याद" करता है कि अंतिम पॉपप मूल्य और जरूरत पड़ने पर इसका उपयोग करता है?

— लुइस मेंडो

@LuisMendo: ¤कुछ आदेशों में से एक है जो स्टैक से पॉप और उपभोग नहीं करता है। यह सूची के अंतिम तत्व को स्टैक पर सूची को छोड़ते समय धक्का देता है।

— Emigna

हम्म? ऐसा प्रतीत नहीं होता है

— लुइस मेंडो

@LuisMendo 05AB1E केवल एक कार्यक्रम के अंत में स्टैक के शीर्ष पर आउटपुट करता है ।

— एमिगा

ओह बेशक! स्पष्टीकरण के लिए धन्यवाद

— लुइस मेंडो

3

MATL , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

दृष्टिकोण अन्य उत्तरों की तरह ही है:

सरणी उत्पन्न करें [0, 1/(n+1), 2/(n+1), ..., 1], जहां nइनपुट है;
उन मूल्यों के साथ सभी 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

— लुइस मेंडो
स्रोत

1

जेलिफ़िश , 37 33 बाइट्स

4 बाइट बचाने के लिए ज़गरब को धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

मेरे गणितज्ञ और पीटर के सीजम के जवाबों की तरह, यह उम्मीदवार टुपल्स का एक सेट उत्पन्न करता है और फिर केवल उन योगों का चयन करता है, जिनका योग 1 से है। मैं अभी तक लेआउट से पूरी तरह से खुश नहीं हूं, और मुझे आश्चर्य है कि क्या मैं हुक या स्याही के साथ कुछ बाइट्स बचा सकता हूं, लेकिन मुझे उस पर गौर करना होगा।

— मार्टिन एंडर
स्रोत

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-ट्यूपल्स उत्पन्न करता है।
grep *.sum == 1, EXPR
1 के योग के साथ नलिकाओं को फ़िल्टर करें।

— SMLS
स्रोत

1

रूबी, ६२

मुझे आश्चर्य होगा अगर इस पर सुधार नहीं किया जा सकता है:

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

पहेली में अव्यक्त सलाह लेते हुए, यह पहले के आधार पर दूसरे नोड विकल्पों की गणना करता है, और पहले दो को घटाकर तीसरा नोड।

— चार्ल्स नहीं
स्रोत

1

ब्रेकीलॉग , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

0

पायथन 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 में प्रिंट करते हैं।

अजगर कार्टेसियन उत्पादों में अच्छा नहीं है ...

यह काम किस प्रकार करता है

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 पर इसे आज़माएं

— TheBikingViking
स्रोत

0

दरअसल , 15 बाइट्स

यह TheBikingViking के पायथन उत्तर में एक के समान एल्गोरिथ्म का उपयोग करता है । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

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

Ungolfed:

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.

— Sherlock9
स्रोत

0

रूबी, 77 74 बाइट्स

TheBikingViking के पायथन उत्तर में एल्गोरिथ्म का उपयोग करते हुए एक और उत्तर । गोल्फ सुझाव का स्वागत करते हैं।

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

एक और 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]}}}

— Sherlock9
स्रोत

0

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 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]]

— नील
स्रोत

आखिर में आपने लिखा [x/n,y/n/z/n], क्या आप अल्पविराम भूल गए?

— kamoroso94

@ kamoroso94 आप सही हैं, मैंने अंतिम अल्पविराम टाइप किया, मुझे बताने के लिए धन्यवाद।

— नील

मेरे त्रिकोण को अधिक नोड्स की आवश्यकता है

इनपुट

उत्पादन

उदाहरण

स्कोरिंग

CJam (22 बाइट्स)

विच्छेदन

हास्केल, 53 बाइट्स

पायथन 3, 87 बाइट्स

गणितज्ञ, ४४ ४३ बाइट्स

05AB1E , 10 बाइट्स

MATL , 17 बाइट्स

व्याख्या

जेलिफ़िश , 37 33 बाइट्स

पर्ल 6: 50 40 बाइट्स

रूबी, ६२

ब्रेकीलॉग , 24 बाइट्स

पायथन 3, 106 बाइट्स

दरअसल , 15 बाइट्स

रूबी, 77 74 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 88 81 बाइट्स