Bir tamsayı verildiğinde, toplamı bu tamsayı olan beş mükemmel küp verin. Küplerin pozitif, negatif veya sıfır olabileceğini unutmayın. Örneğin,

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

Bu nedenle , başka çözümler de mümkün olsa da, giriş için -10çıktı alabilirsiniz [-64, -64, 64, 27, 27]. Küpleri çıkarmanız gerektiğine dikkat edin, küplenen sayıları değil.

Her zaman bir çözüm vardır - bu konuyu kendiniz şaşırtmaktan zevk alabilirsiniz. Ayrıca, dört küpün yeterli olduğuna kanaat getirdi.

Brachylog , 18 bayt

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

Çevrimiçi deneyin!

açıklama

Sorunu temel olarak, çıktı listesinin büyüklükler bakımından artmamasını istediğimiz ilave kısıtlama ile açıklıyoruz: bu, Brachylog'un son değerin değerini sınırsız geri almak yerine 5 değerin tüm olası kombinasyonlarını geriye doğru izlemesini sağlar listenin öğesi.

∧                ∧    (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

Farklı çözümler bulma

A ekleyerek ≜, bu yüklemeyi artan büyüklükteki tüm çözümleri bulmak için kullanmak mümkündür: örneğin, burada ilk 10 çözüm42

Brachylog , 11 bayt

Bir bayt tasarrufu için teşekkürler Fatalize

~+l₅≥₁.√₃ᵐ∧

Çevrimiçi deneyin!

Öncelikle ~+output ( .) 'un girdiyle toplanması gerektiğini zorlar . l₅yine 5'i sınırlandırıyor, 5 uzunluğuna sahip olması gerektiğini dikte ederek ≥₁, listenin azalan bir sırada olması gerektiğini söylüyor (bunun programın sonsuz bir döngüye girmesini durdurmak için gerekli olduğuna inanıyorum)

Bu listeyi ., çıktı değişkeniyle açıkça birleştiririz , çünkü bir sonraki yordamımız listedeki değerleri "değiştirir". Daha sonra listedeki her değerin küp kökünü alırız √₃ᵐ. Brachylog doğası gereği tamsayıya dayalı olduğundan, bu, listedeki tüm sayıların küp sayıları olduğunu belirtir.

Son olarak kullanıyoruz, ∧çünkü .her satırın sonuna eklenen bir kapalı alan var. .Küp kökleri listesiyle birleştirmek istemediğimiz için, daha önce bir araya getirdik ∧ve sonunda birleştirmeyi durdurmak için kullanıyoruz .

Python 2 , 58 57 54 bayt

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

Çevrimiçi deneyin!

• Çubuk sayesinde -2 bayt
• -1 bayt, Neil sayesinde

Python 3 , 65 bayt

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

Çevrimiçi deneyin!

Yani, açık bir formül bile burada (inşaatı varoluşun arkasına çekmesine rağmen).

Java 8, 178 87 73 71 65 bayt

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

@ OlivierGrégoire sayesinde 6 bayt .

Altta aynı açıklama, ancak daha önce kullandığım türev yerine temel denklemin kullanılması ( örtük ipucu için @LeakyNun Python 3 cevabı sayesinde ):

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

Çevrimiçi deneyin.

Eski 178 baytlık cevap:

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;}}

Çevrimiçi deneyin.

Açıklama:

I, döngü kbir çözelti oluşana dek 0 yukarı olan bulunur. Her yinelemede bu iki denklemi kontrol eder:

• Pozitif k: n == N ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Negatif k: n == N ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

Niye ya?

Yana nn ³ = n x (1-n) * (1 + n) ve daha sonra , 6 | (nn ³ ) , bu şekilde yazılabilir nn ³ = 6K .
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ .
Ve bu nedenle , n = n ' ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ bazıları için k .
Kaynak.

Jöle , 13 bayt

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

Çevrimiçi deneyin!

