एक पूर्णांक के qololume

Question

यह प्राचीन ज्ञान है कि प्रत्येक गैर-नकारात्मक पूर्णांक को चार वर्ग पूर्णांक के योग के रूप में फिर से लिखा जा सकता है। उदाहरण के लिए संख्या 1 को $0^2+0^2+0^2+1^2$ रूप में व्यक्त किया जा सकता है । या, सामान्य रूप से, किसी भी गैर-नकारात्मक पूर्णांक $n$ , पूर्णांक मौजूद हैं ऐसा$a,b,c,d$

$$n = a^2+b^2+c^2+d^2$$

1700 के दशक में जोसेफ-लुई लग्रगे ने इसे साबित किया और इसलिए इसे अक्सर लाग्रेंज का प्रमेय कहा जाता है ।

यह कभी-कभी चतुर्भुज के संबंध में चर्चा की जाती है - 1800 के दशक में विलियम हैमिल्टन द्वारा खोजे गए एक प्रकार की संख्या , जिसे रूप में दर्शाया गया है जहां वास्तविक संख्याएँ हैं, और और विशिष्ट काल्पनिक इकाइयाँ हैं जो नहीं करती हैं। विशेष रूप से, यह चतुर्धातुक प्रत्येक घटक संबंध में चर्चा की गई है। इस मात्रा को कभी-कभी आदर्श, या वर्ग मान या चतुर्भुज भी कहा जाता है । लैग्रेंज के प्रमेय के कुछ आधुनिक प्रमाण चतुष्कोणों का उपयोग करते हैं।

$$w+x\textbf{i}+y\textbf{j}+z\textbf{k}$$ $w,x,y,z$$\textbf{i}, \textbf{j}$$\textbf{k}$ $$w^2+x^2+y^2+z^2$$

रुडोल्फ लिप्सचित्ज़ ने केवल पूर्णांक घटकों के साथ चतुर्धातुक का अध्ययन किया, जिसे लिप्सचित्ज़ चतुर्भुज कहा जाता है। क्वाडरेन्स का उपयोग करते हुए, हम कल्पना कर सकते हैं कि हर लिप्सकिटज़ क्वाटर्नियन को पूर्णांकों में एक दोस्त होने के बारे में सोचा जा सकता है। उदाहरण के लिए चतुर्भुज को पूर्णांक संबंधित माना जा सकता है । इसके अलावा, अगर हम पीछे की ओर जाते हैं, तो हर पूर्णांक को लिप्सकिटज़ क्वाटर्न्स में एक दोस्त होने के रूप में सोचा जा सकता है।$0+0\textbf{i}+0\textbf{j}+1\textbf{k}$$1=0^2+0^2+0^2+1^2$

लेकिन लैग्रेंज के प्रमेय का एक दिलचस्प विवरण है - योग अद्वितीय नहीं है। प्रत्येक पूर्णांक में चार वर्गों के कई अलग-अलग सेट हो सकते हैं जो इसे बनाने के लिए अभिव्यक्त किए जा सकते हैं। उदाहरण के लिए, नंबर 1 को गैर-नकारात्मक पूर्णांक का उपयोग करके 4 तरीकों से व्यक्त किया जा सकता है (आइए इस चुनौती के लिए केवल गैर-नकारात्मक पर विचार करें): 1 = 1 ^ 2 + 0 ^ 2 + 0 ^ 2 + 0 ^ 2 + 2

$$1=0^2+0^2+0^2+1^2$$ $$1=0^2+0^2+1^2+0^2$$ $$1=0^2+1^2+0^2+0^2$$ $$1=1^2+0^2+0^2+0^2$$

सारांश हमेशा 0, या 1 के वर्ग होते हैं, लेकिन वे अभिव्यक्ति में विभिन्न पदों पर हो सकते हैं।

इस चुनौती के लिए, हम डुप्लिकेट को खत्म करने के लिए अपनी समन को सबसे कम "उच्चतम" करें, ताकि हम इस अभ्यास के लिए विचार कर सकें, कि 1 में केवल चार वर्गों के योग के रूप में प्रतिनिधित्व किया जा सकता है:

