Biorąc pod uwagę liczbę całkowitą, wypisz pięć doskonałych kostek, których suma jest tą liczbą całkowitą. Zauważ, że kostki mogą być dodatnie, ujemne lub zero. Na przykład,

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

więc dla danych wejściowych -10można wyprowadzać dane [-64, -64, 64, 27, 27], chociaż możliwe są inne rozwiązania. Pamiętaj, że powinieneś generować kostki, a nie liczby w kostkach.

Rozwiązanie zawsze istnieje - możesz samemu rozwiązać zagadkę. Przypuszcza się ponadto, że wystarczą cztery kostki.

Brachylog , 18 bajtów

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

Wypróbuj online!

Wyjaśnienie

Zasadniczo opisujemy problem, z dodatkowym ograniczeniem, że chcemy, aby lista wyników nie zwiększała się pod względem wielkości: to zmusza Brachylog do prawidłowego śledzenia wszystkich możliwych kombinacji 5 wartości, zamiast nieskończonego cofania się w stosunku do wartości ostatniej element listy.

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

Znajdowanie różnych rozwiązań

Dołączając a ≜, można użyć tego predykatu, aby znaleźć wszystkie rozwiązania o rosnących rozmiarach: na przykład, oto pierwsze 10 rozwiązań dla42

Brachylog , 11 bajtów

Dzięki Fatalize za uratowanie jednego bajtu

~+l₅≥₁.√₃ᵐ∧

Wypróbuj online!

Po pierwsze ~+wymusza, że ​​wyjście ( .) musi sumować się z danymi wejściowymi. l₅ponownie ogranicza wynik, dyktując, że musi on mieć długość 5. ≥₁deklaruje, że lista musi być w porządku malejącym (uważam, że jest to konieczne, aby zatrzymać program wchodzący w nieskończoną pętlę)

Wyraźnie ujednolicamy tę listę ze .zmienną wyjściową, ponieważ nasz następny predykat „zmieni” wartości na liście. Następnie pobieramy pierwiastek sześcienny każdej wartości z listy za pomocą √₃ᵐ. Ponieważ Brachylog jest z natury oparty na liczbach całkowitych, dyktuje to, że wszystkie liczby na liście są liczbami kostek.

Wreszcie używamy, ∧ponieważ .na końcu każdej linii jest niejawnie dodane. Ponieważ nie chcemy .być zunifikowani z listą pierwiastków kostki, ujednoliciliśmy ją wcześniej i używamy ∧do zatrzymania jej zjednoczenia na końcu.

Python 2 , 58 57 54 bajtów

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

Wypróbuj online!

• -2 bajty, dzięki Rod
• -1 bajt, dzięki Neilowi

Python 3 , 65 bajtów

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

Wypróbuj online!

To znaczy, wyraźny formuła jest jeszcze tutaj (choć oderwana budowę za egzystencjalny)

Java 8, 178 87 73 71 65 bajtów

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

-6 bajtów dzięki @ OlivierGrégoire .

To samo wyjaśnienie na dole, ale przy użyciu równania podstawowego zamiast pochodnego, którego użyłem wcześniej (dzięki odpowiedzi Python 3 @LeakyNun na niejawną wskazówkę):

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

Wypróbuj online.

Stara 178 bajtów odpowiedź:

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

Wypróbuj online.

Wyjaśnienie:

Pętlę kod 0 w górę, aż do znalezienia rozwiązania. W każdej iteracji sprawdzi te dwa równania:

• Pozytywne k: n == n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Ujemne k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

Czemu?

Ponieważ n - n ³ = n * (1-n) * (1 + n), a następnie 6 | (nn ³ ) , można go zapisać jako n - n ³ = 6k .
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ .
I dlatego n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ dla niektórych k .
Źródło.

Galaretka , 13 bajtów

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

Wypróbuj online!

