एक एन-डायमेंशनल सिम्पलेक्स (टेट्राहेड्रॉन) बनाएं

Question

सबसे सरल एन-डाइमेंशनल शेप जो किसी भी आयाम के लिए बना सकता है , वह एक सिम्प्लेक्स है , और यह एन + 1 बिंदुओं का एक सेट है जो प्रत्येक अभिभावक से सभी समान दूरी पर हैं।

2 आयामों के लिए, यह एक समबाहु त्रिभुज है, 3 आयामों के लिए, यह एक नियमित टेट्राहेड्रॉन है, 4 आयामों पर 5-सेल और इतने पर है।

चुनौती

इनपुट के रूप में एक इंटीग्रेटर आयाम एन को देखते हुए, एक एरियर / सूची / स्टैक / जो भी एन डायमेंशनल अंक का उत्पादन करता है, जो इस आयाम के एक सिम्प्लेक्स का प्रतिनिधित्व करता है। यही है, एन + 1 वर्टेक्स जो प्रत्येक अभिभावक से समान और गैर-शून्य दूरी है।

लुआ में संदर्भ कार्यान्वयन

उदाहरण

1 -> [[0], [1]]
2 -> [[0, 0], [1, 0], [0.5, 0.866...]]
4 -> [[0, 0, 0, 0], [1, 0, 0, 0], [0.5, 0.866..., 0, 0], [0.5, 0.288..., 0.816..., 0], [0.5, 0.288..., 0.204..., 0.790...]]

टिप्पणियाँ

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

Comments

आपको एहसास है कि आप जवाब नहीं दे सकते हार्डकोड नहीं? इससे बचने का सबसे सरल तरीका है इनपुट की सीमा बढ़ाना। साथ ही "वैध मानदंड वस्तुनिष्ठ होना चाहिए", उचित वस्तुनिष्ठ नहीं है।

— user202729

ऐसा लगता है कि इसे पहचान मैट्रिक्स और एक अतिरिक्त वेक्टर के साथ हल किया जा सकता है जिनकी प्रविष्टियां सभी समान हैं।

— xnor

@xnor ने किया;)

— पट्टुएक्स

Answer 1

जेली , 11 बाइट्स

‘½‘÷ẋW
=þ;Ç

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

को उत्पन्न करती है पहचान मैट्रिक्स आकार के एन और दोहरा द्वारा उत्पन्न की सूची के साथ यह श्रृंखलाबद्ध एन बार सिंगलटन √ (N + 1) + 1 , से विभाजित एन ।

‘½‘÷ẋW – Helper link (monadic). I'll call the argument N.

‘      – Increment N (N + 1).
 ½     – Square root.
  ‘    – Increment (√(N + 1) + 1).
   ÷   – Divide by N.
    ẋ  – Repeat this singleton list N times.
     W – And wrap that into another list.

––––––––––––––––––––––––––––––––––––––––––

=þ;Ç   – Main link.

=þ     – Outer product of equality.
  ;Ç   – Concatenate with the result given by the helper link applied to the input.

Answer 2

पायथन 78 66 बाइट्स

lambda n:[i*[0]+[n]+(n+~i)*[0]for i in range(n)]+[n*[1+(n+1)**.5]]

