टेट्राहेड्रोन भूतल क्षेत्र

Question

चुनौती

यह चुनौती बहुत सीधी है। चार 3-आयामी बिंदुओं को देखते हुए, टेट्राहेड्रोन के सतह क्षेत्र की गणना करें जो वे बनाते हैं। यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है। अतिरिक्त खामियों के साथ मानक खामियां लागू होती हैं, इस कार्य को करने के लिए चार बिंदुओं को देखते हुए कोई भी अंतर्निहित कार्य निषिद्ध है।

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

आप में से जो लोग नहीं जानते हैं, उनके लिए टेट्राहेड्रोन एक 3-डी ठोस है, जो 4 त्रिकोणीय चेहरों द्वारा बनाई गई है।

उदाहरण

# input (format is up to you, see clarification above)
[23822, 47484, 57901]
[3305, 23847, 42159]
[19804, 11366, 14013]
[52278, 28626, 52757]

# output
2932496435.95

कृपया ध्यान दें कि यदि आप ध्यान दें कि मेरा गणित गलत है।

Comments

@ BetaDecay नहीं, विचार यह है कि वे चार अलग-अलग लाइनों पर STDIN के माध्यम से इनपुट करेंगे। मैं इसे स्पष्ट करने के लिए प्रश्न को संपादित करूंगा।

— स्टोकैस्टिक

क्या इनपुट एक हो सकता है [[list],[of],[lists]]?

— फोसजेन

@phosgene मुझे लगता है कि इनपुट पढ़ना चुनौती का हिस्सा है, इसलिए मैं ना कहने वाला हूं। मैं भविष्य की चुनौतियों में इनपुट विनिर्देशों के साथ अधिक उदार बनने की कोशिश करूंगा।

— स्टोकैस्टिक

क्या यह एक नियमित या अनियमित टेट्राहेड्रॉन है?

— जेम्स विलियम्स

@JamesWilliams पोस्ट उदाहरण अनियमित है। आपके कार्यक्रम को किसी भी इनपुट को संभालना चाहिए, हालांकि नियमित टेट्राहेड्रोन सहित।

— स्टोकैस्टिक

Answer 1

पायथन, 198 178 161 चार्ट

V=eval('input(),'*4)
A=0
for i in range(4):F=V[:i]+V[i+1:];a,b,c=map(lambda e:sum((a-b)**2for a,b in zip(*e)),zip(F,F[1:]+F));A+=(4*a*b-(a+b-c)**2)**.5
print A/4

इनपुट प्रारूप प्रश्न में दिया गया है।

यह प्रत्येक चेहरे से सटे किनारों की लंबाई की गणना करता है और फिर हेरॉन के सूत्र का उपयोग करता है ।

Answer 2

मतलाब / ऑक्टेव 103

मैं मान को चर में संग्रहीत किया जाना है c। यह इस तथ्य का उपयोग करता है कि एक त्रिकोण का क्षेत्र उसके दो साइड वैक्टर के क्रॉस उत्पाद की आधी लंबाई है।

%input
[23822, 47484, 57901;
3305, 23847, 42159;
19804, 11366, 14013;
52278, 28626, 52757]



%actual code
c=input('');
a=0;
for i=1:4;
    d=c;d(i,:)=[];
    d=d(1:2,:)-[1 1]'*d(3,:);
    a=a+norm(cross(d(1,:),d(2,:)))/2;
end
a

Comments

प्रत्येक बिंदु को मानक इनपुट के रूप में एक अलग लाइन पर दर्ज किया जाना चाहिए।

— डेविड ऑक्ट

मैंने पहले सोचा था कि मतलाब में मानक इनपुट जैसी कोई चीज नहीं है, लेकिन मैंने एक फ़ंक्शन की खोज की जिसका उपयोग कमांड विंडो के माध्यम से इसे अनुकरण करने के लिए किया जा सकता है, इसलिए अब आप इनपुट को पास कर सकते हैं जैसा कि आप अन्य भाषाओं में कर सकते हैं।

— दोष

दिलचस्प। यह वही आदेश है जिसका गणितज्ञ उपयोग करता है,Input[]

— DavidC

आपको क्यों लगता है कि यह दिलचस्प है? 'इनपुट' मुझे एक फ़ंक्शन के लिए एक बहुत ही सामान्य नाम की तरह लगता है जो ऐसा करता है।

— दोष

कल तक, मैं वास्तव में नहीं पता था कि क्या "मानक इनपुट" का मतलब है, और मैंने सोचा कि मेथेमेटिका "मानक" इनपुट नहीं था, भले ही मैं नियमित रूप से इस्तेमाल किया था Input[], InputString[], Import[], और ImportString[]।

— डेविड ऑक्ट

Answer 3

एपीएल, 59

