आदिम पायथागॉरियन ट्रिपल्स

Question

( संबंधित )

एक पायथागॉरियन ट्रिपल एक सूची है (a, b, c)संतुष्ट समीकरण है कि एक ² + b ² = c ² ।

एक आदिम पाइथागोरस ट्रिपल (पीपीटी) में से एक है जहां a, bहै, और cसब कर रहे हैं coprime (यानी, तीन तत्वों के बीच केवल आम भाजक है 1)। उदाहरण के लिए, (3, 4, 5)सही त्रिकोण एक प्रसिद्ध आदिम पायथागॉरियन ट्रिपल है।

चुनौती

• इनपुट को देखते हुए n, nवें पीपीटी का उत्पादन करें । या,
• इनपुट को देखते हुए n, पहले nपीपीटी का उत्पादन करें ।

इन पीपीटी को एक सुव्यवस्थित सूची बनाने का आदेश देने के कई तरीके हैं, यह निर्धारित करने के लिए कि कौन सा है n। आप अपनी इच्छानुसार कोई भी ऑर्डर चुन सकते हैं, इसलिए जब तक आप (अनौपचारिक रूप से ठीक हो) साबित कर सकते हैं कि आपका एल्गोरिथ्म हर संभव अद्वितीय पीपीटी उत्पन्न कर सकता है। उदाहरण के लिए, आपके कोड को आउटपुट नहीं करना चाहिए (3,4,5)और (4,3,5)चूंकि वे एक ही ट्रिपल के डुप्लिकेट हैं - एक या दूसरे, कृपया।

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

उदाहरण

नीचे दिए गए उदाहरण के लिए, मैं एक अनुक्रमण उपयोग कर रहा हूँ, outputting nछोटी से छोटी से वें पीपीटी, और आदेश देने c, छोटी से छोटी तो aछोटी से छोटी है, तो b।

n | output
1 | (3, 4, 5)
2 | (5, 12, 13)
5 | (20, 21, 29)
12| (48, 55, 73)

नियम

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

Comments

संबंधित

— मील

A103606 ।

— मील

हमारे पास सबसे अधिक इनपुट क्या है? क्या हम यह मान सकते हैं कि यह हमारी पसंद की भाषा की क्षमताओं के अनुकूल है?

— श्री Xcoder

@ Mr.Xcoder हाँ; यह एक मानक सुरक्षित धारणा है, जब तक आप उस खामियों का फायदा उठाने के लिए उपयोग नहीं कर रहे हैं (जैसे, भाषा केवल 1-बिट संख्या का समर्थन करती है) समस्या को तुच्छ बनाने के लिए।

— AdmBorkBork

मुझे अपने प्रश्न का उत्तर मिला: a और b को कोप्राइम

— edc65

Answer 1

जेली , 27 25 बाइट्स

जोनाथन एलन को 2 बाइट्स धन्यवाद।

²IH;Pµ;ÆḊ
+2ḶḤ‘Œcg/ÐṂÇ€Ṣḣ

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

पहले n1-अनुक्रमित triples को आउटपुट करता है [b, a, c], जिसे बढ़ाकर bऔर फिर क्रमबद्ध किया जाता है a।

विकिपीडिया से एल्गोरिथ्म का उपयोग करता है :

यह अजीब पूर्णांक के सभी अद्वितीय कोपरेम जोड़े के लिए सभी आदिम त्रिभुज उत्पन्न करता है m > n > 0।

व्याख्या

+2ḶḤ‘Œcg/ÐṂÇ€Ṣḣ    Main link. Argument: n
+2                   Add 2 to n, to get enough results.
  Ḷ                  Get integers [0, 1, ..., n+1].
   Ḥ                 Double to get [0, 2, ..., 2n+2].
    ‘                Increment to get [1, 3, ..., 2n+3].
     Œc              Get all ordered pairs [[1, 3], [1, 5], ..., [2n+1, 2n+3]].
       g/            GCD of each pair.
         ÐṂ          Grab the pairs with minimal GCD (which is 1).
           ǀ        Call the helper link on each pair to get the triples.
             Ṣ       Sort the triples first by a, then by b, then by c.
              ḣ      Get the last n.

