पाँच घन का योग

Question

पूर्णांक को देखते हुए, पांच पूर्ण क्यूब्स का उत्पादन, जिसका पूर्णांक पूर्णांक है। ध्यान दें कि क्यूब्स सकारात्मक, नकारात्मक या शून्य हो सकते हैं। उदाहरण के लिए,

-10 == -64 - 64 + 64 + 27 + 27

इसलिए इनपुट के लिए -10आप आउटपुट दे सकते हैं [-64, -64, 64, 27, 27], हालांकि अन्य समाधान संभव हैं। ध्यान दें कि आपको क्यूब्स का उत्पादन करना चाहिए, न कि क्यूबों की संख्या।

एक समाधान हमेशा मौजूद होता है - आप अपने लिए इसे बाहर निकालने का आनंद ले सकते हैं। यह आगे अनुमान लगाया गया है कि चार क्यूब्स पर्याप्त हैं।

Comments

दो प्रश्न: क्या हम किसी भी परिणाम का उत्पादन कर सकते हैं, या केवल सबसे छोटा? उदाहरण के लिए -10एक और संभावित समाधान हो सकता -1000+4574296+4410944-4492125-4492125है। और यह उत्पादन करने की अनुमति दी है --या +-बजाय +/ -क्रमशः (यानी 3 = 27+-27+-125--64--64बजाय 3 = 27-27-135+64+64)?

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

@ केविनक्रूजसेन कोई भी परिणाम ठीक है। यदि आप आउटपुट का मतलब पसंद करते हैं --5, तो मैं अभिव्यक्ति के आउटपुट पर सामान्य नियमों के अनुसार नहीं कहूंगा ।

— xnor

@KevinCruijssen आपको +संकेतों के साथ एक अभिव्यक्ति का उत्पादन करने की आवश्यकता नहीं है , बस संख्या।

— xnor

-10 = -64 - 64 + 64 + 27 + 27या-10 = -343 + 0 -8 +125 +216

— Angs

दिलचस्प नोट: 3 पर्याप्त नहीं है (कुछ संख्याएं अप्रस्तुत हैं), लेकिन कुछ संख्याएं हैं जिनकी प्रतिनिधित्व क्षमता अज्ञात है (जैसे कि 33)।

— फल

Answer 1

ब्रेकीलॉग , 18 बाइट्स

∧5~lLȧᵐ≥₁∧L^₃ᵐ.+?∧

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

व्याख्या

हम मूल रूप से समस्या का वर्णन करते हैं, अतिरिक्त बाधा के साथ कि हम आउटपुट सूची को परिमाण के संदर्भ में गैर-बढ़ते हुए चाहते हैं: यह ब्रिअकलॉग को 5 मानों के सभी संभावित संयोजनों को ठीक से पीछे करने के बजाय, अंतिम के मूल्य पर असीम रूप से पीछे हटने के बजाय मजबूर करता है। सूची का तत्व।

∧                ∧    (disable some implicit stuff)
 5~lL                 L is a list of length 5
    Lȧᵐ≥₁             L must be a non-increasing list in terms of magnitude
         ∧
          L^₃ᵐ.       The output is L with each element cubed
              .+?     The sum of the output is the input

अलग-अलग उपाय खोजना

ए को जोड़कर ≜, बढ़ते परिमाण के साथ सभी समाधान खोजने के लिए इस विधेय का उपयोग करना संभव है: उदाहरण के लिए, यहां पहले 10 साल के लिए हैं42

Answer 2

ब्रेकीलॉग , 11 बाइट्स

धन्यवाद एक बाइट को बचाने के लिए घातक

~+l₅≥₁.√₃ᵐ∧

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

सबसे पहले ~+लागू होता है कि आउटपुट ( .) इनपुट के लिए योग होना चाहिए। l₅फिर से उत्पादन में बाधा उत्पन्न करता है, यह तय करता है कि इसकी लंबाई 5 होनी चाहिए। ≥₁घोषणा करता है कि सूची घटते क्रम में होनी चाहिए (मेरा मानना ​​है कि यह एक अनंत लूप में प्रवेश करने वाले कार्यक्रम को रोकने के लिए आवश्यक है)

