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


12

एक बहुभुज संख्या kआकार के एक आंगन में डॉट्स की संख्या है n

आपको दिया जाएगा nऔर k, और आपका कार्य एक प्रोग्राम / फ़ंक्शन लिखना है जो संबंधित संख्या को आउटपुट / प्रिंट करता है।

स्कोरिंग

यह । बाइट्स जीत में सबसे कम समाधान।

उदाहरण

3 षट्भुज संख्या

3तृतीय षट्भुज संख्या ( k=6, n=3) है 28क्योंकि देखते हैं 28डॉट्स ऊपर।

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

इस पायथ टेस्ट सूट से उत्पन्न किया जा सकता है ।

उपयोग: दो लाइनें प्रति परीक्षणकेस, nऊपर, kनीचे।

n    k  output
10   3  55
10   5  145
100  3  5050
1000 24 10990000

अग्रिम जानकारी


1
तस्वीर में 4 हैक्सागोनल संख्या नहीं है?
नील

@ नील हम शून्य से गिनते हैं।
लीक नन

2
आप वास्तव में एक प्रश्न पोस्टिंग होड़ पर जा रहे हैं, क्या आप नहीं हैं?
आर। काप

उदाहरण बंद हो सकता है। आप डाल दिया n=3और k=6अपने परीक्षण सुइट में, आप प्राप्त 15। आप में डाल दिया n=4और k=6, आप प्राप्त 28
नॉनलाइनयरफ्रूट

जवाबों:


9

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

’;’;PH+

यह सूत्र का उपयोग करता है

सूत्र

n वें s- gonal संख्या की गणना करने के लिए ।

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

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

’;’;PH+  Main link. Arguments: s, n

’        Decrement; yield s - 1.
 ;       Concatenate; yield [s - 1, n].
  ’      Decrement; yield [s - 2, n - 1].
   ;     Concatenate; yield [s - 2, n - 1, n].
    P    Product; yield (s - 2)(n - 1)n.
     H   Halve; yield (s - 2)(n - 1)n ÷ 2.
      +  Add; yield (s - 2)(n - 1)n ÷ 2 + n.

4

हेक्सागोनी , 25 बाइट्स