²IH;Pµ;ÆḊ    Helper link. Argument: pair [m, n]
²              Square to get [m², n²].
 I             Increments: get [m²-n²].
  H            Halve: get [(m²-n²)/2], i.e. [b].
    P          Product: get mn, i.e. a.
   ;           Append to get [b, a].
     µ         Begin a new monadic chain with argument [b, a].
       ÆḊ      Get the length of the vector, i.e. c.
      ;        Append to get [b, a, c].

Comments

यह एक बहुत अच्छी व्याख्या है। धन्यवाद!

— AdmBorkBork

g/Ị$Ðf-> g/ÐṂदो बाइट्स को बचाने के लिए (चूंकि न्यूनतम जीसीडी 1 है और हमेशा कम से कम एक ऐसी प्रविष्टि होगी)।

— जोनाथन एलन

एक और बाइट को बचाया भी जा सकता है (हालांकि इसे कम कुशल बनाकर) - स्क्रैप के +2ḶḤ‘Œcसाथ बदलकर, ²Rm2Œcजो कि इसके इनपुट के लिए काम नहीं करेगा 1:(

— जोनाथन एलन

@JonathanAllan न्यूनतम एक के लिए धन्यवाद। मैंने बहुत सी 2-बाइट रेंज की कोशिश की, लेकिन दुर्भाग्य से कोई भी बड़ी नहीं थी। ( ²ḶḤ‘Œcसबसे पहले मैंने जो सोचा था, उनमें से एक था)।

— पुरकाकूदरी जूल

Answer 2

MATL , 36 बाइट्स

`@:Ut&+wmR&fZd1Mhw/vXutnGE<]GY)t&2|h

इनपुट 1-आधारित है। आउटपुट ऑर्डर गारंटी देता है कि प्रत्येक ट्रिपल बिल्कुल एक बार दिखाई देता है। आदेश को निम्नलिखित में समझाया गया है। स्पष्टीकरण कार्यक्रम को कैसे काम करता है, इस बारे में थोड़ी सी जानकारी देने की आवश्यकता है।

कोड kलूप में शुरू होने पर एक काउंटर बढ़ाता रहता है 1। प्रत्येक के लिए kइसके साथ सभी जोड़ों को उत्पन्न करता है a = 1,...,k, b = 1,...,k, a < b, और की पसंद उन है कि एक पाइथागोरस के साथ ट्रिपल दे c <= k। जोड़े बढ़ाने के क्रम में प्राप्त किए जाते हैं b, फिर a।

प्रत्येक जोड़ी को फिर उसके gcd द्वारा विभाजित किया जाता है। परिणामस्वरूप (संभवतः डुप्लिकेट) जोड़े को दो-स्तंभ मैट्रिक्स के रूप में व्यवस्थित किया जाता है। इस मैट्रिक्स को एक समान मैट्रिक्स के साथ लंबवत रूप से समतल किया जाता है जिसमें छोटे मूल्यों के लिए प्राप्त संचित परिणाम होते हैं k। मैट्रिक्स की पंक्तियों को तब सख्ती से घटाया जाता है। यह दो प्रकार के डुप्लिकेट को हटाता है :

1. जोड़े जो वर्तमान के लिए एक से अधिक बार पाए गए हैं k(जैसे कि 3,4, जो 6,8इसकी जीसीडी द्वारा विभाजित करते समय भी परिणाम होता है );

2. जोड़े जो पहले से छोटे के साथ पाए गए थे k।

वास्तव में, प्रत्येक पुनरावृत्ति kसभी जोड़े को ढूंढती है जो पहले से पुनरावृत्तियों के लिए पाए गए थे। लेकिन यह उन्हें एक अलग क्रम में मिल सकता है । उदाहरण के लिए, k=25ट्रिपल मिलेगा 7,24,25और नहीं 20,21,29(क्योंकि cअधिक नहीं हो सकता k)। बाद में, पुनरावृत्ति k=29दोनों मिल जाएगी, लेकिन 20,21,29 पहले 7,24,25 (आदेश बढ़ रहा है b, तब a) के साथ। यही कारण है कि, सभी जोड़ियों को नवीनतम के लिए रखने के बजाय k, हम उन्हें पिछले वाले से जोड़ते हैं और दृढ़ता से समर्पण करते हैं। ऐसा करने से आश्वासन मिलता है कि ऑर्डर किसी भी इनपुट के लिए समान है n।

उपरोक्त गारंटी देता है कि प्रत्येक आदिम पायथागॉरियन ट्रिपल अंततः दिखाई देगा, और यह केवल एक बार दिखाई देगा। इनपुट के लिए n, kकम से कम nवैध त्रिक प्राप्त होने पर लूप खत्म हो जाता है ; और तब-तब nट्रिपल ouput है।

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

या पहले nत्रिगुणों को देखने के लिए इस संशोधित कोड का उपयोग करें :

`@:Ut&+wmR&fZd1Mhw/vXutnGE<]G:Y)tU&2sX^h

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