$$1=0^2+0^2+0^2+1^2$$

एक अन्य उदाहरण संख्या 42 है, जिसे चार तरीकों से व्यक्त किया जा सकता है (फिर से, केवल गैर-नकारात्मक a, b, c, d और डुप्लिकेट घटक व्यवस्था को समाप्त करने पर विचार)

$$42=0^2+1^2+4^2+5^2$$ $$42=1^2+1^2+2^2+6^2$$ $$42=1^2+3^2+4^2+4^2$$ $$42=2^2+2^2+3^2+5^2$$

क्या होगा अगर हम एक विशिष्ट चतुर्भुज से जुड़े होने के रूप में पूर्णांक व्यक्त करने के इन विभिन्न तरीकों में से प्रत्येक की कल्पना करते हैं? तब हम कह सकते हैं कि संख्या ४२ इन चार चतुर्भुजों से जुड़ी है:

$$0+1\textbf{i}+4\textbf{j}+5\textbf{k}$$ $$1+1\textbf{i}+2\textbf{j}+6\textbf{k}$$ $$1+3\textbf{i}+4\textbf{j}+4\textbf{k}$$ $$2+2\textbf{i}+3\textbf{j}+5\textbf{k}$$

यदि हम एक चतुर्भुज की मानक कंप्यूटर ग्राफिक्स व्याख्या की कल्पना करते हैं, जहां $\textbf{i}$ , $\textbf{j}$ और $\textbf{k}$ तीन आयामी यूक्लिडियन अंतरिक्ष में वैक्टर हैं , और इसलिए क्वाटर्नियन के $x$ , $y$ और $z$ घटक 3 आयामी कार्टेशियन निर्देशांक हैं, तो हम कल्पना कर सकते हैं कि प्रत्येक पूर्णांक, इस विचार प्रक्रिया के माध्यम से, अंतरिक्ष में 3 आयामी निर्देशांक के एक सेट के साथ जोड़ा जा सकता है। उदाहरण के लिए, संख्या 42 निम्नलिखित चार $(x,y,z)$ साथ जुड़ी है निर्देशांक:

$$(1,4,5),(1,2,6),(3,4,4),(2,3,5)$$

यह एक बिंदु बादल, या अंतरिक्ष में बिंदुओं के एक सेट के रूप में सोचा जा सकता है। अब, अंतरिक्ष में परिमित बिंदुओं के एक सेट के बारे में एक दिलचस्प बात यह है कि आप हमेशा उनके चारों ओर एक न्यूनतम बाउंडिंग बॉक्स खींच सकते हैं - एक बॉक्स जो सभी बिंदुओं को फिट करने के लिए पर्याप्त बड़ा है, लेकिन कोई बड़ा नहीं है। यदि आप $x,y,z$ axes के साथ संरेखित एक साधारण बॉक्स के रूप में बॉक्स की कल्पना करते हैं , तो इसे अक्ष-संरेखित बाउंडिंग बॉक्स कहा जाता है । बाउंडिंग बॉक्स में एक वॉल्यूम भी है, जो इसकी चौड़ाई, लंबाई और ऊंचाई का निर्धारण करके और उन्हें एक साथ गुणा करके गणना योग्य है।

फिर हम अपने चतुर्भुज द्वारा गठित बिंदुओं के लिए एक बाउंडिंग बॉक्स की मात्रा की कल्पना कर सकते हैं। पूर्णांक 1 के लिए, हमारे पास इस अभ्यास के मानदंडों का उपयोग करते हुए, एक चतुष्कोण है जिसका चतुर्भुज 1, $0+0\textbf{i}+0\textbf{j}+1\textbf{k}$ । यह एक बहुत ही सरल बिंदु बादल है, इसमें केवल एक बिंदु है, इसलिए यह बाउंडिंग बॉक्स में वॉल्यूम है। पूर्णांक 42 के लिए, हालांकि, हमारे पास चार चतुर्भुज हैं, और इसलिए चार बिंदु हैं, जिसके चारों ओर हम एक बाउंडिंग बॉक्स आकर्षित कर सकते हैं। बॉक्स का न्यूनतम बिंदु $(1,2,4)$ और अधिकतम $(3,4,6)$ 2 की चौड़ाई, लंबाई और ऊंचाई के परिणामस्वरूप, 2, और 2, 8 की मात्रा देता है।