हम इस सूची .को आउटपुट चर के साथ स्पष्ट रूप से एकीकृत करते हैं , क्योंकि हमारी अगली भविष्यवाणी सूची के मूल्यों को "बदल" देगी। फिर हम सूची में प्रत्येक मान का घनमूल लेते हैं √₃ᵐ। चूंकि ब्रेजलॉग स्वाभाविक रूप से पूर्णांक-आधारित है, इसलिए यह निर्धारित करता है कि सूची में सभी संख्याएँ घन संख्याएँ हैं।

अंत में, हम उपयोग करते हैं ∧क्योंकि .प्रत्येक पंक्ति के अंत में एक निहित जोड़ है। चूंकि हम .घन जड़ों की सूची के साथ एकीकृत नहीं होना चाहते हैं, इसलिए हमने इसे पहले से एकीकृत किया और ∧इसे अंत में एकीकृत करने से रोकने के लिए उपयोग किया।

Answer 3

पायथन 2 , 58 57 54 बाइट्स

def f(n):k=(n**3-n)/6;return[v**3for v in~k,1-k,n,k,k]

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

---

• -2 बाइट्स, रॉड के लिए धन्यवाद
• -1 बाइट, नील की बदौलत

Comments

आप सिग्नल को स्वैप करते हुए 2 बाइट्स बचा सकते हैंk=-(n-n**3)/6;[v**3for v in~k,1-k,n,k,k]

— रॉड

@ -(n-n**3)क्या आप उपयोग नहीं कर सकते (n**3-n)?

— नील

@ हाँ, आप कर सकते हैं।

— रॉड

Answer 4

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

def f(n):k=(n-n**3)//6;return[n**3,(k+1)**3,(k-1)**3,-k**3,-k**3]

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

मेरा मतलब है, एक स्पष्ट फार्मूला यहाँ भी है (हालाँकि उसने एक अस्तित्व के पीछे निर्माण को अलग कर दिया है)

Comments

आप kअपने समीकरण को उलट कर और लिखकर ठीक एक बाइट बचा सकते हैं । इसे ऑनलाइन आज़माएं!

— जेफ फ्रीमैन

बार-बार क्यूबिंग से परेशान क्यों? यानी कोडगॉल्फ.स्टैकएक्सचेंज.com

— 161235/

Answer 5

जावा 8, 178 87 73 71 65 बाइट्स

n->new long[]{n*n*n,(n=(n-n*n*n)/6+1)*n*n--,--n*n*n,n=-++n*n*n,n}

-6 बाइट्स @ OlivierGrégoire को धन्यवाद ।

तल पर एक ही स्पष्टीकरण, लेकिन मैं पहले इस्तेमाल किए गए व्युत्पन्न के बजाय आधार समीकरण का उपयोग कर रहा हूं ( अंतर्निहित टिप के लिए @LeakyNun के पायथन 3 उत्तर के लिए धन्यवाद ):

k = (n - n ³ ) / 6
n == n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³

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

---

पुराने 178 बाइट्स उत्तर:

n->{for(long k=0,a,b,c,d;;){if(n==(a=n*n*n)+(b=(d=k+1)*d*d)+(c=(d=k-1)*d*d)-(d=k*k*k++)-d)return a+","+b+","+c+","+-d+","+-d;if(n==a-b-c+d+d)return-a+","+-b+","+-c+","+d+","+d;}}

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

स्पष्टीकरण:

मैं k0 से ऊपर की ओर लूप करता हूं जब तक कि कोई समाधान नहीं मिलता है। प्रत्येक पुनरावृत्ति में यह इन दो समीकरणों की जाँच करेगा:

• धनात्मक k: n == n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• ऋणात्मक k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

क्यूं कर?

चूंकि n - n ³ = n * (1-n) * (1 + n) और फिर 6 | (nn ³ ) , इसे n - n ³ = 6k के रूप में लिखा जा सकता है ।
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ ।
और इसलिए n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ कुछ k के लिए ।
स्रोत।

