Somme de cinq cubes

33

Avec un entier, sortez cinq cubes parfaits dont la somme est cet entier. Notez que les cubes peuvent être positifs, négatifs ou nuls. Par exemple,

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

-10vous pouvez donc générer des entrées [-64, -64, 64, 27, 27], même si d’autres solutions sont possibles. Notez que vous devez sortir les cubes et non les nombres en cubes.

Il existe toujours une solution : vous pouvez vous amuser à résoudre ce problème . On suppose en outre que quatre cubes suffisent.

Xnor
la source
Deux questions: Pouvons-nous produire un résultat, ou seulement le plus petit? Pour -10une autre solution possible pourrait être -1000+4574296+4410944-4492125-4492125par exemple. Et est-il autorisé à sortir --ou à la +-place de +/ -respectivement (c'est- 3 = 27+-27+-125--64--64à- dire à la place de 3 = 27-27-135+64+64)?
Kevin Cruijssen
@KevinCruijssen Tout résultat est bon. Si vous voulez dire sortie comme --5, je dirais non, conformément aux règles habituelles de sortie d'une expression .
xnor
@KevinCruijssen Il n'est pas nécessaire de générer une expression avec des +signes, mais uniquement des nombres.
xnor
-10 = -64 - 64 + 64 + 27 + 27ou-10 = -343 + 0 -8 +125 +216
Angs
3
Note intéressante: 3 n'est pas suffisant (certains nombres sont non représentables), mais il y en a dont la représentabilité est inconnue (telle que 33).
Esolanging Fruit

Réponses:

16

Brachylog , 18 octets

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

Essayez-le en ligne!

Explication

Nous décrivons essentiellement le problème, avec la contrainte supplémentaire que nous voulons que la liste de sortie ne soit pas croissante en termes de magnitudes: ceci force Brachylog à revenir correctement sur toutes les combinaisons possibles de 5 valeurs, au lieu de revenir à l'infini sur la valeur de la dernière. élément de la 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

Trouver des solutions différentes

En ajoutant a , il est possible d’utiliser ce prédicat pour trouver toutes les solutions d’importance croissante: voici , par exemple, les 10 premières solutions pour42

Fataliser
la source
14

Brachylog , 11 octets

Merci Fatalize pour la sauvegarde d'un octet

~+l₅≥₁.√₃ᵐ∧

Essayez-le en ligne!

En premier lieu ~+, la sortie ( .) doit additionner à l'entrée. l₅de nouveau contraint la sortie, en dictant qu'elle doit avoir une longueur de 5. ≥₁déclare que la liste doit être dans un ordre décroissant (je crois que cela est nécessaire pour empêcher le programme d'entrer dans une boucle infinie)

Nous unifions explicitement cette liste avec .la variable de sortie, car notre prédicat suivant "changera" les valeurs de la liste. Nous prenons ensuite la racine cubique de chaque valeur de la liste avec √₃ᵐ. Comme Brachylog est intrinsèquement basé sur un nombre entier, cela signifie que tous les nombres de la liste sont des nombres de cubes.

Enfin, nous utilisons parce qu’un implicite est .ajouté à la fin de chaque ligne. Puisque nous ne voulons .pas être unifiés avec la liste des racines de cubes, nous l'avons unifié plus tôt et utilisons pour l'empêcher d'unifier à la fin.

H.PWiz
la source
10

Python 2 , 58 57 54 octets

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

Essayez-le en ligne!


  • -2 octets, merci à Rod
  • -1 octet, merci à Neil
TFeld
la source
1
Vous pouvez économiser 2 octets en remplaçant le signalk=-(n-n**3)/6;[v**3for v in~k,1-k,n,k,k]
Rod
1
@Rod Pour -(n-n**3)ne pouvez-vous pas utiliser (n**3-n)?
Neil
@ Neil oui, vous pouvez.
Rod
9

Python 3 , 65 octets

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

Essayez-le en ligne!

Je veux dire, une formule explicite est même ici (bien qu'il ait résumé la construction derrière un existentiel)

Fuite, nonne
la source
Vous pouvez enregistrer exactement un octet en inversant ket en réécrivant votre équation. Essayez-le en ligne!
Jeff Freeman
Pourquoi s'embêter avec des cubes répétés? ie codegolf.stackexchange.com/a/161235/17360
qwr
7

Java 8, 178 87 73 71 65 octets

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

-6 octets grâce à @ OlivierGrégoire .

Même explication en bas, mais en utilisant l’équation de base à la place de celle que j’avais utilisée auparavant (grâce à la réponse Python 3 de @LeakyNun pour le conseil implicite):

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

Essayez-le en ligne.


Ancien 178 octets répondent:

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

Essayez-le en ligne.

Explication:

Je boucle à kpartir de 0 jusqu'à ce qu'une solution soit trouvée. A chaque itération, il vérifiera ces deux équations:

  • Positif k: n == n 3 + (k + 1) 3 + (k-1) 3 - k 3 - k 3
  • Négatif k: n == n 3 - (k + 1) 3 - (k-1) 3 + k 3 + k 3

Pourquoi?

Puisque n - n 3 = n * (1-n) * (1 + n) , puis 6 | (nn 3 ) , il est possible d’écrire n - n 3 = 6k .
6k = (k + 1) 3 + (k-1) 3 - k 3 - k 3 .
Et donc n = n 3 + (k + 1) 3 + (k-1) 3 - k 3 - k 3 pour certains k .
La source.

Kevin Cruijssen
la source
1
65 octets : n->new long[]{n*n*n,(n=(n-n*n*n)/6+1)*n*n--,--n*n*n,n=-++n*n*n,n}(ou 64 utilisant ints pour des résultats moins précis)
Olivier Grégoire
6

Gelée , 13 octets

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

Essayez-le en ligne!

Calculez la formule indépendamment. (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 octets: essayez-le en ligne!

utilisateur202729
la source
‘c3µ³;;;C;~*3devrait sauvegarder un octet depuis (n ^ 3-n) / 6 = C (n + 1, 3)
miles
5

Octave , 47 40 33 octets

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

Essayez-le en ligne!

Sauvegardé 6 octets grâce à Giuseppe, car j'avais oublié de supprimer certaines anciennes parenthèses. Sauvé un autre octet en changeant les signes, grâce à rafa11111.

Utilise la formule dans l'article math.se lié :

  1. Puisque n - n ^ 3 = n (1-n) (1 + n) alors 6 | (n - n ^ 3) et nous pouvons écrire n - n ^ 3 = 6k .
  2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Cela semble plus long si j'essaie de résoudre l'équation: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 en ce qui concerne k , au lieu de en utilisant l'équation.

Stewie Griffin
la source
3

Fonctions Minecraft (18w11a, 1.13 instantanés), 813 octets

cubes parfaits dans minecraft

Utilise six fonctions:

une

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

scoreboard players operation x c = x k

e

scoreboard players operation x b = x c

F

function e
function c

"Prend les entrées" d'un objectif de tableau de bord nommé n, créez-le avec /scoreboard objectives add n dummypuis définissez-le à l'aide de /scoreboard players set x n 5. Puis appelez la fonction en utilisant/function a

Utilise la formule de cette réponse math.se

Noskcaj
la source
2

JavaScript (Node.js) , 48 à 45 octets

  • merci à @Arnauld pour la réduction de 3 octets
n=>[n,1-(k=(n**3-n)/6|0),~k,k,k].map(x=>x**3)

Essayez-le en ligne!

DanielIndie
la source
1
Pourquoi |0? n**3-ndoit être un multiple de 6 pour un entier n.
Neil
2

MATL , 21 octets

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

Ceci essaye tous les 5 tuples de nombres de l'ensemble (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. C'est donc très inefficace.

Essayez-le en ligne!

Luis Mendo
la source
2

Haskell , 43 42 octets

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

Juste la réponse populaire, traduite en Haskell. Merci à @ rafa11111 pour la sauvegarde d'un octet!

Essayez-le en ligne!

Angs
la source
2
Vous pouvez enregistrer un octet en changeant le signe dans l' kassignation ...
rafa11111
2

Coque , 12 octets

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

Essayez-le en ligne!

Essaie toutes les listes possibles de 5 cubes et renvoie le premier avec la somme correcte.

Explication

ḟ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
Leo
la source
1

C (gcc) , 85 81 75 octets

Sauvegardé 4 octets puis 6 octets grâce à la réorganisation des assignations de @ 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;}

Essayez-le en ligne!

vazt
la source
1

Fortran (GFortran) , 53 octets

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

Essayez-le en ligne!

Python Fortran sortant du golf? Que se passe t-il ici?

rafa11111
la source
1

Python 3, 65 61 60 octets

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

Edit: laissé tomber des espaces inutiles.

Edit: merci à la réorganisation intelligente de rafa11111.

Inspiré par cela .

Essayez-le en ligne!

Guoyang Qin
la source
Vous pouvez enregistrer un octet en utilisant (N**3-N)et[N,1-k,-1-k,k,k]
rafa11111
1
@ rafa11111 réorganisation intelligente. Merci.
Guoyang Qin
1

R , 40 38 octets

Utilise la formule du message math.SE lié. Jusqu'à 2 octets grâce à Giuseppe.

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

Essayez-le en ligne!

tourbull
la source
38 octets
Giuseppe
1

APL (Dyalog Unicode) , 30 à 26 octets

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

Essayez-le en ligne!

Traduction APL de la réponse de LeakyNun .

Merci à Adám pour 4 octets en tacite.

Comment?

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é
la source
Désolé si j'ai manqué quelque chose, mais: 1) étant donné qu'il y a une tâche à accomplir, votre réponse n'est-elle pas un extrait? 2) bien que vous ayez utilisé 30 caractères, puisqu'il est en unicode, n'utilisez-vous pas 43 octets, comme indiqué dans tio?
rafa11111
1
@ rafa11111 Non et non: APL fonctionne étrangement dans TIO. L'affectation dans le champ «Code» n'est en réalité qu'un raccourci pour utiliser la fonction dans le champ «Entrée»; il est totalement inutile que le code actuel fonctionne. De plus, nous comptons chaque caractère comme un octet car pour Dyalog APL, nous utilisons le SBCS de @ Adám. Je peux ajouter le lien à la méta-publication pour l'expliquer plus tard, mais je suis actuellement sur mobile.
J. Sallé
Oh je vois. Je n'en savais rien. Merci de m'avoir expliqué!
rafa11111
1

Coque , 20 octets

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

Essayez-le en ligne!

Utilise la formule de ce post .

Explication

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
la source
1

x86, 41 39 octets

Implémentation plutôt simple de la formule avec entrée ecxet sortie sur la pile.

La chose intéressante est que j'ai utilisé une fonction de cubage, mais puisque call labelc'est 5 octets , je stocke l'adresse de l'étiquette et utilise les 2 octets call reg. De plus, comme je pousse des valeurs dans ma fonction, j'utilise un à la jmpplace de ret. Il est très possible qu'être intelligent avec une boucle et la pile évite d'appeler entièrement.

Je n'ai pas fait d'astuces de fantaisie avec cubing, comme utiliser (k+1)^3 = k^3 + 3k^2 + 3k + 1.

Changelog:

  • Correction du nombre d'octets en utilisant notau lieu de neg/ dec.

  • -2 octets en xornotant edxpuisqu'il est probablement 0 de 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

Voici ma version de test qui fait tout le cubage à la fin. Une fois les valeurs placées dans la pile, la boucle de cube remplace les valeurs de la pile. Il s’agit actuellement de 42 à 40 octets, mais des améliorations devraient être apportées quelque part.

.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
la source
0

Cubiquement , 51 caractères, 55 octets

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

Essayez-le en ligne!

Apparemment, MDXF a oublié de mettre en œuvre le SBCS ...

utilisateur202729
la source
0

Perl 5 -nE, 48 octets

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

pointe du chapeau

msh210
la source
0

PowerShell Core , 52 octets

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

Essayez-le en ligne!

Utilise l'équation o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, où k=o^3 - o; c'est un refactoring mineur du populaire l=o-o^3(avec k=-l).

Comme note de côté, l'expression l=o-o^3ressemble à un chat avec une oreille blessée.

Jeff Freeman
la source