Formülü bağımsız olarak hesaplayın. (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.

Alternatif 13 bayt: Çevrimiçi deneyin!

Octave , 47 40 33 bayt

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

Çevrimiçi deneyin!

Bazı eski parantezleri almayı unuttuğumdan, Giuseppe sayesinde 6 bayt kurtardı. Rafa11111 sayesinde işaretleri değiştirerek başka bir bayt kurtardı.

Bağlantılı math.se yazısındaki formülü kullanır :

1. Yana n - n ^ 3 = n (1-n) (1 + n) , sonra 6 | (n - n ^ 3) yazabiliriz n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Ben çalışırsanız daha uzun gibi görünen çözmek denklemi: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 ile ilgili olarak k , yerine sadece denklemi kullanarak.

Minecraft İşlevleri (18w11a, 1.13 anlık görüntü), 813 bayt

Altı işlev kullanır:

bir

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

b

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

c

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

d

scoreboard players operation x c = x k

e

scoreboard players operation x b = x c

f

function e
function c

Adlı bir puan tahtası hedefinden "giriş alır" n, ile oluşturun /scoreboard objectives add n dummyve sonra onu kullanarak ayarlayın /scoreboard players set x n 5. Ardından işlevi kullanarak/function a

Bu math.se yanıtındaki formülü kullanır

JavaScript (Node.js) , 48 45 bayt

• @Arnauld, 3 byte'ı azalttığı için teşekkürler

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

Çevrimiçi deneyin!

MATL , 21 bayt

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

Bu, kümedeki tüm 5 tuple sayılarını dener. (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3 . Bu yüzden çok verimsiz.

Çevrimiçi deneyin!

Haskell , 43 42 bayt

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

Sadece popüler cevap, Haskell'e çevrilmiş. Bir bayt tasarrufu için @ rafa11111 için teşekkürler!

Çevrimiçi deneyin!

Kabuğu , 12 bayt

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

Çevrimiçi deneyin!

5 küpün tüm olası listelerini dener ve ilkini doğru toplamıyla döndürür.

açıklama

ḟ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

C (gcc) , 85 81 75 bayt

@ Ceilingcat'in siparişleri yeniden sıralaması sayesinde 4 byte sonra 6 byte kaydedildi

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;}

Çevrimiçi deneyin!

Fortran (GFortran) , 53 bayt

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

Çevrimiçi deneyin!

Fortran, Python'u Aşar mı? Burada neler oluyor?

Python 3, 65 61 60 bayt

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

Düzenleme: gereksiz bazı alanlar düştü.

Düzenleme: rafa11111'in akıllı yeniden siparişi sayesinde.

Esinlenen bu .

Çevrimiçi deneyin!

R , 40 38 bayt

Bağlantılı matematikteki formülü kullanır. Giuseppe sayesinde 2 bayta kadar.

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 30 26 bayt

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

Çevrimiçi deneyin!

LeakyNun'ın cevabının APL çevirisi .

4 baytlık Adám'a teşekkür ederim.

Nasıl?

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

Kabuğu , 20 bayt

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

Çevrimiçi deneyin!

Bu yayındaki formülü kullanır .

açıklama

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

x86, 41 39 bayt

ecxYığın üzerinde giriş ve çıkış ile formülün en basit şekilde uygulanması .

İşin ilginç yanı, bir küpleme işlevi kullanmam ama call label5 byte olduğundan , etiketin adresini saklıyorum ve 2 byte kullanıyorum call reg. Ayrıca, fonksiyonumdaki değerleri zorladığımdan jmpbunun yerine bir değer kullanıyorum ret. Bir döngü ve istif ile akıllı olmanın tamamen aramadan kaçınması çok olası.

Kullanarak olduğu gibi küpleme ile herhangi bir fantezi hileci yapmadım (k+1)^3 = k^3 + 3k^2 + 3k + 1 .

Değişiklikler:

• Bayt sayısını / notyerine kullanarak düzeltin .negdec

• -2 vermeyerek bayt xoring edxo muhtemelen 0'a olduğundan 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

İşte sondaki tüm küpleme yapan test sürümüm. Değerler yığına itildikten sonra, küp döngüsü yığın değerlerinin üzerine yazar. Şu anda 42 40 bayt ama bir yerlerde bazı iyileştirmeler olmalı.

.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

Kübik olarak , 51 karakter, 55 bayt

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

Çevrimiçi deneyin!

Görünüşe göre MDXF SBCS'yi uygulamayı unuttu ...

Unefunge 98 , 35 bayt

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

Çevrimiçi deneyin!

Bu math.se cevabındaki popüler formülü kullanır .

Perl 5 -nE, 48 bayt

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

şapka ucu

PowerShell Çekirdek , 52 bayt

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

Çevrimiçi deneyin!

Denklemi kullanır ; o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3nerede k=o^3 - o; Bu popüler üstlenmeden reşit olmaması l=o-o^3(ile k=-l).

Bir yan not olarak, ifade, l=o-o^3kulağı kırılmış bir kedi gibi görünür.

Ruby , 43 bayt

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

Çevrimiçi deneyin!