Bei einer gegebenen Ganzzahl werden fünf perfekte Würfel ausgegeben, deren Summe diese Ganzzahl ist. Beachten Sie, dass Würfel positiv, negativ oder null sein können. Beispielsweise,

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

Für die Eingabe können -10Sie also eine Ausgabe durchführen [-64, -64, 64, 27, 27], obwohl auch andere Lösungen möglich sind. Beachten Sie, dass Sie die Würfel ausgeben sollten, nicht die Zahlen, die gewürfelt werden.

Es gibt immer eine Lösung - vielleicht haben Sie Spaß daran, dies selbst herauszufinden. Es wird weiter vermutet, dass vier Würfel ausreichen.

Brachylog , 18 Bytes

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

Probieren Sie es online!

Erläuterung

Wir beschreiben das Problem im Grunde genommen mit der zusätzlichen Einschränkung, dass die Ausgabeliste in Bezug auf die Größen nicht ansteigen soll: Dies zwingt Brachylog, alle möglichen Kombinationen von 5 Werten ordnungsgemäß zurückzuverfolgen, anstatt den Wert des letzten Wertes unendlich zurückzuverfolgen Element der Liste.

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

Verschiedene Lösungen finden

Durch Anhängen von a ≜ist es möglich, mit diesem Prädikat alle Lösungen mit zunehmender Größe zu finden: Hier sind beispielsweise die ersten 10 Lösungen für42

Brachylog , 11 Bytes

Danke Fatalize für das Speichern eines Bytes

~+l₅≥₁.√₃ᵐ∧

Probieren Sie es online!

Erstens ~+erzwingt , daß der Ausgang ( .) an die Eingangssumme muß. l₅schränkt die Ausgabe erneut ein und schreibt vor, dass sie eine Länge von 5 haben ≥₁muss

Wir vereinheitlichen diese Liste explizit mit .der Ausgabevariablen, da unser nächstes Prädikat die Werte in der Liste "ändert". Wir nehmen dann die Kubikwurzel von jedem Wert in der Liste mit √₃ᵐ. Da Brachylog von Natur aus ganzzahlig ist, bedeutet dies, dass alle Zahlen in der Liste Würfelnummern sind.

Schließlich verwenden wir, ∧weil .am Ende jeder Zeile ein impliziter Zusatz steht. Da wir nicht .mit der Liste der Kubikwurzeln vereinheitlicht werden möchten , haben wir sie früher vereinheitlicht und ∧beenden sie am Ende mit.

Python 2 , 58 57 54 Bytes

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

Probieren Sie es online!

• -2 Bytes, danke an Rod
• -1 Byte, danke an Neil

Python 3 , 65 Bytes

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

Probieren Sie es online!

Ich meine, eine explizite Formel gibt es auch hier (obwohl er die Konstruktion hinter einer existenziellen abstrahiert)

Java 8, 178 87 73 71 65 Bytes

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

-6 Bytes dank @ OlivierGrégoire .

Dieselbe Erklärung unten, aber unter Verwendung der Basisgleichung anstelle der abgeleiteten, die ich zuvor verwendet habe (dank der Antwort von @LeakyNun in Python 3 für den impliziten Tipp):

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

Probieren Sie es online aus.

Alte 178 Bytes Antwort:

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

Probieren Sie es online aus.

Erläuterung:

Ich schleife kvon 0 aufwärts, bis eine Lösung gefunden wird. In jeder Iteration werden diese beiden Gleichungen überprüft:

• Positiv k: n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Negativ k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

Warum?

Da n - n ³ = n * (1 - n) * (1 + n) und dann 6 | (nn ³ ) ist , kann es als n - n ³ = 6k geschrieben werden .
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ .
Und deshalb ist n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ für einige k .
Quelle.

Jelly , 13 Bytes

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

Probieren Sie es online!

