बहुभुज संख्याएँ!

Question

परिचय

गणित में, एक बहुभुज संख्या एक संख्या होती है जिसे एक नियमित बहुभुज के आकार में व्यवस्थित डॉट्स या कंकड़ के रूप में दर्शाया जाता है। बिंदुओं को अल्फ़ाज़ (इकाइयों) के रूप में माना जाता है। ये एक प्रकार के 2-आयामी आलंकारिक संख्याएं हैं।

संख्या 10, उदाहरण के लिए, एक त्रिकोण के रूप में व्यवस्थित की जा सकती है:

*
**
***
****

लेकिन 10 को एक वर्ग के रूप में व्यवस्थित नहीं किया जा सकता है। दूसरी ओर, संख्या 9 हो सकती है:

***
***
***

36 की तरह कुछ संख्याओं को एक वर्ग और एक त्रिकोण के रूप में व्यवस्थित किया जा सकता है:

******  *
******  **
******  ***
******  ****
******  *****
******  ******

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

त्रिकोणीय संख्या:

वर्ग संख्या:

पक्षों की अधिक संख्या वाले बहुभुज, जैसे पेंटागन और हेक्सागोन्स भी इस नियम के अनुसार बनाए जा सकते हैं, हालांकि डॉट्स अब ऊपर की तरह पूरी तरह से नियमित जाली नहीं बनाएंगे।

पेंटागनल नंबर:

हेक्सागोनल संख्या:

^{स्रोत: विकिपीडिया}

आपका कार्य

एक धनात्मक पूर्णांक N (1 <= N <= 1000) को देखते हुए , हर प्रकार के बहुभुज संख्या N को त्रिकोणीय संख्याओं से शुरू कर रहे हैं और जिसमें Icosagonal (20-gon) संख्याएँ शामिल हैं।

उदाहरण के लिए, संख्या 10 एक त्रिकोणीय संख्या और एक विकर्ण संख्या है, इसलिए आउटपुट कुछ ऐसा होना चाहिए (आप अपना स्वयं का आउटपुट प्रारूप चुन सकते हैं, लेकिन यह कुछ इस तरह दिखना चाहिए):

3 10

परीक्षण के मामलों

1 -> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2 -> (None)
3 -> 3
6 -> 3 6
36 -> 3 4 13

संदर्भ के लिए, nमई के k-gonal संख्या है:

^{साभार: xnor}

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स वाला कोड जीतता है।

Comments

संदर्भ के लिए, nवें k-gonal संख्या है (k-2)*n*(n-1)/2 + n।

— xnor

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

— पीटर टेलर

Answer 1

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

lambda R:[s+2for s in range(1,19)if(s-2+(4+s*(s-4+8*R))**.5)/2%s==0]

प्रत्येक संभावित संख्या के लिए, यह देखने के लिए s+2द्विघात सूत्र हल करता है कि क्या परिणाम पूरी संख्या है।R=s*n*(n-1)/2 + nn

तुलना करें (73 बाइट्स):

lambda R:[s+2for s in range(1,19)if R in[n+s*n*~-n/2for n in range(R+1)]]

sपाइथन 3 में 62 बाइट्स देने के लिए हल करने का एक वैकल्पिक तरीका है , लेकिन विफल रहता है R=1।

lambda R:{(R-n)*2/n/~-n+2for n in range(2,R+1)}&{*range(3,21)}

Answer 2

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

n=>[...Array(21).keys(n--)].slice(3).filter(i=>(Math.sqrt(i*i+8*i*n-16*n)+i-4)%(i+i-4)==0)

द्विघात समीकरण हल करता है। फ़ायरफ़ॉक्स के नए पर्याप्त संस्करणों पर 73 बाइट्स:

n=>[for(i of Array(18).keys())if(((~-i**2+8*n*-~i)**.5+~-i)/2%-~i==0)i+3]

Answer 3

> <>, 62 + 3 = 65 बाइट्स

&1v
v0<;?)+8a:+1~~<
1.292:{<>+n}ao^
>:&:&=?^:&:&)?^:@:@$-{:}++

स्टैक के शीर्ष पर इनपुट की अपेक्षा करता है, इसलिए -vध्वज के लिए +3 बाइट्स ।

यह>> में मेरी पहली बार प्रोग्रामिंग है, इसलिए मुझे कोड को छोटा करने के लिए कुछ स्पष्ट ट्रिक्स याद आ रही हैं।

स्पष्टीकरण:

प्रारंभ

&1v
v0<
1

चालें एन रजिस्टर करने के लिए, ढेर करने के लिए काउंटर धक्का (से शुरू 1जो त्रिकोणीय संख्या से मेल खाती है,), और मूल्यों के साथ अनुक्रम शुरू होता है 0और 1।

मुख्य घेरा

 :&:&=?^:&:&)?^:@:@$-{:}++

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

छाप

 .292:{<>+n}ao^
       ^

काउंटर + 2 को प्रिंट करता है, उसके बाद एक नई लाइन, फिर रीसेट रूटीन पर जाता है।

रीसेट

v0<;?)+8a:+1~~<
1             ^

शीर्ष दो स्टैक आइटम निकालता है और काउंटर बढ़ाता है। कार्यक्रम समाप्त होता है यदि काउंटर 18 से अधिक है, अन्यथा प्रारंभिक संख्या 0और 1स्टैक को धक्का देता है और मुख्य लूप पर लौटता है।

Answer 4

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

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3

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

व्याख्या

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3
18pȷ                   - All possible (k-2,n) pairs
    µ      µ€          - to each pair compute the corresponding polygonal number:
     Ḣ                 -   retrieve k-2
      ×’               -   multiply by n-1
        ×H             -   multiply by half of n
          +            -   add n
             _³        - subtract the input. There will now be 0's at (k-2,n) pairs which produce the input
               ¬FT     - retrieve all indices of 0's. The indices are now (k-2)*1000+n
                  :ȷ   - floor division by 1000, returning k-3
                    +3 - add 3 to get all possible k.