Comments

अच्छी व्याख्या।

— AdmBorkBork

Answer 3

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

f 0=(3,4,5)
f n|let(a,b,c)=f$div(n-1)3;r=mod n 3;d=a*(-1)^2^r;e=b*(-1)^r;s=2*(d+e+c)=(s-d,s-e,s+c)

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

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

यह आदिम पाइथागोरस के पेड़ के नीचे एक पथ के रूप में n के जीवनी आधार -3 अंकों की व्याख्या करता है । यह ओ (लॉग एन ) संचालन में कोई खोज के साथ चलता है ।

Answer 4

जेली , 19 18 बाइट्स

*g/²_/
4*œc3UṢÇÐḟḣ

कार्यक्रम 1-आधारित इंडेक्स n लेता है और लेक्सिकोग्राफ़िक क्रम में पहले n PPTs [c, b, a] को प्रिंट करता है ।

यह एक ओ (64 ^एन ) समाधान है, इसलिए टीआईओ इनपुट 4 और उच्चतर पर घुट जाएगा । मैं इसे और तेज़ बनाने पर काम करूँगा।

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

वैकल्पिक संस्करण, O (n ³ ), संभवतः मान्य है

N ^th triplet को खोजने के लिए - [c _n , b _n , a _n ] - ऊपर दिया गया उपाय मानता है कि c _n is 4 ⁿ , जो सत्यापित करना आसान है। हालाँकि, A020882 यह सिद्ध करता है कि c _n ~ 2 , _n , इसलिए एक k ऐसा है जो c _n all kn for all n ।

यदि हम k = 7 ले सकते हैं , तो नीचे दिया गया समाधान भी मान्य है (और बहुत, बहुत तेज)।

*g/²_/
×7œc3UṢÇÐḟḣ

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

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

4*œc3UṢÇÐḟḣ  Main link. Argument: n

4*           Compute 4**n, the n-th power of 4.
  œc3        Take all 3-combinations of the set {1, ..., 4**n}, each sorted in
             ascending order. The triples themselves are sorted lexicographically.
     U       Upend; reverse each triple [a, b, c], yielding [c, b, a].
      Ṣ      Sort the descending triples lexicographically. This ensures that their
             order is independent of n.
       ÇÐḟ   Keep only triples for which the helper link returns a falsy value.
          ḣ  Dyadic head; take the first n triples.


*g/²_/       Helper link. Argument: [c, b, a]

 g/          Reduce [c, b, a] by greatest common divisor, yielding g.
*            Elevate the integers to that power, computing [c**g, b**g, a**g].
   ²         Square, yielding [c**2g, b**2g, a**2g].
    _/       Reduce by subtraction, yielding c**2g - b**2g - a**2g.
             Fermat's Last Theorem assures that this difference will be non-zero
             whenever g > 1, so this yields 0 iff g = 1 and c² = a² = b².

Answer 5

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

Nth PPT को आउटपुट करता है। परिणाम 1-अनुक्रमित हैं और बी के मूल्य द्वारा आदेशित हैं ।

n=>(g=(a,b)=>b?g(b,a%b):a,F=a=>(x=a*a+b*b,c=x**.5|0)*c-x*g(a,g(b,c))||--n?F(a-b?a+1:!++b):[a,b,c])(b=1)

डेमो

let f =

n=>(g=(a,b)=>b?g(b,a%b):a,F=a=>(x=a*a+b*b,c=x**.5|0)*c-x*g(a,g(b,c))||--n?F(a-b?a+1:!++b):[a,b,c])(b=1)