Finde die Formel unabhängig heraus. (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.

Alternative 13 Bytes: Probieren Sie es online!

Oktave , 47 40 33 Bytes

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

Probieren Sie es online!

Dank Giuseppe 6 Bytes gespart, da ich vergessen hatte, alte Klammern zu entfernen. Sparte dank rafa11111 weitere Bytes durch Ändern der Vorzeichen.

Verwendet die Formel im verknüpften Beitrag von math.se :

1. Da n - n ^ 3 = n (1-n) (1 + n), dann 6 | (n - n ^ 3) und wir können schreiben n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Es scheint länger zu sein, wenn ich versuche , die Gleichung zu lösen : (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 in Bezug auf k , anstatt nur unter Verwendung der Gleichung.

Minecraft-Funktionen (18w11a, 1.13 Schnappschüsse), 813 Bytes

Verwendet sechs Funktionen:

ein

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

"Nimmt Eingaben" von einem Scoreboard-Ziel mit dem Namen n, erstelle es mit /scoreboard objectives add n dummyund setze es dann mit /scoreboard players set x n 5. Rufen Sie dann die Funktion mit auf/function a

Verwendet die Formel aus dieser math.se-Antwort

JavaScript (Node.js) , 48-45 Byte

• Danke an @Arnauld für die Reduzierung von 3 Bytes

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

Probieren Sie es online!

MATL , 21 Bytes

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

Dies versucht alle 5-Tupel von Zahlen aus dem Satz (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. Es ist also sehr ineffizient.

Probieren Sie es online!

Haskell , 43 42 Bytes

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

Nur die beliebte Antwort, übersetzt nach Haskell. Vielen Dank an @ rafa11111 für das Speichern eines Bytes!

Probieren Sie es online!

Schale , 12 Bytes

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

Probieren Sie es online!

Versucht alle möglichen Listen mit 5 Würfeln und gibt den ersten mit der korrekten Summe zurück.

Erläuterung

ḟ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 Bytes

4 Bytes und dann 6 Bytes dank @ ceilingcats Neuordnung der Zuordnungen gespart

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

Probieren Sie es online!

Fortran (GFortran) , 53 Bytes

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

Probieren Sie es online!

Fortran, das Python ausgolft? Was ist hier los?

Python 3, 65 61 60 Bytes

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

Bearbeiten: Es wurden unnötige Leerzeichen entfernt.

Bearbeiten: dank der intelligenten Neuordnung von rafa11111.

Davon inspiriert .

Probieren Sie es online!

R , 40 38 Bytes

Verwendet die Formel im verknüpften math.SE-Beitrag. Bis zu 2 Bytes dank Giuseppe.

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

Probieren Sie es online!

APL (Dyalog Unicode) , 30 26 Bytes

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

Probieren Sie es online!

APL-Übersetzung der Antwort von LeakyNun .

Vielen Dank an Adám für 4 Bytes.

Wie?

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

Schale , 20 Bytes

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

Probieren Sie es online!

Verwendet die Formel aus diesem Beitrag .

Erläuterung

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 Bytes

Meist unkomplizierte Umsetzung der Formel mit Ein- ecxund Ausgabe auf dem Stack.

Das Interessante ist, dass ich eine Cubing-Funktion verwendet habe, aber da sind call labeles 5 Bytes , speichere ich die Adresse des Etiketts und verwende die 2 Bytes call reg. Da ich in meiner Funktion Werte pushe, verwende ich jmpstatt ret. Es ist sehr wahrscheinlich, dass ein geschickter Umgang mit einer Schleife und dem Stack einen Aufruf ganz vermeiden kann.

Ich habe keine ausgefallenen Tricks mit Würfeln gemacht, wie mit (k+1)^3 = k^3 + 3k^2 + 3k + 1.

Änderungsprotokoll:

• Anzahl der Bytes korrigieren mit notanstelle von neg/dec .

• -2 Bytes von nicht xoring , edxda es wahrscheinlich 0 aus ist 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

Objektspeicherauszug:

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

Hier ist meine Testversion, die das Cubing am Ende erledigt. Nachdem die Werte auf den Stapel verschoben wurden, überschreibt die Cube-Schleife die Stapelwerte. Derzeit sind es 42 bis 40 Bytes, aber irgendwo sollte es einige Verbesserungen geben.

.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

Kubisch , 51 Zeichen, 55 Bytes

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

Probieren Sie es online!

Anscheinend hat MDXF vergessen, das SBCS zu implementieren ...

Unefunge 98 , 35 Bytes

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

Probieren Sie es online!

Es wird die beliebte Formel aus dieser math.se-Antwort verwendet .

Perl 5 -nE, 48 Bytes

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

Hutspitze

PowerShell Core , 52 Byte

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

Probieren Sie es online!

Verwendet die Gleichung o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, wo k=o^3 - o; Dies ist ein kleines Refactoring des Populären l=o-o^3(mit k=-l).

Als Randnotiz l=o-o^3sieht der Ausdruck aus wie eine Katze mit einem verletzten Ohr.

Ruby , 43 Bytes

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

Probieren Sie es online!