?(({"+!@/"*'+{/?('*})/2':

सामने आया:

   ? ( ( {
  " + ! @ /
 " * ' + { /
? ( ' * } ) /
 2 ' : . . .
  . . . . .
   . . . .

kपहले और nदूसरे (किसी विभाजक का उपयोग करके) पढ़ता है ।

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

व्याख्या

कार्यक्रम पूरी तरह से रैखिक है, लेकिन हेक्सागोनी में हमेशा की तरह, निष्पादन का क्रम सभी जगह है:

यहाँ छवि विवरण दर्ज करें

पथ को ग्रे , गहरे नीले , लाल , हल्के नीले , गहरे हरे , गुलाबी रंग में निष्पादित किया जाता है । जैसा कि आप देख सकते हैं, तीन/ केवल प्रवाह को पुनर्निर्देशित करने के लिए कार्य करते हैं। इसके अलावा, .कोई विकल्प नहीं हैं। सभी हेक्सागोनल fanciness स्ट्रिपिंग, जिसके परिणामस्वरूप रैखिक कार्यक्रम है:

?(({?('*})"*'+{2':"+!@

यह मानक सूत्र की गणना करता है

सूत्र

अन्य उत्तर की तरह। यह निम्न पांच मेमोरी किनारों का उपयोग करता है, मेमोरी पॉइंटर (एमपी) के साथ जैसा कि लाल रंग में दिखाया गया है:

यहाँ छवि विवरण दर्ज करें

यहां बताया गया है कि यह कैसे किया जाता है:

?    Read integer input s into edge A.
((   Decrement twice to get (s-2).
{    Move the MP forwards onto edge B.
?    Read integer input n into edge B.
(    Decrement to get (n-1).
'    Move the MP backwards onto edge C.
*    Multiply edges A and B to store the result (s-2)(n-1) in edge C.
}    Move the MP forwards onto edge B.
)    Increment to restore the value n.
"    Move the MP backwards onto edge A.
*    Multiply edge B and C to store the result (s-2)(n-1)n in edge A.
'    Move the MP backwards onto edge D.
+    Add edges E (initially 0) and A to copy (s-2)(n-1)n into edge D.
{    Move the MP forwards onto edge E.
2    Set the memory edge to value 2.
'    Move the MP backwards onto edge A.
:    Divide edge D by edge E to store (s-2)(n-1)n/2 in edge A.
"    Move the MP backwards onto edge C.
+    Add edges A and B to store (s-2)(n-1)n/2+n in edge C.
!    Print as integer.
@    Terminate the program.

इस तरह के एक सरल सूत्र ... 25 बाइट्स की आवश्यकता है ?!
लीक नून

4
@KennyLau यह है सब के बाद Hexagony ...
मार्टिन Ender

हेक्सागोनी मेटा प्रश्न
डाउनरेप_नेशन


3

भूलभुलैया , 13 बाइट्स

?::(*?((*#/+!

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

व्याख्या

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

यह कई अन्य उत्तरों के समान सूत्र का उपयोग करता है:

सूत्र

Op  Explanation                 Stack
?   Read n.                     [n]
::  Make two copies.            [n n n]
(   Decrement.                  [n n (n-1)]
*   Multiply.                   [n (n*(n-1))]
?   Read s.                     [n (n*(n-1)) s]
((  Decrement twice.            [n (n*(n-1)) (s-2)]
*   Multiply.                   [n (n*(n-1)*(s-2))]
#   Push stack depth, 2.        [n (n*(n-1)*(s-2)) 2]
/   Divide.                     [n (n*(n-1)*(s-2))/2]
+   Add.                        [(n+(n*(n-1)*(s-2))/2)]
!   Print.                      []

इस बिंदु पर, निर्देश सूचक एक मृत अंत हिट करता है और चारों ओर मुड़ता है। अब +फिर से निष्पादित किया जाता है, जो एक नो-ऑप है (चूंकि स्टैक के निचले हिस्से को अनन्त रूप से शून्य राशि से भरा हुआ है), और फिर /एक विभाजन-बाय-शून्य का प्रयास करता है जो प्रोग्राम को एक त्रुटि के साथ समाप्त करता है।


2

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

(k,n)=>n+n*--n*(k-2)/2

व्याख्या: प्रत्येक एन-गॉन को एन पॉइंट माना जा सकता है साथ में एक पक्ष प्लस के -2 त्रिकोण आकार एन -1, यानी एन + एन (एन -1) (के -2) / 2।


k--*n--+2-nहालांकि परीक्षण नहीं किया गया है
लीक नून

@KennyLau क्षमा करें, लेकिन (k,n)=>n*(--k*--n-n+2)/2अभी भी 24 बाइट्स हैं।
नील

@KennyLau में तथ्य मैं का स्पष्ट उपयोग की अनदेखी --nके लिए (n-1)। डी 'ओह!
नील

@NeiI खैर, अच्छा है।
लीक नन

आप एक बाई को करीने से बचा सकते हैं:k=>n=>n+n*--n*(k-2)/2
डेनिस


2

एपीएल (Dyalog विस्तारित) , 11 बाइट्स SBCS

इस वैकल्पिक संस्करण के सुझाव के लिए उनकी मदद के लिए Adám को धन्यवाद।

⊢+-∘2⍤⊣×2!⊢

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

व्याख्या

⊢+-∘2⍤⊣×2!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  -∘2⍤⊣×     Multiply (×) with by getLeftArgument (⊢) with (⍤) minus 2 (-∘2) called on it.
             In short, multiply binomial(n,2) with (s-2).
⊢+           Add n.

एपीएल (डायलॉग यूनिकोड) , 12 11 बाइट्स एसबीसीएस

यह गोल्फ में उनकी मदद के लिए Adám को धन्यवाद।

संपादित करें: ngn से -1 बाइट।

⊢+{⍺-22!⊢

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

Ungolfing

⊢+{⍺-22!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  {⍺-2     Multiply it by s-2.
⊢+           Add n.

1

दरअसल, 12 बाइट्स

3@n(¬@D3╟π½+

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

स्पष्टीकरण:

3@n(¬@D3╟π½+
3@n           push 3 copies of n (stack: [n, n, n, k])
   (¬         bring k to front and subtract 2 ([k-2, n, n, n])
     @D       bring an n to front and subtract 1 ([n-1, k-2, n, n])
       3╟π    product of top 3 elements ([n*(n-1)*(k-2), n])
          ½   divide by 2 ([n*(n-1)*(k-2)/2, n])
           +  add ([n*(n-1)*(k-2)/2 + n])

1

डीसी , 14 बाइट्स

?dd1-*2/?2-*+p

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

व्याख्या

यह निम्न सूत्र का उपयोग करता है (ध्यान दें कि T n = n*(n-1)/2):

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

                # inputs              | N S                  | 10 5
?dd             # push N three times  | N, N, N              | 10, 10, 10
   1-           # subtract 1          | (N-1), N, N          | 9, 10, 10
     *          # multiply            | (N-1)*N, N           | 90, 10
      2/        # divide by two       | (N-1)*N/2, N         | 45, 10
        ?       # push S              | S, (N-1)*N/2, N      | 5, 45, 10
         2-     # subtract 2          | (S-2), (N-1)*N/2, N  | 3, 45, 10
           *    # multiply            | (S-2)*(N-1)*N/2, N   | 135, 10
            +   # add                 | (S-2)*(N-1)*N/2 + N  | 145
             p  # print to stdout

1

एसीटो , , 15 बाइट्स

पोर्ट ऑफ द ब्रूस फोर्ट का dc उत्तर :

riddD*2/ri2-*+p

3 बाइट्स को यह समझकर सहेज लिया गया है कि किसी भी "शुद्ध" (कोई संयुक्त आदेश) एसीटो प्रोग्राम को रैखिक रूप से नहीं लिखा जा सकता है।


1

मठगोल्फ , 8 बाइट्स

_┐*½?⌡*+

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

स्पष्टीकरण (के साथ) n=10,=5

_          duplicate first implicit input, stack is [10, 10]
 ┐         push TOS-1 without popping, stack is [10, 10, 9]
  *        multiply, stack is [10, 90]
   ½       halve TOS, stack is [10, 45]
    ?      rotate top 3 stack elements, popping k to the top: [10, 45, 5]
     ⌡     decrement TOS twice: [10, 45, 3]
      *    multiply: [10, 135]
       +   add: [145]

एक वैकल्पिक 8-बायटर है ┼┐*½\⌡*+, जो इनपुट को उल्टे क्रम में लेता है।



0

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

(#2-2)#(#-1)/2+#&

सूत्र का सीधा-आगे अनुप्रयोग।

प्रयोग

  f = (#2-2)#(#-1)/2+#&
  f[10, 3]
55
  f[10, 5]
145
  f[100, 3]
5050
  f[1000, 24]
10990000

0

जे, 14 बाइट्स

]++/@i.@]*[-2:

सूत्र के आधार पर।

P(k, n) = (k - 2) * T(n - 1) + n where T(n) = n * (n + 1) / 2
        = (k - 2) * n * (n - 1) / 2 + n

प्रयोग

   f =: ]++/@i.@]*[-2:
   3 f 10
55
   5 f 10
145
   3 f 100
5050
   24 f 1000
10990000

व्याख्या

]++/@i.@]*[-2:
            2:  The constant function 2
          [     Get k
           -    Subtract to get k-2
        ]       Get n
     i.@        Make a range from 0 to n-1
  +/@           Sum the range to get the (n-1) Triangle number = n*(n-1)/2
                The nth Triangle number is also the sum of the first n numbers
         *      Multiply n*(n-1)/2 with (k-2)
]               Get n
 +              Add n to (k-2)*n*(n-1)/2

मेरे दृष्टिकोण का उपयोग करते हुए, यह कब तक होगा?
लीक नून


0

गेममेकर भाषा, 44 बाइट्स

n=argument1;return (argument0-2)*n*(n-1)/2+n

क्या अंतरिक्ष की आवश्यकता है?
लीक नून

0

पायथन 3, 31 30 28 बाइट्स

इस विकी लेख से सीधे ऊपर समीकरण

lambda s,n:(s-2)*(n-1)*n/2+n

एक बाइट को बचाने के लिए @ मीगो का धन्यवाद!


आप बृहदान्त्र और कोष्ठक के बीच की जगह को हटा सकते हैं।
Mego


0

एक्सेल, 22 बाइट्स

A1वें B1-gonal संख्या की गणना करता है ।

=(B1-2)*A1*(A1-1)/2+A1

0

जावा 8, 21 बाइट्स

समान बाइट-लंबाई के सभी व्यक्तिगत उत्तर:

k->n->n+n*~-n*(k-2)/2
k->n->n+n*--n*(k-2)/2
k->n->n+n*~-n*~-~-k/2
k->n->n+n*--n*~-~-k/2

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

k->n->            // Method with two integer parameters and integer return-type
  n+              //  Return `n` plus
    n*            //   `n` multiplied by
      ~-n         //   `n-1`
         *(k-2)   //   Multiplied by `k-2`
               /2 //   Divided by 2
                  // End of method (implicit / single-line return-statement)



0

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

{⍵+(⍺-2)×+/⍳⍵-1}

यह इस तथ्य से आधारित है कि n × (n-1) / 2 = योग (1..n-1) परीक्षण लगता है:

  f←{⍵+(⍺-2)×+/⍳⍵-1}
  10 f 3
27
  3 f 10
55
  5 f 19
532
  3 f 10
55
  5 f 10
145
  3 f 100
5050
  24 f 1000
10990000
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.