f←{+.×⍨⊃1 2-.⌽(⊂⍵)×1 2⌽¨⊂⍺}
.5×.5+.*⍨(f/2-/x),2f/4⍴x←⎕⎕⎕-⊂⎕

क्रॉस उत्पादों की गणना करके काम करता है

स्पष्टीकरण
पहली पंक्ति एक समारोह है कि दो तर्क (implicity नामित लेता है परिभाषित करता है ⍺और ⍵), परोक्ष उन्हें उम्मीद लंबाई 3 के संख्यात्मक सरणियों होने के लिए, उन्हें 3 डी वैक्टर के रूप में लेते हैं और गणना करता वर्ग उनके उत्पाद पार की भयावहता।

                        ⊂⍺   # Wrap the argument in a scalar
                   1 2⌽¨     # Create an array of 2 arrays, by rotating `⊂⍺` by 1 and 2 places
             (⊂⍵)×           # Coordinate-wise multiply each of them with the other argument
        1 2-.⌽               # This is a shorthand for:
        1 2  ⌽               #   Rotate the first array item by 1 and the second by 2
           -.                #   Then subtract the second from the first, coordinate-wise
       ⊃                     # Unwrap the resulting scalar to get the (sorta) cross product
   +.×                       # Calculate the dot product of that...
      ⍨                      # ...with itself
f←{+.×⍨⊃1 2-.⌽(⊂⍵)×1 2⌽¨⊂⍺} # Assign function to `f`

दूसरी पंक्ति बाकी काम करती है।

                         ⎕⎕⎕-⊂⎕ # Take 4 array inputs, create an array of arrays by subtracting one of them from the other 3
                       x←        # Assign that to x
                     4⍴          # Duplicate the first item and append to the end
                  2f/            # Apply f to each consecutive pair
            2-/x                 # Apply subtraction to consecutive pairs in x
          f/                     # Apply f to the 2 resulting arrays
         (f/2-/x),2f/4⍴x←⎕⎕⎕-⊂⎕ # Concatenate to an array of 4 squared cross products
   .5+.*⍨                        # Again a shorthand for:
   .5  *⍨                        #   Take square root of each element (by raising to 0.5)
     +.                          #   And sum the results
.5×                              # Finally, divide by 2 to get the answer

Comments

यदि आप सुनिश्चित नहीं हैं कि यह चित्रलिपि है या एक भ्रष्ट dll फ़ाइल है तो यह शायद APL होने वाला है। क्या आप शायद कुछ अधिक बता सकते हैं कि उनमें से कुछ प्रतीक क्या करते हैं? ऐसा नहीं है कि मैं इसे सीखना चाहता हूं, लेकिन मैं अभी भी इस बात से

— सहमत नहीं हूं

@flawr मैं आमतौर पर ऐसा इसलिए करता हूं क्योंकि एपीएल में गोल्फिंग ज्यादातर एल्गोरिदम डिजाइन के लिए नीचे आता है और सबसे अधिक समस्या के लिए एक असामान्य दृष्टिकोण में परिणाम होगा। लेकिन मुझे लगा कि "क्रॉस उत्पाद की गणना" यहां एल्गोरिदम के बारे में पर्याप्त है। यदि आप एक पूर्ण स्पष्टीकरण चाहते हैं तो मैं इसे आज बाद में करूंगा।

— 12

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

— दोष

Answer 4

अजगर 3, 308 298 292 279 258 254

from itertools import*
def a(t,u,v):w=(t+u+v)/2;return(w*(w-t)*(w-u)*(w-v))**.5
z,x,c,v,b,n=((lambda i,j:(sum((i[x]-j[x])**2for x in[0,1,2]))**.5)(x[0],x[1])for*x,in combinations([eval(input())for i in">"*4],2))
print(a(z,x,v)+a(z,c,b)+a(b,v,n)+a(x,c,n))

यह उपयोग करता है:

• पायथागॉरियन प्रमेय (3 डी में) प्रत्येक पंक्ति की लंबाई बाहर काम करने के लिए
• बगुला का सूत्र प्रत्येक त्रिकोण के क्षेत्र में काम करता है

Comments

मैंने अपने समाधान के परीक्षण के लिए उसी विधि का उपयोग किया। मुझे गोल्फ की कोशिश करनी होगी और बाद में इसे पोस्ट करना होगा।

— स्टोकैस्टिक

आपका for i in">"*4चालाक है

— स्टोकैस्टिक

आप अपने रेंज फ़ंक्शन में लेन (i) का उपयोग करने के बजाय 3 की लंबाई कोड कर सकते हैं।

— स्टोकैस्टिक

आप x**0.5इसके बजाय वर्गमूल के रूप में कर रहे कुछ और पात्रों को बचा सकते हैं math.sqrt(x)।