Answer 5

Axiom 203 बाइट्स

 l(x)==(local q,m,a;v:List INT:=[];for i in 3..20 repeat(q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n);if #q>1 then(m:=rhs q.1;a:=rhs q.2;if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v)));v:=sort v;v)

यहाँ कम गोल्फ और दिनचर्या है जो संख्या दिखाते हैं

 l(x)==
  local q,m,a
  v:List INT:=[]
  for i in 3..20 repeat 
     q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n)  -- this would find only rational solutions as r/s with r,s INT
     if #q>1 then -- if exist rational solution and denominator =1=> add to list of result
        m:=rhs q.1;a:=rhs q.2;
        if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v) 
  v:=sort v
  v

 (2) ->  [[i,l(i)]  for i in 1..45]
    Compiling function l with type PositiveInteger -> List Integer

    (2)
    [[1,[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]], [2,[]], [3,[3]],
     [4,[4]], [5,[5]], [6,[3,6]], [7,[7]], [8,[8]], [9,[4,9]], [10,[3,10]],
     [11,[11]], [12,[5,12]], [13,[13]], [14,[14]], [15,[3,6,15]], [16,[4,16]],
     [17,[17]], [18,[7,18]], [19,[19]], [20,[20]], [21,[3,8]], [22,[5]],
     [23,[]], [24,[9]], [25,[4]], [26,[]], [27,[10]], [28,[3,6]], [29,[]],
     [30,[11]], [31,[]], [32,[]], [33,[12]], [34,[7]], [35,[5]], [36,[3,4,13]],
     [37,[]], [38,[]], [39,[14]], [40,[8]], [41,[]], [42,[15]], [43,[]],
     [44,[]], [45,[3,6,16]]]
                                                           Type: List List Any

Answer 6

AWK , 67 बाइट्स

{for(k=2;++k<21;)for(n=0;++n<=$1;)if((k/2-1)*(n*n-n)+n==$1)print k}

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

मैंने वास्तव में द्विघात को हल करने की कोशिश की, लेकिन यह देखने के लिए कि क्या यह काम छोटा है (और मेरे लिए कम त्रुटि-प्रवण) प्रत्येक मान की जाँच कर रहा है

Answer 7

आर, 68 66 बाइट्स

N=scan();m=expand.grid(k=1:18,1:N);n=m$V;m$k[m$k*n*(n-1)/2+n==N]+2

स्टड Nसे पढ़ता है। पहले Nk-gonal नंबरों की गणना करता है और xnor के फॉर्मूले का उपयोग करते हुए kउन्हें जहां समान Nमिलता है; हालाँकि, अंत में जोड़ने और जोड़ने के 1:18बजाय कोष्ठक पर बाइट्स बचाता है ।3:202

expand.gridडिफ़ॉल्ट रूप से कॉलम Var1, Var2...,, अगर कोई नाम नहीं दिया गया है। $आंशिक मिलान द्वारा अनुक्रमित, इसलिए दूसरे कॉलम से m$Vमेल खाती है m$Var2,।

पुराना संस्करण:

N=scan();m=expand.grid(k=3:20,1:N);n=m$V;m$k[(m$k-2)*n*(n-1)/2+n==N]

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

Answer 8

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

परी / जीपी में एक अंतर्निहित परीक्षण है कि क्या एक संख्या बहुभुज संख्या है।

x->[s|s<-[3..20],ispolygonal(x,s)]

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

Answer 9

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

^{मैंने अभी इस चुनौती का एक प्रभावी विवरण लिखना शुरू किया है (यद्यपि सभी k> 1 को न केवल [1,20]) कवर किया है ... इसलिए इसके बजाय इसका जवाब देंगे!}

Ṫð’××H+⁸
18pÇċ¥Ðf⁸+2

एक पूरा कार्यक्रम मुद्रण जेली सूची परिणामों का प्रतिनिधित्व *

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

* कोई परिणाम प्रिंट कुछ नहीं;
  एक एकल परिणाम केवल उस संख्या को प्रिंट करता है;
  एकाधिक परिणाम संख्याओं की एक []संलग्न, , पृथक सूची प्रिंट करते हैं

कैसे?

Ṫð’××H+⁸ - Link 1, ith (x+2)-gonal number: list [x,i]   e.g. [3,4] (for 4th Pentagonal)
Ṫ        - tail & modify (i.e. yield i & make input [x])     4
 ð       - new dyadic chain, i.e. left = i, right = [x]
  ’      - decrement i                                       3
   ×     - multiply by [x]                                   [9]
     H   - halve [x]                                         [2]
    ×    - multiply                                          [18]
       ⁸ - chain's left argument, i                          4
      +  - add                                               [22]

18pÇċ¥Ðf⁸+2 - Main link: number, n                      e.g. 36
18p         - Cartesian product of range [1,18] with n       [[1,1],[1,2],...,[1,36],[2,1],...,[18,1],[18,2],[18,36]]
            -   (all pairs of [(k-2),i] which could result in the ith k-gonal number being n)
      Ðf    - filter keep if this is truthy:
        ⁸   -   chain's left argument, n                     36
     ¥      -   last two links as a dyad:
   Ç        -     call the last link as a monad (note this removes the tail of each)
    ċ       -     count (this is 1 if the result is [n] and 0 otherwise)
            -                            filter keep result: [[1],[2],[11]]
         +2 - add two                                        [[3],[4],[13]]
            - implicit print ...due to Jelly representation: [3, 4, 13]