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.

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

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.

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

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)

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

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 ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Négatif k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

Pourquoi?

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

Gelée , 13 octets

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

Essayez-le en ligne!

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

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.

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

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

ré

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

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!

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!

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!

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

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!

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?

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!

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!

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

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

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

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

Unfunge 98 , 35 octets

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

Essayez-le en ligne!

Il utilise la formule populaire de cette réponse math.se .

Perl 5 -nE, 48 octets

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

pointe du chapeau

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.

Ruby , 43 octets

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

Essayez-le en ligne!