— स्नोरफॉर्पलागस

आप दो बाइट्स def a(t,u,v)को एक लाइन पर रख कर बचा सकते हैं जैसे def a(t,u,v):w=(t+u+v)/2;return(w*(w-t)*(w-u)*(w-v))**0.5:।

— बीटा डेके

Answer 5

गणितज्ञ 168 154

यह टेट्राहेड्रोन के किनारों की लंबाई का पता लगाता है और चेहरे के क्षेत्रों को निर्धारित करने के लिए हेरॉन के सूत्र का उपयोग करता है ।

t = Subsets; p = Table[Input[], {4}];
f@{a_, b_, c_} := Module[{s = (a + b + c)/2}, N[Sqrt[s (s - #) (s - #2) (s -#3)] &[a, b, c], 25]]
  Tr[f /@ (EuclideanDistance @@@ t[#, {2}] & /@ t[p, {3}])]

---

एक अधिक प्रत्यक्ष मार्ग है जिसमें केवल 60 वर्णों की आवश्यकता होती है , लेकिन यह नियमों के उल्लंघन का उल्लंघन करता है क्योंकि यह प्रत्येक चेहरे के क्षेत्र को एक अंतर्निहित फ़ंक्शन के साथ गणना करता है Area:

p = Table[Input[], {4}];
N[Tr[Area /@ Polygon /@ Subsets[p, {3}]], 25]

Answer 6

ऋषि - 103

print sum((x*x*y*y-x*y*x*y)^.5for x,y in map(differences,Combinations(eval('vector(input()),'*4),3)))/2

इनपुट-रीडिंग भाग कीथ रान्डेल के उत्तर से अनुकूलित है ।

Answer 7

अजगर - 260

मुझे यकीन नहीं है कि आपके खुद के सवालों के जवाब पोस्ट करने पर शिष्टाचार क्या है, लेकिन उसका समाधान मेरा है, जिसे मैं अपने उदाहरण, गोल्फ के लिए सत्यापित करता था:

import copy,math
P=[input()for i in"1234"]
def e(a, b):return math.sqrt(sum([(b[i]-a[i])**2 for i in range(3)]))
o=0
for j in range(4):p=copy.copy(P);p.pop(j);a,b,c=[e(p[i],p[(i+1)%3])for i in range(3)];s=(a+b+c)/2;A=math.sqrt(s*(s-a)*(s-b)*(s-c));o+=A
print o

यह उसी प्रक्रिया का उपयोग करता है जैसे लॉरेंसव्स।

Comments

अंगूठे के नियम के रूप में, अपने स्वयं के प्रश्न का उत्तर देने से पहले कुछ दिन इंतजार करना सबसे अच्छा विचार है, खासकर अगर आपका स्कोर कम है, ताकि दर्शकों की प्रेरणा शांत न हो।

— ब्लैकहोल

कुछ सुझाव: आप कुछ पात्रों को बचा सकते हैं r=range। lambdaसे छोटा है def। math.sqrtद्वारा प्रतिस्थापित किया जा सकता है (…)**.5। p=copy.copy(P);p.pop(j);को छोटा किया जा सकता है p=P[:j-1]+P[j:]। Aकेवल एक बार उपयोग किया जाता है।

— Wrzlprmft

Answer 8

सी, 303

अनावश्यक व्हाट्सएप को छोड़कर। हालांकि, यहां अभी भी बहुत सारे गोल्फिंग होने हैं (मैं वापस आने की कोशिश करूंगा और बाद में करूंगा।) यह पहली बार है जब मैंने forलूप घोषित किया है #define। मैंने हमेशा पहले लूप की संख्या को कम करने के तरीके ढूंढे हैं।

मुझे परीक्षण मामले के लिए ओपी के समान उत्तर प्राप्त floatकरने के doubleलिए से बदलना पड़ा । इससे पहले, यह 300 का दौर था।

scanf वही काम करता है चाहे आप अपने इनपुट को स्पेस या न्यूलाइन्स से अलग करते हों, इसलिए आप इसे जितनी चाहें उतने या कुछ लाइनों में प्रारूपित कर सकते हैं।

#define F ;for(i=0;i<12;i++)
#define D(k) (q[i]-q[(i+k)%12])
double q[12],r[12],s[4],p,n;

main(i){
  F scanf("%lf",&q[i])
  F r[i/3*3]+=D(3)*D(3),r[i/3*3+1]+=D(6)*D(6)
  F r[i]=sqrt(r[i])
  F i%3||(s[i/3]=r[(i+3)%12]/2),s[i/3]+=r[i]/2
  F i%3||(p=s[i/3]-r[(i+3)%12]),p*=s[i/3]-r[i],n+=(i%3>1)*sqrt(p)   
  ;printf("%lf",n);       
}