Comments

65 बाइट्स : n->new long[]{n*n*n,(n=(n-n*n*n)/6+1)*n*n--,--n*n*n,n=-++n*n*n,n}(या 64 कम सटीक परिणामों के लिए ints का उपयोग करते हुए)

— ओलिवियर ग्रेजायर

Answer 6

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

‘c3µ;;C;~;³*3

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

सूत्र को स्वतंत्र रूप से देखें। (x + 1) ³ + (x-1) ³ - 2 × x ³ == 6 × x।

---

 === Explanation ===
‘c3µ;;C;~;³*3   Main link. Input: (n).
‘               Increment.
 c3             Calculate (n+1)C3 = (n+1)×n×(n-1)÷6.
   µ            Start a new monadic link. Current value: (k=(n³-n)÷6)
    ;           Concatenate with itself.
     ;C         Concatenate with (1-k).
       ;~       Concatenate with bitwise negation of (k), that is (-1-k)
         ;³     Concatenate with the input (n).
           *3   Raise the list [k,k,1-k,-1-k,n] to third power.
                End of program, implicit print.

वैकल्पिक 13 बाइट्स: इसे ऑनलाइन आज़माएं!

Comments

‘c3µ³;;;C;~*3तब से एक बाइट को बचाना चाहिए (n ^ 3-n) / 6 = C (n + 1, 3)

— मील

Answer 7

ऑक्टेव , 47 40 33 बाइट्स

@(n)[k=(n^3-n)/6,k,-k-1,1-k,n].^3

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

Giuseppe के लिए 6 बाइट्स से बचा, क्योंकि मैं कुछ पुराने कोष्ठक को हटाना भूल गया था। राफ 11111 के लिए धन्यवाद, संकेतों को बदलकर एक और बाइट्स को बचाया।

लिंक किए गए math.se पोस्ट में सूत्र का उपयोग करता है :

1. चूँकि n - n ^ 3 = n (1-n) (1 + n) तब 6 | (n - n ^ 3) और हम n - n ^ 3 = 6k लिख सकते हैं ।
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 ।

ऐसा प्रतीत होता है कि यदि मैं समीकरण को हल करने का प्रयास करता हूं : (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 के संबंध में k , सिर्फ के बजाय समीकरण का उपयोग करना।

Answer 8

माइनक्राफ्ट फ़ंक्शंस (18w11a, 1.13 स्नैपशॉट), 813 बाइट्स

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

ए

scoreboard objectives add k dummy
scoreboard objectives add b dummy
scoreboard objectives add c dummy
scoreboard players operation x k = x n
function d
function f
scoreboard players operation x k -= x b
scoreboard players set x b 6
scoreboard players operation x k /= x b
scoreboard players set x b 1
function d
scoreboard players operation x c += x b
function f
scoreboard players set x b 1
function d
scoreboard players operation x c -= x b
function f
function d
function e
scoreboard players operation x b -= x c
scoreboard players operation x b -= x c
function c
function b

ख

tellraw @s {"score":{"name":"x","objective":"b"}}

सी

scoreboard players operation x b *= x c
scoreboard players operation x b *= x c
function b

घ

scoreboard players operation x c = x k

ई

scoreboard players operation x b = x c

च

function e
function c

नामित स्कोरबोर्ड से "इनपुट लेता है" n, इसे बनाएं /scoreboard objectives add n dummyऔर फिर इसका उपयोग करके सेट करें /scoreboard players set x n 5। फिर फ़ंक्शन का उपयोग करके कॉल करें/function a

इस math.se उत्तर से सूत्र का उपयोग करता है

Answer 9

जावास्क्रिप्ट (Node.js) , 48 45 बाइट्स

• 3 बाइट्स कम करने के लिए @Arnauld को धन्यवाद

n=>[n,1-(k=(n**3-n)/6|0),~k,k,k].map(x=>x**3)

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

Comments

क्यों |0? n**3-nपूर्णांक के लिए 6 का गुणक होना चाहिए n।

— नील

Answer 10

MATL , 21 बाइट्स

|_G|&:5Z^3^t!sG=fX<Y)