Oblicz formułę niezależnie. (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.

Alternatywne 13 bajtów: Wypróbuj online!

Oktawa , 47 40 33 bajtów

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

Wypróbuj online!

Zaoszczędziłem 6 bajtów dzięki Giuseppe, ponieważ zapomniałem usunąć stare nawiasy. Zaoszczędził kolejne bajty, zmieniając znaki, dzięki rafa11111.

Używa formuły w połączonym poście math.se :

1. Ponieważ n - n ^ 3 = n (1-n) (1 + n), to 6 | (n - n ^ 3) i możemy napisać n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Wydaje się być dłuższy, jeśli spróbuję rozwiązać równanie: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 w odniesieniu do k , zamiast po prostu używając równania.

Funkcje Minecraft (18w11a, migawki 1.13), 813 bajtów

Korzysta z sześciu funkcji:

za

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

do

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

re

scoreboard players operation x c = x k

mi

scoreboard players operation x b = x c

fa

function e
function c

„Pobiera dane wejściowe” z nazwanego celu tablicy wyników n, utwórz go, /scoreboard objectives add n dummya następnie ustaw za pomocą /scoreboard players set x n 5. Następnie wywołaj funkcję za pomocą/function a

Używa formuły z tej odpowiedzi matematycznej

JavaScript (Node.js) , 48 45 bajtów

• dzięki @Arnauld za zmniejszenie 3 bajtów

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

Wypróbuj online!

MATL , 21 bajtów

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

Spróbuje wszystkich 5 krotek liczb z zestawu (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. Jest to więc bardzo nieefektywne.

Wypróbuj online!

Haskell , 43 42 bajty

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

Tylko popularna odpowiedź przetłumaczona na Haskell. Dzięki @ rafa11111 za uratowanie bajtu!

Wypróbuj online!

Łuska , 12 bajtów

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

Wypróbuj online!

Próbuje wszystkich możliwych list 5 kostek i zwraca pierwszą z poprawną sumą.

Wyjaśnienie

ḟ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 bajtów

Zaoszczędzono 4 bajty, a następnie 6 bajtów dzięki zmianie kolejności przydziałów @ ceilingcat

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

Wypróbuj online!

Fortran (GFortran) , 53 bajty

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

Wypróbuj online!

Fortran outgolfing Python? Co tu się dzieje?

Python 3, 65 61 60 bajtów

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

Edycja: usunięto niepotrzebne spacje.

Edycja: dzięki inteligentnej zmianie kolejności rafa11111.

Zainspirowany tym .

Wypróbuj online!

R , 40 38 bajtów

Wykorzystuje formułę w powiązanym poście math.SE. Do 2 bajtów dzięki Giuseppe.

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

Wypróbuj online!

APL (Dyalog Unicode) , 30 26 bajtów

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

Wypróbuj online!

Tłumaczenie APL odpowiedzi LeakyNun .

Dzięki Adám za 4 bajty, idąc milcząco.

W jaki sposób?

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

Łuska , 20 bajtów

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

Wypróbuj online!

Używa formuły z tego postu .

Wyjaśnienie

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

x 86, 41 39 bajtów

Najczęściej prosta implementacja formuły z wejściem ecxi wyjściem na stosie.

Interesujące jest to, że użyłem funkcji dzielenia, ale ponieważ call labeljest to 5 bajtów , przechowuję adres etykiety i używam 2 bajtów call reg. Ponadto, ponieważ wypycham wartości w mojej funkcji, używam jmpzamiastret . Jest bardzo możliwe, że bycie sprytnym z pętlą i stosem może całkowicie uniknąć sprawdzania.

Nie robiłem żadnych fantazyjnych sztuczek z kostką, jak używanie (k+1)^3 = k^3 + 3k^2 + 3k + 1 .

Dziennik zmian:

• Napraw liczbę bajtów za pomocą notzamiast neg/ dec.

• -2 bajty, nie xoring, edxponieważ prawdopodobnie jest to 0 z 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

Oto moja wersja testowa, która wykonuje całą kostkę na końcu. Po wypchnięciu wartości na stos pętla kostki zastępuje wartości stosu. Obecnie ma 42 40 bajtów, ale gdzieś powinny być jakieś ulepszenia.

.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

Sześciennie , 51 znaków, 55 bajtów

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

Wypróbuj online!

Najwyraźniej MDXF zapomniał wdrożyć SBCS ...

Unefunge 98 , 35 bajtów

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

Wypróbuj online!

Wykorzystuje popularną formułę z odpowiedzi matematycznej .

Perl 5 -nE, 48 bajtów

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

czapka z daszkiem

PowerShell Core , 52 bajty

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

Wypróbuj online!

Korzysta z równania o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, gdzie k=o^3 - o; jest to niewielkie refaktoryzacja popularnego l=o-o^3(z k=-l).

Na marginesie, wyrażenie l=o-o^3wygląda jak kot z bolącym uchem.

Rubinowy , 43 bajty

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

Wypróbuj online!