for(n = 1; n <= 20; n++) {
  console.log('#' + n + ' : ' + f(n));
}

Answer 6

MATL , 63 बाइट्स

3lvi:"t"[HlHllO;aOlOHl]!@Y*2eh]]!XuGY)&*tt[lO;Oa]*ssD2)ED2Xy*ss

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

गोल्फ में एक सबक बुरी तरह से गलत हो गया। मैं इसे वैसे भी पोस्ट कर रहा हूं क्योंकि मैं सोच रहा हूं कि क्या इस तरीके से गोल्फ को बेहतर बनाना है।

मैंने इस विकिपीडिया पृष्ठ पर यूक्लिड के सूत्र के साथ संयोजन के रूप में, परीक्षण-और-त्रुटि दृष्टिकोणों के बजाय रचनात्मक रूप से सभी त्रिक उत्पन्न करने के लिए।

सबसे पहले, विषम कोप्राइम जोड़े एक टर्नरी पेड़ के रूप में उत्पन्न होते हैं। यह एक बड़ी मैट्रिक्स गुणन के रूप में किया जाता है, अधिकांश बाइट गिनती के लिए लेखांकन। फिर, यूक्लिड का सूत्र लागू किया जाता है, संभवतः बहुत ही बाइट-बर्बाद करने के तरीके में भी। अगर किसी के पास इन दो हिस्सों के लिए सुझाव हैं, तो मैं उन्हें सुनना पसंद करूंगा।

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

3lv % Push root node of ternary tree
i:" % Generate a tree of depth of input (WAY too large, but golfy)
t"  % loop over all nodes (golfier than looping over last tree row)
[HlHllO;aOlOHl]! % Matrix to generate three children of current node
@Y* % Multiply with current node to get children
2e  % Reshape to get node pairs
h]] % Append to tree, exit loops
!Xu % Remove duplicates (more efficient to do it before last ] but golfier this way)
GY) % Select n-th odd coprime pair
&*tt % Multiply with it's own transpose to get [m²,m*n;m*n,n²]
[lO;Oa]*ssD % Sum of matrix multiplication = m²-n² to get a
2)ED % Second element doubled for b=2mn
2Xy*ss % Sum of matrix multiplication with identify matrix to get c=m²+n²

Answer 7

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

([(a,b,c)|c<-[5..],b<-[1..c],gcd c b<2,a<-[1..b],a^2+b^2==c^2]!!)

0-आधारित अनुक्रमण। किसी दिए गए के लिए c, bऊपर cऔर aऊपर तक चलता है b, इसलिए c > b > aहमेशा धारण करता है।

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

Answer 8

पायथन, 67 50 48 46 बाइट्स

विकिपीडिया पर पाए गए सूत्रों का उपयोग करते हुए,

a=m*n, b=(m^2-n^2)/2, c=(m^2+n^2)/2

कहाँ m>n>0और हैं mऔर nकॉपीराइट और विषम हैं। यहाँ कोड है

lambda n:[3+2*n,~-(3+2*n)**2-1/2,-~(3+2*n)**2/2]

-17 बाइट्स @ मर्टिन एंडर को धन्यवाद

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

हमेशा nसमीकरण 1 में चर का मान होने से काम करता है , जिसका अर्थ है कि mबस कोई अन्य विषम मूल्य है, इस मामले में, 3+2*nजहां nआदिम पायथागॉरियन ट्रिपल की संख्या है। यह हमें सभी nमूल्यों के लिए 1 का मान मानने की अनुमति देता है ।

Comments

PPCG में आपका स्वागत है! फ़ंक्शंस ठीक हैं, इसलिए आपको लैम्ब्डा को असाइन करने की आवश्यकता नहीं है a(और यदि आपने किया, तो आप वहां दो रिक्त स्थान से छुटकारा पा सकते हैं)। मुझे भी यकीन नहीं है कि आप printवहां क्यों हैं , आप लैंबडा से ही मूल्यों को वापस कर सकते हैं।

— मार्टिन एंडर