यह सेट से सभी 5-ट्यूपल संख्याओं की कोशिश करता है (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3। इसलिए यह बहुत अक्षम है।

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

Answer 11

हास्केल , 43 42 बाइट्स

p n|k<-div(n^3-n)6=map(^3)[n,-k-1,1-k,k,k]

बस लोकप्रिय जवाब, हास्केल के लिए अनुवादित। एक बाइट को बचाने के लिए @ rafa11111 को धन्यवाद!

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

Comments

आप kअसाइनमेंट में साइन को बदलते हुए एक बाइट बचा सकते हैं ...

— rafa11111

Answer 12

भूसी , 12 बाइट्स

ḟo=⁰Σπ5m^3İZ

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

5 क्यूब्स के सभी संभावित सूचियों की कोशिश करता है, और सही राशि के साथ पहला रिटर्न देता है।

व्याख्या

ḟo=⁰Σπ5m^3İZ
          İZ    List of all integers [0,1,-1,2,-2,3,-3...
       m^3      Cube of each integer [0,1,-1,8,-8,27,-27...
     π5         Cartesian power with exponent 5. This returns a list of all possible
                lists built by taking 5 elements from the input list. This infinite
                list is ordered in such a way that any arbitrary result occurs at a 
                finite index.
ḟo              Find and return the first element where...
    Σ             the sum of the five values
  =⁰              is equal to the input

Answer 13

सी (जीसीसी) , 85 81 75 बाइट्स

सहेजे गए 4 बाइट्स और फिर 6 बाइट्स @ सीलिंगकैट के असाइनमेंट्स को फिर से ऑर्डर करने के लिए धन्यवाद

r[5];f(n){r[1]=(n=(n-(*r=n*n*n))/6+1)*n*n--;r[3]=r[4]=-n*n*n;r[2]=--n*n*n;}

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

Answer 14

फोरट्रान (GFortran) , 53 बाइट्स

READ*,N
K=(N**3-N)/6
PRINT*,(/N,1-K,-1-K,K,K/)**3
END

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

फोर्ट्रन आउटगोल्फिंग पायथन? यहाँ क्या चल रहा है?

Answer 15

पायथन 3, 65 61 60 बाइट्स

lambda N:[n**3for k in[(N**3-N)//6]for n in[N,-k-1,1-k,k,k]]

संपादित करें: कुछ अनावश्यक रिक्त स्थान को गिरा दिया।

संपादित करें: rafa11111 के स्मार्ट रीऑर्डरिंग के लिए धन्यवाद।

से प्रेरित होकर इस ।

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

Comments

आप (N**3-N)[N,1-k,-1-k,k,k]

— rafa11111

@ rafa11111 स्मार्ट reordering। धन्यवाद।

— गुओयांग किन

Answer 16

आर , 40 38 बाइट्स

लिंक किए गए math.SE पोस्ट में सूत्र का उपयोग करता है। Giuseppe के लिए नीचे 2 बाइट्स के लिए धन्यवाद।

c(n<-scan(),k<-(n^3-n)/6,k,1-k,-k-1)^3

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

Comments

38 बाइट्स

— Giuseppe

Answer 17

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

3*⍨⊢,∘(1 ¯1∘+,2⍴-)6÷⍨⊢-*∘3

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

LeakyNun के उत्तर का APL अनुवाद ।

टैटिट पर जाकर 4 बाइट्स के लिए Adám को धन्यवाद।

कैसे?

3*⍨⊢,∘(1 ¯1∘+,2⍴-)6÷⍨⊢-*∘3 ⍝ Tacit function
                   6÷⍨⊢-*∘3 ⍝ (n-n^3)/6 (our k)
                 -)         ⍝ Negate
               2⍴           ⍝ Repeat twice; (yields -k -k)
       (1 ¯1∘+,             ⍝ Append to k+1, k-1
     ,∘                     ⍝ Then append to
    ⊢                       ⍝ n
3*⍨                         ⍝ And cube everything

Comments

क्षमा करें अगर मुझे कुछ याद आया, लेकिन: 1) क्योंकि tio में एक असाइनमेंट है, तो आपका जवाब यहाँ सिर्फ एक स्निपेट नहीं है? 2) यद्यपि आपने 30 वर्णों का उपयोग किया है, क्योंकि यह यूनिकोड में है, क्या यह 43 बाइट्स का उपयोग नहीं कर रहा है, जैसा कि tio में बताया गया है?

— rafa11111

@ rafa11111 नहीं और नहीं: APL TIO में अजीब तरह से काम करता है। "कोड" फ़ील्ड में असाइनमेंट वास्तव में "इनपुट" फ़ील्ड में फ़ंक्शन का उपयोग करने के लिए सिर्फ एक शॉर्टकट है; वास्तविक कोड के काम करने के लिए यह पूरी तरह अनावश्यक है। इसके अलावा, हम प्रत्येक चरित्र को एक बाइट के रूप में गिनते हैं क्योंकि Dyalog APL के लिए, हम @ Adám के SBCS का उपयोग करते हैं। मैं बाद में इसे समझाते हुए मेटा पोस्ट का लिंक जोड़ सकता हूं लेकिन मैं अभी मोबाइल पर हूं।

— जे। सेले

ओह मैं समझा। मैं इन के बारे में नहीं जानता था। समझाने के लिए धन्यवाद!

— rafa11111

Answer 18

भूसी , 20 बाइट्स

m^3m‼:_:→:←;K¹÷6Ṡ-^3

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

इस पोस्ट से सूत्र का उपयोग करता है ।

व्याख्या

m^3m‼:_:→:←;K¹÷6Ṡ-^3  Implicit input
                Ṡ-    Subtract itself from it
                   ^3    raised to the third power
              ÷6       Divide by six
   m                   Map over the value with a list of functions:
           ;             Create a singleton list with
            K¹             the function of replace by the input
         :←              Append the function of decrement
       :→                Append the function of increment
    ‼:_                  Append the function of negate twice
m^3                    Cube the numbers of the list

Answer 19

x86, 41 39 बाइट्स

ecxस्टैक पर इनपुट और आउटपुट के साथ सूत्र का अधिकतर सीधा कार्यान्वयन ।

दिलचस्प बात यह है कि मैंने एक क्यूबिंग फ़ंक्शन का उपयोग किया, लेकिन चूंकि call label5 बाइट्स हैं , मैं लेबल के पते को संग्रहीत करता हूं और 2 बाइट का उपयोग करता हूं call reg। इसके अलावा, जब से मैं अपने फ़ंक्शन में मान बढ़ा रहा हूं, मैं jmpइसके बजाय उपयोग करता हूं ret। यह बहुत संभव है कि लूप और स्टैक के साथ चालाक होने से पूरी तरह से कॉल करने से बचा जा सकता है।

मैंने किसी भी फैंसी ट्रिक को क्यूबिंग के साथ नहीं किया, जैसे कि उपयोग करना (k+1)^3 = k^3 + 3k^2 + 3k + 1।

बदलाव का:

• फिक्स बाइट का उपयोग कर गिनती notके बजाय neg/ dec।

• -2 बाइट नहीं xorआईएनजी edxक्योंकि यह शायद 0 से है imul।

.section .text
.globl main

main:
        mov     $10, %ecx   # n = 10

start:
        lea     (cube),%edi # save function pointer
        call    *%edi       # output n^3

        sub     %ecx, %eax  # n^3 - n
                            # edx = 0 from cube
        push    $6
        pop     %ebx        # const 6        
        idiv    %ebx        # k = (n^3 - n)/6
        mov     %eax, %ecx  # save k

        call    *%edi       # output k^3
        push    %eax        # output k^3

        not     %ecx        # -k-1        
        call    *%edi       # output (-k-1)^3

        inc     %ecx        
        inc     %ecx        # -k+1
        call    *%edi       # output (-k+1)^3

        ret

cube:                       # eax = ecx^3
        pop     %esi 
        mov     %ecx, %eax
        imul    %ecx
        imul    %ecx

        push    %eax        # output cube
        jmp     *%esi       # ret

objdump:

00000005 <start>:
   5:   8d 3d 22 00 00 00       lea    0x22,%edi
   b:   ff d7                   call   *%edi
   d:   29 c8                   sub    %ecx,%eax
   f:   6a 06                   push   $0x6
  11:   5b                      pop    %ebx
  12:   f7 fb                   idiv   %ebx
  14:   89 c1                   mov    %eax,%ecx
  16:   ff d7                   call   *%edi
  18:   50                      push   %eax
  19:   f7 d1                   not    %ecx
  1b:   ff d7                   call   *%edi
  1d:   41                      inc    %ecx
  1e:   41                      inc    %ecx
  1f:   ff d7                   call   *%edi
  21:   c3                      ret    

00000022 <cube>:
  22:   5e                      pop    %esi
  23:   89 c8                   mov    %ecx,%eax
  25:   f7 e9                   imul   %ecx
  27:   f7 e9                   imul   %ecx
  29:   50                      push   %eax
  2a:   ff e6                   jmp    *%esi

---

यहां मेरा परीक्षण संस्करण है जो अंत में सभी क्यूबिंग करता है। मानों को स्टैक पर धकेलने के बाद, क्यूब लूप स्टैक मानों को अधिलेखित कर देता है। यह वर्तमान में 42 40 बाइट्स है, लेकिन कहीं न कहीं कुछ सुधार होना चाहिए।

.section .text
.globl main

main:
        mov     $10, %ecx       # n = 10

start:
        push    %ecx            # output n

        mov     %ecx, %eax
        imul    %ecx
        imul    %ecx
        sub     %ecx, %eax      # n^3 - n
                                # edx = 0 from imul

        push    $6
        pop     %ecx            # const 6        
        idiv    %ecx            # k = (n^3 - n)/6

        push    %eax            # output k
        push    %eax            # output k

        not     %eax            # -k-1        
        push    %eax            # output -k-1

        inc     %eax            
        inc     %eax            # -k+1
        push    %eax            # output -k+1

        dec     %ecx            # count = 5
        add     $20, %esp
cube:           
        mov     -4(%esp),%ebx   # load num from stack
        mov     %ebx, %eax
        imul    %ebx
        imul    %ebx            # cube 
        push    %eax            # output cube
        loop    cube            # --count; while (count)

        ret

Answer 20

मूल रूप से , 51 अक्षर, 55 बाइट्स

⇒-6-^0+7/0»8
$F:^0%@5-7/0»8^0%@5%@5f1+8^0%@5f1-8^0%

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

जाहिर तौर पर MDXF SBCS को लागू करना भूल गया ...

Answer 21

Unefunge 98 , 35 बाइट्स

j&3k:**-6/:1-\:1+\0\-::!#@_::**.37*

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

यह इस math.se उत्तर से लोकप्रिय सूत्र का उपयोग करता है ।

Answer 22

पर्ल 5 -nE, 48 बाइट्स

say$_**3for$i=($_**3-($n=$_))/6,$i,-1-$i,1-$i,$n

टोपी की नोक

Answer 23

पॉवरशेल कोर , 52 बाइट्स

$o,(1-($k=($o*$o-1)*$o/6)),(-$k-1),$k,$k|%{$_*$_*$_}

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

समीकरण का उपयोग करता है o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, जहां k=o^3 - o; यह लोकप्रिय l=o-o^3(के साथ k=-l) की एक छोटी सी refactoring है ।

साइड नोट के रूप में, अभिव्यक्ति l=o-o^3एक आहत कान के साथ बिल्ली की तरह दिखती है।

Answer 24

रूबी , 43 बाइट्स

->n{[~k=(n**3-n)/6,1-k,n,k,k].map{|i|i**3}}

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