Summe von fünf Würfeln

33

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.

xnor
quelle
Zwei Fragen: Können wir ein Ergebnis ausgeben oder nur das kleinste? Eine -10andere mögliche Lösung könnte -1000+4574296+4410944-4492125-4492125beispielsweise sein. Und darf ausgegeben werden --oder +-anstelle von +/ -bzw. (dh 3 = 27+-27+-125--64--64anstelle von 3 = 27-27-135+64+64)?
Kevin Cruijssen
@ KevinCruijssen Jedes Ergebnis ist in Ordnung. Wenn du Ausgabe wie meinst --5, würde ich nein sagen, wie es bei der Ausgabe eines Ausdrucks üblich ist .
XNOR
@KevinCruijssen Sie müssen keinen Ausdruck mit +Vorzeichen ausgeben, sondern nur die Zahlen.
XNOR
-10 = -64 - 64 + 64 + 27 + 27oder-10 = -343 + 0 -8 +125 +216
Angs
3
Interessante Anmerkung: 3 ist nicht ausreichend (einige Zahlen sind nicht darstellbar), aber es gibt einige Zahlen, deren Darstellbarkeit unbekannt ist (z. B. 33).
Esolanging Fruit

Antworten:

16

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

Tödlich
quelle
14

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.

H.PWiz
quelle
10

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
TFeld
quelle
1
Sie können 2 Bytes speichern, die das Signal tauschenk=-(n-n**3)/6;[v**3for v in~k,1-k,n,k,k]
Rod
1
@ Rod für -(n-n**3)kannst du nicht benutzen (n**3-n)?
Neil
@Neil ja, das kannst du.
Rod
9

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)

Undichte Nonne
quelle
Sie können genau ein Byte speichern, indem Sie kIhre Gleichung invertieren und neu schreiben. Probieren Sie es online!
Jeff Freeman
Warum sollte man sich mit wiederholten Würfeln beschäftigen? ie codegolf.stackexchange.com/a/161235/17360
qwr
7

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 3 ) / 6
n == n 3 + (k + 1) 3 + (k - 1) 3 - k 3 - k 3

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 3 + (k + 1) 3 + (k-1) 3 - k 3 - k 3
  • Negativ k: n == n 3 - (k + 1) 3 - (k-1) 3 + k 3 + k 3

Warum?

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

Kevin Cruijssen
quelle
1
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}(oder 64 mit Ints für weniger genaue Ergebnisse)
Olivier Grégoire
6

Jelly , 13 Bytes

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

Probieren Sie es online!

Finde die Formel unabhängig heraus. (x + 1) 3 + (x-1) 3 - 2 × x 3 == 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!

user202729
quelle
‘c3µ³;;;C;~*3sollte ein Byte speichern, da (n ^ 3-n) / 6 = C (n + 1, 3)
Meilen
5

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.

Stewie Griffin
quelle
3

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

perfekte Würfel in Minecraft

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

Noskcaj
quelle
2

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!

DanielIndie
quelle
1
Warum |0? n**3-nmuss ein Vielfaches von 6 für eine Ganzzahl sein n.
Neil
2

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!

Luis Mendo
quelle
2

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!

Angs
quelle
2
Sie können ein Byte speichern, k
indem
2

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
Löwe
quelle
1

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!

vazt
quelle
1

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!

Guoyang Qin
quelle
Sie können ein Byte mit (N**3-N)und[N,1-k,-1-k,k,k]
rafa11111
1
@ rafa11111 Intelligente Neuordnung. Vielen Dank.
Guoyang Qin
1

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!

rturnbull
quelle
38 Bytes
Giuseppe
1

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
J. Sallé
quelle
Tut mir leid, wenn ich etwas verpasst habe, aber: 1) da in tio eine Aufgabe vorliegt, ist Ihre Antwort hier nicht nur ein Ausschnitt? 2) Obwohl Sie 30 Zeichen verwendet haben, da es sich um Unicode handelt, werden nicht 43 Byte verwendet, wie in tio gezeigt?
Rafa11111
1
@ rafa11111 Nein und nein: APL funktioniert in TIO komisch. Die Zuweisung im Feld "Code" ist eigentlich nur eine Abkürzung zur Verwendung der Funktion im Feld "Eingabe". Es ist völlig unnötig, dass der eigentliche Code funktioniert. Außerdem zählen wir jedes Zeichen als ein Byte, da wir für Dyalog APL das SBCS von @ Adám verwenden. Ich kann den Link zum Meta-Post hinzufügen, um ihn später zu erklären, bin aber gerade auf dem Handy.
J. Sallé
Oh, ich verstehe. Davon wusste ich nichts. Danke fürs Erklären!
Rafa11111
1

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
Fyr
quelle
1

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
qwr
quelle
0

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 ...

user202729
quelle
0

Perl 5 -nE, 48 Bytes

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

Hutspitze

msh210
quelle
0

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.

Jeff Freeman
quelle