मान लीजिए कि एक पूर्णांक के लिए करते हैं $n$ , qvolume quaternions एक quadrance है द्वारा गठित सभी 3 डी अंक की धुरी गठबंधन बाउंडिंग बॉक्स की मात्रा के बराबर है $n$ , जहां चार का समुदाय के घटकों $w+x\textbf{i}+y\textbf{j}+z\textbf{k}$ गैर-ऋणात्मक हैं और $w<=x<=y<=z$ ।

एक प्रोग्राम या फ़ंक्शन बनाएँ, जो एक एकल गैर-नकारात्मक पूर्णांक $n$ , $n$ का qvolume आउटपुट करेगा ।

उदाहरण:

input -> output
0 -> 0
1 -> 0
31 -> 4
32 -> 0
42 -> 8
137 -> 96
1729 -> 10032

यह कोड-गोल्फ है, बाइट्स की सबसे छोटी संख्या जीतती है।

Comments

मुझे क्या जोड़ने की आवश्यकता है? मेरा मतलब है कि सबसे छोटी संख्या में बाइट्स जीतेंगे

— उज्ज्वल

आप कोड-गोल्फ टैग को भूल गए, मैंने आपको इसे जोड़ने में मदद की

— अज्ञानता का अवतार

यह एक अच्छी चुनौती है, लेकिन अगर यह थोड़ा कम है तो यह बेहतर IMHO होगा। इसके अलावा, अप्रासंगिक लिंक से सावधान रहें (मैं यह नहीं कह रहा हूं कि आपके सभी लिंक अप्रासंगिक हैं, लेकिन उनमें से कुछ ही वास्तव में चुनौती के लिए सार्थक जानकारी लाते हैं, जबकि अन्य केवल विचलित कर रहे हैं)।

— अरनौलड़

हां, लेकिन केवल i, j, k को 3 डी स्पेस के रूप में क्यों लिया जाए लेकिन 4 डी स्पेस नहीं?

— TSH

@tsh क्योंकि Quaternions जरूरी 4 आयामी यूक्लिडियन स्थान का प्रतिनिधित्व नहीं करते हैं। हैमिल्टन ने उन्हें 3 आयामी अंतरिक्ष के साथ काम करने का तरीका खोजते हुए खोजा। यह एक 4d संस्करण करना संभव होगा, लेकिन मैं 3 डी अंतरिक्ष में उनके उपयोग को टटोल रहा था जब मैंने सवाल किया

— उज्ज्वल

Answer 1

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 67 58 बाइट्स