"आप साबित कर सकते हैं (अनौपचारिक रूप से ठीक है) कि आपका एल्गोरिथ्म हर संभव अद्वितीय पीपीटी उत्पन्न कर सकता है"। लेकिन यह विधि केवल उन लोगों को उत्पन्न करती है जहां कर्ण एक पैर से 1 लंबा है। उदाहरण के लिए, यह कभी भी 8,15,17 उत्पन्न नहीं करता है।

— रोजी एफ

Answer 9

हस्क , 18 बाइट्स

↑üOf§=F⌋ȯ¬Ḟ-m□ΠR3N

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

डेस से प्रेरणा लेकर -4 बाइट्स जर्ब का शुक्रिया अदा करते हैं

सुपर-स्लो ब्रूट फोर्स एप्रोच, 1 से बड़े इनपुट के लिए TIO पर काम नहीं करेगा। आप एक अधिक प्रबंधनीय संस्करण, a, b to200 तक सीमित कर सकते हैं

व्याख्या

↑üOf§=F⌋ȯ¬Ḟ-m□ΠR3N
              ΠR3N   Get all triples of natural numbers
   f                 Keep only those triples where
      F⌋                their GCD
    §=                  is equal to
        ȯ¬Ḟ-m□          the logical negation of c²-b²-a²
 üO                  Remove duplicates by their sorted version
↑                    Get the first <input> values of this sequence

Comments

मानचित्र और फ़िल्टर के संयोजन से 20 बाइट्स , यहां तक ​​कि धीमी।

— जर्बेर जूल

@Zgarb धन्यवाद! मैं

— लियो

डेनिस की जेली उत्तर से घटाव चाल के साथ 18 बाइट्स ।

— जगरब

@Zgarb अच्छा है! हालांकि मुझे संदेह है: क्या एक ही के साथ दो अलग-अलग त्रिभुज हो सकते हैं c? उस स्थिति में इस समाधान को ठीक करने की आवश्यकता होगी

— लियो

हम्म, वास्तव में एक ही के साथ कई ट्रिपल हैं c। यह 18-बाइट समाधान (जो डेनिस की एक और चाल का उपयोग करता है) परवाह किए बिना काम करता है।

— जर्बेर जूल

Answer 10

मैथेमेटिका, 89 बाइट्स

c द्वारा आदेशित हल का उपयोग करना