निश्चित रूप से सुधार किया जा सकता है, खासकर n = 1``` को संभालने में। (यह कैसे एक साधारण भी है?) बस एहसास हुआ कि यह आवश्यक नहीं है। शायद अभी भी ^ ^ में सुधार किया जा सकता है

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

[i*[0]+[1]+(n+~i)*[0]for i in range(n)]पहचान मैट्रिक्स बनाता है। सभी बिंदुओं में sqrt(2)एक दूसरे से दूरी है। (सुधार के लिए रॉड का धन्यवाद)

अब हमें n+1अन्य सभी बिंदुओं के लिए समान दूरी के साथ एक वें बिंदु की आवश्यकता है । हमें चुनना है (x, x, ... x)।

से दूरी (1, 0, ... )के लिए (x, x, ... x)है sqrt((x-1)²+x²+...+x²)। यदि हम एक nआयामी सिम्प्लेक्स चाहते हैं sqrt((x-1)²+(n-1)x²), तो यह पहले बिंदु पर एक 1और n-1 0एस है। थोड़ा सरल करें:sqrt(x²-2x+1+(n-1)x²) = sqrt(nx²-2x+1)

हम चाहते हैं कि यह दूरी बनी रहे sqrt(2)।

sqrt(2) = sqrt(nx²-2x+1)
2 = nx²-2x+1
0 = nx²-2x-1
0 = x²-2/n*x+1/n

इस द्विघात समीकरण को हल करना (एक समाधान, अन्य एक भी ठीक काम करता है):

x = 1/n+sqrt(1/n²+1/n) = 1/n+sqrt((n+1)/n²) = 1/n+sqrt(n+1)/n = (1+sqrt(n+1))/n

सूची nसमय में रखें , उस सूची को सूची में रखें और पहचान मैट्रिक्स के साथ जुड़ें।

---

-4 एलेक्स वर्गा को बाइट्स धन्यवाद:

प्रत्येक वेक्टर को गुणा करें n। इससे पहचान मैट्रिक्स के निर्माण lambda n:[i*[0]+[n]+(n+~i)*[0](एक ही लंबाई) में परिवर्तन होता nहै और अतिरिक्त बिंदु से विभाजन से छुटकारा मिलता है , इसलिए यह n*[1+(n+1)**.5]दो कोष्ठक और बचत करता है /n।

Comments

हालांकि इस चुनौती के दायरे में नहीं, 0 आयामी सिम्प्लेक्स भी एक चीज है, जितना भयानक हो सकता है।

— अताको

थोड़ा और पढ़ने के बाद, क्या हर जोड़ी अलग-अलग संख्याओं को 1-सिम्प्लेक्स नहीं बनाती है?

— पट्टुएक्स

हां, ऐसी सरलता की कष्टप्रद शक्ति है

— ATaco

आप 8 बाइट्स को बचाने के लिए पहचान मैट्रिक्स को बनाने के तरीके में बदलाव कर सकते हैं

— रॉड

66 टिप्पणियाँ पिछले टिप्पणियों के संयोजन

— एलेक्स Varga

Answer 3

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

IdentityMatrix@#~Join~{Table[1-(#+1)^.5,#]/#}&

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

Answer 4

APL (Dyalog) , 20 18 बाइट्स

1 बाइट @ngn को धन्यवाद

∘.=⍨∘⍳⍪1÷¯1+4○*∘.5

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

Comments

(∘.=⍨⍳)->∘.=⍨∘⍳

— ngn

@ मैं इस गोल्फ स्टैंड पर खड़ा हूं, मैं इंतजार कर रहा था कि क्या मैं इसे देखने से पहले कुछ और बाइट्स गोल्फ कर सकता हूं क्योंकि एडिटिंग पोस्ट्स में मोबाइल का उपयोग करने में बहुत दर्द होता है

— Uriel

मैंने इसे आपके लिए संपादित करने की स्वतंत्रता ली है। मुझे भी संदेह है कि एक बेहतर उत्तर हो सकता है - यह मुझे याद दिलाता है ⌹लेकिन मैं यह पता नहीं लगा सकता कि यह कैसे काम कर सकता है ...

— ngn

मैट्रिक्स विभाजन फलहीन था, लेकिन मुझे एक दिलचस्प परिपत्र फ़ंक्शन मिला:{÷¯1+4○⍵*.5}⍪⍳∘.=⍳

— ngn

@ धन्यवाद। मैंने उसी गणना के लिए आपके समाधान का एक टैसीट संस्करण प्रयोग किया है

— उरेल

Answer 5

जावास्क्रिप्ट (ईएस 7), 70 बाइट्स

n=>[a=Array(n++).fill((1+n**.5)/--n),...a.map((_,i)=>a.map(_=>+!i--))]

पोर्ट ऑफ @ पट्टु का पायथन उत्तर।

Answer 6

वोल्फ्राम भाषा (गणितज्ञ), 205 बाइट्स

f1 = Sqrt[# (# + 1)/2]/# /(# + 1) & ;
f2 = Sqrt[# (# + 1)/2]/# & ;
simplex[k_] := {ConstantArray[0, k]}~Join~Table[
   Table[f1[n], {n, 1, n - 1}]~Join~{f2[n]}~Join~
    ConstantArray[0, k - n],
   {n, k}]

माथेमेटिका में सिम्पलेक्स फंक्शन {0,0,...]},{1,0,0,...]}, शुरुआत से पहले, मूल पर पहला बिंदु, xअक्ष पर दूसरा बिंदु x,y, विमान में तीसरा बिंदु , x,y,zअंतरिक्ष में चौथा बिंदु , आदि। यह प्रगति पिछले सभी बिंदुओं का पुन: उपयोग करती है, एक समय में एक नए बिंदु को नए आयाम में जोड़ते हुए

simplex[6]={{0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {1/2, Sqrt[3]/2, 0, 0, 0, 
  0}, {1/2, 1/(2 Sqrt[3]), Sqrt[2/3], 0, 0, 0}, {1/2, 1/(2 Sqrt[3]), 
  1/(2 Sqrt[6]), Sqrt[5/2]/2, 0, 0}, {1/2, 1/(2 Sqrt[3]), 1/(
  2 Sqrt[6]), 1/(2 Sqrt[10]), Sqrt[3/5], 0}, {1/2, 1/(2 Sqrt[3]), 1/(
  2 Sqrt[6]), 1/(2 Sqrt[10]), 1/(2 Sqrt[15]), Sqrt[7/3]/2}}

सत्यापन

In[64]:= EuclideanDistance[simplex[10][[#[[1]]]],simplex[10][[#[[2]]]]] & /@ Permutations[Range[10],{2}]//Simplify
Out[64]= {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}

Comments

साइट पर आपका स्वागत है! 1) यह एक कोड गोल्फ है, आपको अपने कोड को यथासंभव छोटा बनाने का लक्ष्य रखना चाहिए। 2) कृपया अपने पद को यथासंभव पठनीय बनाने के लिए मार्कडाउन का उपयोग करें ।

— caird coinheringaahing

Answer 7

ऑक्टेव , 31 बाइट्स

लुइस मेंडो के लिए धन्यवाद 2 बाइट्स सहेजे गए ।

@(n)[n*eye(n);~~(1:n)+(n+1)^.5]

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

Comments

आप की जगह ले सकता ones(1,n)द्वारा~~(1:n)

— लुइस Mendo

Answer 8

रूबी , 55 बाइट्स

सभी आयामों के लिए समान परिमाण वापस करने के बजाय और सूत्र को सरल बनाने (1+(n+1)**0.5)/nके nलिए मैं एक कारक द्वारा सूत्र का उपयोग करता हूं(1+(n+1)**0.5)

->n{(a=[n]+[0]*~-n).map{a=a.rotate}+[[1+(n+1)**0.5]*n]}

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

परीक्षण कार्यक्रम में अपुष्ट

एक लंबोदर फ़ंक्शन nएक तर्क के रूप में ले रहा है और सरणियों की एक सरणी लौटा रहा है।

f=->n{
  (a=[n]+[0]*~-n).map{        #setup an array `a` containing `n` and `n-1` zeros. perform `n` iterations (which happens to be the the size of the array.)
  a=a.rotate}+                #in each iteration rotate `a` and return an array of all possible rotations of array `a`     
  [[1+(n+1)**0.5]*n]          #concatenate an array of n copies of 1+(n+1)**0.5
}

p f[3]                        # call for n=3 and print output

उत्पादन

[[0, 0, 3], [0, 3, 0], [3, 0, 0], [3.0, 3.0, 3.0]]

Answer 9

परी / जीपी , 37 बाइट्स

n->concat((n+1)^.5-matid(n),1^[1..n])

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

Answer 10

आर , 38 बाइट्स

function(n)rbind(diag(n,n),1+(n+1)^.5)

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