Volume@BoundingRegion[Rest/@PowersRepresentations[#,4,2]]&

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

                         ...&   Pure function:
PowersRepresentations[#,4,2]    Get the sorted reprs. of # as sums of 4 2nd powers
Rest/@                         Drop the first coordinate of each
BoundingRegion[...]            Find the bounding region, a Cuboid[] or Point[].
                               By default Mathematica finds an axis-aligned cuboid.
Volume                         Find volume; volume of a Point[] is 0.

Comments

वाह, मुझे नहीं पता था कि PowersRepresentations की तरह कुछ एक भाषा में बनाया जाएगा। मैंने वास्तव में एक पूर्णांक को चार वर्गों के रूप में योग करने के विभिन्न तरीकों को दिखाने के लिए एक चुनौती बनाने के बारे में सोचा था, लेकिन मुझे खुशी है कि मैंने नहीं किया।

— दान करें

Lol, Mathematica यहां तक ​​कि एक छवि में बकरियों को निर्धारित करने के लिए एक बेसिन है , इसलिए इस के लिए एक बिलिन होना वास्तव में मुझे आश्चर्यचकित नहीं करता है। xD

— केविन क्रूज़सेन

Answer 2

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

Żœċ4²S⁼ɗƇ⁸ZḊṢ€I§P

इसे ऑनलाइन आज़माएं! (बहुत धीमी गति से - यह एक अग्रणी के साथ½ सभी परीक्षण मामलों के लिए पर्याप्त तेजी से बनाते हैं)

कैसे?

Żœċ4²S⁼ɗƇ⁸ZḊṢ€I§P - Link: non-negative integer, n    e.g. 27
Ż                 - zero-range                            [0,1,2,...,27]
   4              - literal four                          4
 œċ               - combinations with replacement         [[0,0,0,0],[0,0,0,1],...,[0,0,0,27],[0,0,1,1],[0,0,1,2],...,[27,27,27,27]]
        Ƈ         - filter keep those for which:          e.g.: [0,1,1,5]
       ɗ          -   last three links as a dyad:
    ²             -     square (vectorises)                     [0,1,1,25]
     S            -     sum                                     27
      ⁼  ⁸        -     equal to? chain's left argument, n      1
                  -                                       -> [[0,1,1,5],[0,3,3,3],[1,1,3,4]]
          Z       - transpose                             [[0,0,1],[1,3,1],[1,3,3],[5,3,4]]
           Ḋ      - dequeue                               [[1,3,1],[1,3,3],[5,3,4]]
            Ṣ€    - sort each                             [[1,1,3],[1,3,3],[3,4,5]]
              I   - incremental differences (vectorises)  [[ 0,2 ],[ 2,0 ],[ 1,1 ]]
               §  - sum each                              [2,2,2]
                P - product                               8

Answer 3

हास्केल , 132 123 बाइट्स

z=zipWith
(!)=foldr1.z
h n=[0..n]
f n|p<-[[c,b,a]|a<-h n,b<-h a,c<-h b,d<-h c,a^2+b^2+c^2+d^2==n]=product$z(-)(max!p)$min!p

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

बहुत ही सीधा साधा समाधान। Brute 0 से n (जिस तरह से ओवरकील लेकिन कम बायटेकाउंट) से सभी मूल्यों पर पुनरावृत्ति करके सभी संभावित समाधानों को बाध्य करता है। मैं एक सूची के रूप में बिंदु को आउटपुट करता हूं ताकि हम @ लिन के मैजिक (!)ऑपरेटर का उपयोग कर सकें । वह ऑपरेटर बाईं ओर फ़ंक्शन के साथ प्रत्येक आयाम को ढहता है इसलिए max!pआकार 3 की एक सूची देता है जिसमें प्रत्येक आयाम के साथ अधिकतम शामिल होते हैं और min!pन्यूनतम के लिए भी ऐसा ही करते हैं। फिर हम प्रत्येक आयाम में न्यूनतम आकार पाते हैं (अधिकतम से न्यूनतम मान घटाकर z(-)) और उन्हें एक साथ गुणा करें।

कुछ तह ज़िप जादू के साथ 9 बाइट्स को हटाने के लिए @Lynn को बहुत धन्यवाद!

Comments

मैंने कुछ zipWithलॉजिक के पक्ष में ट्रांसपोज़ेशन को आगे बढ़ाते हुए कुछ बाइट्स का मुंडन किया । 123 बाइट्स

— लिन

Answer 4

स्लेजहैमर 0.2, 12 बाइट्स

⡌⢎⣟⡊⢘⣚⡏⡨⠍⠁⡇⠨

Mathematica 11.2 और स्लेजहैमर के इस संस्करण का उपयोग करें , जो चुनौती से पहले है। संस्करण 0.3 में काम करने वाले संस्करण के लिए संपादन इतिहास देखें, जिसमें एक GUI है और एक Mathematica अभिव्यक्ति उत्पन्न करता है।

यह इनपुट को स्टैक पर धकेलता है और कमांड के अनुक्रम को कॉल करता है

{intLiteral[4], intLiteral[2], call["PowersRepresentations", 3], call["Thread", 1], call["Rest", 1], call["Thread", 1], call["BoundingRegion", 1], call["Volume", 1]}

जो मेरे वुल्फ्राम भाषा के उत्तर से प्राप्त निम्नलिखित वुल्फराम कोड के मूल्यांकन के बराबर है :

Volume[BoundingRegion[Thread@Rest@Thread@PowersRepresentations[#, 4, 2]]]&

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

Comments

क्या इसे परीक्षण करने के लिए गणितज्ञ की आवश्यकता है?

— दान करें

@ उज्ज्वल उज्ज्वल हां, रिपॉजिटरी के निर्देश हैं। यह अभी तक बहुत उपयोगकर्ता के अनुकूल नहीं है, इसलिए यह कार्य प्रगति पर है। Setup.wls चलाने के बाद आप वुल्फस्क्रिप्ट या इंटरेक्टिव_एप.वल्स के साथ परीक्षण कर सकते हैं।

— lirtosiast

@Downgoat हां। मैं एक गोल्फ पुस्तकालय को लागू करने की योजना बना रहा हूं, लेकिन वर्तमान में यह मैथमेटीका के मैदान में घटता है।

— lirtosiast

@ पुराने संस्करण को काम करना चाहिए (अब जब मुझे लगता है कि, यह कोड एक पुराने संस्करण पर समान है), लेकिन मुझे इसे डाउनलोड करना होगा और फिर से सेटअप चलाना होगा। (तब से हुए बदलाव ज्यादातर GUI और रिफैक्टिंग कोड लिख रहे हैं जिनमें कार्यक्षमता में कोई बड़ा बदलाव नहीं हुआ है।) चूंकि यह उत्तर सबसे छोटा है, इसलिए यह पात्रता साबित करने के लिए महत्वपूर्ण है, इसलिए मैं कल सुबह यही करूंगा।

— lirtosiast

किसी और को यह चला सकते हैं? मैं इसे 'ol' चेकमार्क देने से पहले काम करने की पुष्टि करना चाहता हूँ।

— उज्ज्वल

Answer 5

पायथन 2 , 138 बाइट्स

q=lambda n,x=0,*t:[t]*(n==0)if t[3:]else q(n-x*x,x,x,*t)+q(n,x+1,*t+(0,)*(x>n))
p=1
for l in zip(*q(input()))[:3]:p*=max(l)-min(l)
print p

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

पुनरावर्ती दिए गए मानदंड के साथ रिवर्स-सॉर्ट किए गए quaternions उत्पन्न करता है, फिर पहले तीन सूचकांकों में सभी संभव मानों के अधिकतम और न्यूनतम के बीच उत्पाद लेता है।

itertools अगर यह हास्यास्पद रूप से लंबे नामों का उपयोग नहीं करता तो शॉट हो सकता था itertools.combinations_with_replacement

पायथन 2 , 161 बाइट्स

from itertools import*
n=input();p=1
for l in zip(*[t[1:]for t in combinations_with_replacement(range(n+1),4)if sum(x*x for x in t)==n]):p*=max(l)-min(l)
print p

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

यही कारण itertoolsहै कि इसका जवाब कभी नहीं है ।

Answer 6

जावास्क्रिप्ट (ईएस 6),  148  143 बाइट्स

n=>(r=[[],[],[]]).map(a=>p*=a.length+~a.indexOf(1),(g=(s,k=0,a=[])=>a[3]?s||r.map(r=>r[a.pop()]=p=1):g(s-k*k,k,[...a,++k],k>s||g(s,k,a)))(n))|p

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

टिप्पणी की गई

हम एक सरणी को इनिशियलाइज़ करते हैं $r$ 3 खाली सरणियों के साथ।

r = [ [], [], [] ]

के प्रत्येक वैध मूल्य के लिए $x$, हम सेट कर देंगे $1$ मूल्य पर $x+1$पहली सरणी में। के लिए Ditto$y$ तथा $z$ क्रमशः दूसरे और तीसरे सरणियों के साथ।

बाउंडिंग बॉक्स के आयामों को पहले और अंतिम प्रवेश सेट के बीच की दूरी से घटाया जाएगा $1$ इन सरणियों में।

चरण 1

भरना $r$, हम पुनरावर्ती फ़ंक्शन का उपयोग करते हैं $g$।

g = (              // g is a recursive function taking:
  s,               // s   = current sum, initially set to the input n
  k = 0,           // k   = next value to be squared
  a = []           // a[] = list of selected values
) =>               //
  a[3] ?           // if we have 4 values in a[]:
    s ||           //   if s is equal to zero (we've found a valid sum of 4 squares):
      r.map(r =>   //     for each array r[] in r[]:
        r[a.pop()] //       pop the last value from a[]
        = p = 1    //       and set the corresponding value in r[] to 1
                   //       (also initialize p to 1 for later use in step 2)
      )            //     end of map()
  :                // else:
    g(             //   do a recursive call:
      s - k * k,   //     subtract k² from s
      k,           //     pass k unchanged
      [...a, ++k], //     increment k and append it to a[]
      k > s ||     //     if k is less than or equal to s:
        g(s, k, a) //       do another recursive call with s and a[] unchanged
    )              //   end of outer recursive call

चरण 2

अब हम उत्पाद की गणना कर सकते हैं $p$ आयामों के।

r.map(a =>         // for each array a[] in r[]:
  p *=             //   multiply p by:
    a.length +     //     the length of a[]
    ~a.indexOf(1)  //     minus 1, minus the index of the first 1 in a[]
) | p              // end of map(); return p

Answer 7

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 229 बाइट्स

a=>{uint b=0,c=~0U,d,e,f=0,g=0,h=0,i=c,j=c,k=c;for(;b*b<=a;b++)for(c=b;c*c<=a;c++)for(d=c;d*d<=a;d++)for(e=d;e*e<=a;e++)if(b*b+c*c+d*d+e*e==a){f=c>f?c:f;g=d>g?d:g;h=e>h?e:h;i=c<i?c:i;j=d<j?d:j;k=e<k?e:k;}return(f-i)*(g-j)*(h-k);}

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

Answer 8

05AB1E , 18 बाइट्स

Ý4ãʒnOQ}€{ζ¦ε{¥O}P

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

पोर्ट ऑफ जोनाथन एलन के जेली उत्तर ।

Answer 9

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

n%i=sum[maximum[t!!i*b|t<-mapM([0..n]<$f)[0..3],sum(map(^2)t)==n,scanr1 max t==t]|b<-[-1,1]]
f n=n%0*n%1*n%2

इसे ऑनलाइन आज़माएं! (बड़े परीक्षण मामलों पर बार)

यहाँ कुछ अजीब अनुकूलन है। किसी दिए गए स्थान पर तत्वों maximum l-minimum lकी सूची lके लिए गणना करने के लिए , यह दूसरे शब्द की उपेक्षा करके अधिकतम करने के लिए उन दोनों को बदलने के संदर्भ में कम हो जाता है: maximum l+maximum(map((-1)*))lया समकक्ष sum[maximum$map(b*)l||b<-[-1,1]]।

तीन आयामों को गुणा करने के लिए, यह f n=n%0*n%1*n%2किसी भी प्रकार के लूप का उपयोग करने की तुलना में केवल उत्पाद लिखने के लिए छोटा हो जाता है । यहां, 'वें समन्वय मानों n%iके न्यूनतम और अधिकतम के बीच का अंतर है i, जो अनुक्रमण के साथ निकाले जाते हैं !!i।

मान्य चार-टुपल्स उत्पन्न करने के लिए, हम उन चार नंबरों की सूची लेते हैं [0..n]जिनके वर्ग से राशि nघटती है और घटते क्रम में होती है। हम के tसाथ रिवर्स-सॉर्टनेस की जांच करते हैं scanr1 max t==t, जो यह देखता है कि क्या रिवर्स का अधिकतम भाग स्वयं है, क्योंकि हास्केल के पास एक महंगा आयात के बिना अंतर्निहित सॉर्ट नहीं है। मैंने अपने पायथन उत्तरों में चार-टुपल्स को पुन: उत्पन्न करने के विभिन्न तरीकों की कोशिश की, लेकिन वे सभी इस क्रूर-बल जनरेट-एंड-फिल्टर तरीके से अधिक लंबे थे।