SortBy[{a,b,c}/.Solve[a^2+b^2==c^2&&GCD[a,b]==1&&0<a<b<c<9#,{a,b,c},Integers],Last][[#]]&

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

(s={};Table[If[IntegerQ[c=Sqrt[a^2+b^2]]&&GCD[a,b]==1,AppendTo[s,{a,b,c}]],{a,9#},{b,9#}];SortBy[Union[Sort/@s],Last][[#]])&

Answer 11

आर (+ संख्या), 88 बाइट्स

n=scan();while(all(nrow(T)<n))T=numbers::pythagorean_triples(5,5+(F<-F+1));T[n,3:5]

संख्याओं को उत्पन्न करने के लिए एक बेसिन का उपयोग करने के लिए, वास्तव में हमें जो चाहिए वह प्राप्त करने के लिए बाइट्स का एक आश्चर्यजनक राशि लेता है। बिल्टिन ने दो तर्क दिए c1और c2, और उन ट्रिपल को लौटा दिया जो उनके पास हैं c >= c1 & c <= c2। यह n-th ट्रिपलेट को पाने के लिए थोड़ा परेशान करता है । यह सिर्फ c2एक समय में 1 बढ़ाता रहेगा जब तक कि आउटपुट सिर्फ पर्याप्त पंक्तियाँ न हो।

Answer 12

PHP , 273 बाइट्स

function t($n){$x=[];for($c=3;;$c++)for($b=2;$b<$c;$b++)for($a=2;$a<$b;$a++)if(d($a,$b,$c)&&$a**2+$b**2==$c**2){$x[]=[$a,$b,$c];if(--$n==0)return $x;}}function d($a,$b,$c){for($i=2;$i<$a;$i++)if($a%$i==0&&$b%$i==0||$a%$i==0&&$c%$i==0||$b%$i==0&&$c%$i==0)return 0;return 1;}

• t($n) ऑर्डर देने के साथ [a, b, c] की एक सरणी देता है a < b < c
• एक शून्य-आधारित सूचकांक लौटाता है

इसे ऑनलाइन आज़माएं! (कोड वहां भी पठनीय है)

Answer 13

सी, 158 बाइट्स

मेरा मानना ​​है कि यह मेरा पहला सबमिशन है, इसलिए आप सबसे बेहतर कर सकते हैं।

#include<stdio.h>
void f(n){int i=0,j=3,k,l;while(1){for(k=1;k<j;k++){for(l=k;l<j;l++){if(j*j==k*k+l*l)i++;if(i==n){printf("%d %d %d",j,k,l);return;}}}j++;};}

और ungolfed संस्करण:

#include <stdio.h>

void f(n)
{
  int i=0, j=3, k, l;
  while (1) {
    for (k=1; k<j; k++) {
      for (l=k; l<j; l++) {
        if (j*j==k*k+l*l)
          i++;
        if (i==n) {
          printf("%d %d %d\n", j, k, l);
          return;
        }
      }
    }
    j++;
  };
}

void main()
{
  int i;

  scanf("%d", &i);

  f(i);
  printf("\n");
}

के लिए एक ² + b ² = c ² , आदेश बढ़ती जा रही है ग तो बढ़ रही है एक ।

कोई दो बार एक ही पीपीटी हो सकता है के रूप में बी एल ई ऐज़ पर है एक इस एल्गोरिथ्म में।

Comments

PPCG में आपका स्वागत है!

— JAD

Answer 14

जेली , 27 25 बाइट्स

⁽0(ḃs
Ɠḃd2Ḥ’×€Ç
3r5DṭÇæ×/

यह एक अलग शाखा आदेश के साथ @ AndersKaseorg के हास्केल उत्तर से पेड़ के दृष्टिकोण का कार्यान्वयन है । कार्यक्रम 0-आधारित अनुक्रमण का उपयोग करता है और STDIN से इनपुट लेता है।

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

पृष्ठभूमि

जैसा कि आदिम पायथागॉरियन ट्रिप्स के विकिपीडिया पृष्ठ ट्री पर उल्लेख किया गया है , प्रत्येक पीपीटी को कुछ गुणों के साथ मैट्रिसेस द्वारा पंक्ति वेक्टर (3, 4, 5) के बार-बार बाएं गुणा करके प्राप्त किया जा सकता है ।

प्रत्येक पुनरावृत्ति में, पिछले परिणाम को A , B , या C दोनों से छोड़ा जा सकता है , जिसे निम्नानुसार चुना जा सकता है।

जब ए , बी , और सी तय किए जाते हैं, तो प्रत्येक पीपीटी को एक अनोखे अंदाज में प्राप्त किया जा सकता है।

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

3r5DṭÇæ×/  Main link. No arguments.

3          Set the argument and the return value to 3.
 r5        Create a range from 3 to 5, i.e., [3, 4, 5].
   D       Decimal; convert each integer to base 10, yielding [[3], [4], [5]].
     Ç     Call the second helper link with argument 3.
    ṭ      Tack; append [[3], [4], [5]] to the result.
      æ×/  Reduce by matrix multiplication.

Ɠḃd2Ḥ’×€Ç  Second helper link. Argument: 3

Ɠ          Read and evaluate one line of input, yielding an integer n.
 ḃ         Convert n to bijective base 3.
  d2       Divmod 2; map each digit d to [d/2, d%2].
    Ḥ      Unhalve; multiply the results by 2.
     ’     Decrement the doubled results.
           The previous four atoms apply the following mapping to the digits.
               1 -> [0, 1] -> [0, 2] -> [-1,  1]
               2 -> [1, 0] -> [2, 0] -> [ 1, -1]
               3 -> [1, 1] -> [2, 2] -> [ 1,  1]
        Ç  Call the helper link with argument 3, yielding the following 2D array.
               [[ 1,  2,  2],
                [ 2,  1,  2],
                [ 2,  2,  3]]
      ×€   Multiply each [-1,  1], [ 1, -1], and [ 1,  1] by that matrix, using
           vectorizing multiplication (not matrix multiplication), yielding one 
           of the following three 2D arrays.

               [[-1,  2,  2],    [[ 1, -2,  2],    [[ 1,  2,  2],
                [-2,  1,  2],     [ 2, -1,  2],     [ 2,  1,  2],
                [-2,  2,  3]]     [ 2, -2,  3]]     [ 2,  2,  3]]

⁽0(ḃs      First helper link. Argument: 3

⁽0(        Numeric literal; yield 13041.
   ḃ       Convert 13041 to bijective base 3, yielding [1, 2, 2, 2, 1, 2, 2, 2, 3].
    s      Split the result into chunks of length 3, yielding the aforementioned
           2D array.

Answer 15

एपीएल (एनएआरएस), 90 चार्ट, 180 बाइट्स

{a⊃⍨⍵⊃⍋↑¨a←{⍵[⍋⍵]}¨a/⍨{1=∨/⍵}¨a←{(-/k),(×/2,⍵),+/k←⍵*2}¨a/⍨{>/⍵}¨a←,a∘.,a←⍳(⌊2⍟2+⍵)×9+⌊√⍵}

यदि उपरोक्त फ़ंक्शन का तर्क ⍵ है, तो उपरोक्त फ़ंक्शन एरे के तत्व of (1 आधारित) को लौटाएगा, जिसमें पाइथोगोरियन ट्राइएल्स (ए, बी, सी) के तत्व हैं जहां <= b <= c और वह एरे के लिए पहले आदेश है, (पक्ष अधिक छोटा), फिर बी के लिए (दूसरी तरफ कर्ण नहीं)। वहाँ कुछ गलत होगा क्योंकि वहाँ नहीं देखा है जहाँ मैं बी के लिए भी आदेश देता हूं ... परीक्षण:

  f←{a⊃⍨⍵⊃⍋↑¨a←{⍵[⍋⍵]}¨a/⍨{1=∨/⍵}¨a←{(-/k),(×/2,⍵),+/k←⍵*2}¨a/⍨{>/⍵}¨a←,a∘.,a←⍳(⌊2⍟2+⍵)×9+⌊√⍵}
  f¨1..10
3 4 5  5 12 13  7 24 25  8 15 17  9 40 41  11 60 61  12 35 37  13 84 85  15 112 113  16 63 65  

यह http://oeis.org/A020884 और http://oeis.org/A020884/b020884.xt से संबंधित है

A020884: आदिम पायथागॉरियन त्रिकोण के छोटे पैरों का आदेश दिया।

  ↑¨f¨1..23
3 5 7 8 9 11 12 13 15 16 17 19 20 20 21 23 24 25 27 28 28 29 31 
  f 999
716 128163 128165 
  f 1000
717 28556 28565 

मुझे नहीं पता कि क्या यह सही है, ऐसा लगता है कि फ़ंक्शन 1000 तक त्रिकोण के पहले पक्ष का सही परिणाम देता है, लेकिन मुझे पता नहीं है, और संभव हो सकता है कुछ ट्रिपल भी सही नहीं हो सकता है <1000।

Answer 16

जावास्क्रिप्ट, 101 बाइट्स

यूक्लिड के सूत्र द्वारा सभी आदिम पायथागॉरियन ट्रिपल पूर्णांकों से उत्पन्न किया जा सकता mहै और nसाथ m>n>0, m+nअजीब gcd(m,n)==1( विकिपीडिया )

इस समारोह में सभी m,nजोड़ी वृद्धि मीटर से शुरू होने वाली गणना m=2और n2 से शुरू होने वाली कमी m-1(ताकि m+nयह विषम हो)

c=>eval("g=(a,b)=>b?g(b,a%b):a;for(m=2,n=1;c-=g(m,n)<2;(n-=2)>0||(n=m++));[m*m-n*n,2*m*n,m*m+n*n]")

कम गोल्फ वाला

c => {
  g = (a,b) => b ? g(b,a%b) : a;
  for( m = 2, n = 1; 
       g(m,n) < 2 ? --c : c; 
       (n -= 2) > 0 || (n = m++))
    /* empty for body */;
  return [m*m - n*n, 2*m*n, m*m + n*n]
}

परीक्षा

F=
c=>eval("g=(a,b)=>b?g(b,a%b):a;for(m=2,n=1;c-=g(m,n)<2;(n-=2)>0||(n=m++));[m*m-n*n,2*m*n,m*m+n*n]")

for(i=1;i<=50;i++) console.log(i+' '+F(i))