Dado un entero, genera cinco cubos perfectos cuya suma es ese entero. Tenga en cuenta que los cubos pueden ser positivos, negativos o cero. Por ejemplo,

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

por lo tanto, para la entrada -10puede salir [-64, -64, 64, 27, 27], aunque son posibles otras soluciones. Tenga en cuenta que debe generar los cubos, no los números que se están cubicando.

Siempre existe una solución : es posible que disfrute de resolver esto por sí mismo. Se conjetura además que cuatro cubos son suficientes.

Brachylog , 18 bytes

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

Pruébalo en línea!

Explicación

Básicamente describimos el problema, con la restricción adicional de que queremos que la lista de salida no aumente en términos de magnitudes: esto obliga a Brachylog a retroceder adecuadamente sobre todas las combinaciones posibles de 5 valores, en lugar de retroceder infinitamente sobre el valor del último elemento de la lista.

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

Encontrar diferentes soluciones

Al agregar a ≜, es posible usar este predicado para encontrar todas las soluciones con magnitudes crecientes: por ejemplo, aquí están las 10 primeras soluciones para42

Brachylog , 11 bytes

Gracias Fatalize por guardar un byte

~+l₅≥₁.√₃ᵐ∧

Pruébalo en línea!

En primer lugar, ~+exige que la salida ( .) debe sumar a la entrada. l₅nuevamente restringe la salida, dictando que debe tener una longitud de 5. ≥₁declara que la lista debe estar en orden decreciente (creo que esto es necesario para evitar que el programa entre en un bucle infinito)

Unificamos explícitamente esta lista con .la variable de salida, porque nuestro próximo predicado "cambiará" los valores dentro de la lista. Luego tomamos la raíz cúbica de cada valor en la lista con √₃ᵐ. Dado que Brachylog está intrínsecamente basado en enteros, esto dicta que todos los números en la lista son números de cubo.

Finalmente, usamos ∧porque hay un implícito .agregado al final de cada línea. Como no queremos .unificarnos con la lista de raíces cúbicas, la unificamos antes y la usamos ∧para evitar que se unifique al final.

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]

Pruébalo en línea!

• -2 bytes, gracias a Rod
• -1 byte, gracias a 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]

Pruébalo en línea!

Quiero decir, una fórmula explícita está incluso aquí (aunque resumió la construcción detrás de un existencial)

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 gracias a @ OlivierGrégoire .

La misma explicación en la parte inferior, pero usando la ecuación base en lugar de la derivada que usé antes (gracias a la respuesta de Python 3 de @LeakyNun por la sugerencia implícita):

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

Pruébalo en línea.

Antigua respuesta de 178 bytes:

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

Pruébalo en línea.

Explicación:

Doy un bucle kdesde 0 hacia arriba hasta que se encuentra una solución. En cada iteración verificará estas dos ecuaciones:

• Positivo k: n == n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Negativo k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

¿Por qué?

Como n - n ³ = n * (1-n) * (1 + n) y luego 6 | (nn ³ ) , se puede escribir como n - n ³ = 6k .
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ .
Y por lo tanto n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ para algunos k .
Fuente.

Jalea , 13 bytes

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

Pruébalo en línea!

Descubre la fórmula de forma independiente. (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.

Alternativa de 13 bytes: ¡ Pruébelo en línea!

Octava , 47 40 33 bytes

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

Pruébalo en línea!

Ahorré 6 bytes gracias a Giuseppe, ya que había olvidado eliminar algunos paréntesis antiguos. Ahorró otros bytes cambiando los signos, gracias a rafa11111.

Utiliza la fórmula en la publicación math.se vinculada :

1. Como n - n ^ 3 = n (1-n) (1 + n), entonces 6 | (n - n ^ 3) y podemos escribir n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Parece ser más largo si trato de resolver la ecuación: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 con respecto a k , en lugar de solo usando la ecuación.

Funciones de Minecraft (18w11a, 1.13 instantáneas), 813 bytes

Utiliza seis funciones:

una

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

si

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

F

function e
function c

"Toma datos" de un objetivo del marcador nombrado n, créalo con /scoreboard objectives add n dummyy luego configúrelo usando /scoreboard players set x n 5. Luego llame a la función usando/function a

Utiliza la fórmula de esta respuesta matemática.

JavaScript (Node.js) , 48 45 bytes

• gracias a @Arnauld por reducir 3 bytes

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

Pruébalo en línea!

MATL , 21 bytes

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

Esto intenta todas las 5 tuplas de números del conjunto (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. Entonces es muy ineficiente.

Pruébalo en línea!

Haskell , 43 42 bytes

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

Solo la respuesta popular, traducida a Haskell. ¡Gracias a @ rafa11111 por guardar un byte!

Pruébalo en línea!

Casco , 12 bytes

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

Pruébalo en línea!

Intenta todas las listas posibles de 5 cubos y devuelve el primero con la suma correcta.

Explicación

ḟ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

Se guardaron 4 bytes y luego 6 bytes gracias al reordenamiento de las asignaciones 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;}

Pruébalo en línea!

Fortran (GFortran) , 53 bytes

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

Pruébalo en línea!

¿Fortran superando a Python? ¿Que está pasando aqui?

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

Editar: dejó caer algunos espacios innecesarios.

Editar: gracias al reordenamiento inteligente de rafa11111.

Inspirado por esto .

Pruébalo en línea!

R , 40 38 bytes

Hace uso de la fórmula en la publicación matemática vinculada. Hasta 2 bytes gracias a Giuseppe.

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

Pruébalo en línea!

APL (Dyalog Unicode) , 30 26 bytes

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

Pruébalo en línea!

Traducción APL de la respuesta de LeakyNun .

Gracias a Adám por 4 bytes yendo tácito.

¿Cómo?

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

Casco , 20 bytes

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

Pruébalo en línea!

Utiliza la fórmula de esta publicación .

Explicación

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

Implementación principalmente directa de la fórmula con entrada ecxy salida en la pila.

Lo interesante es que usé una función de cubing, pero como call labelson 5 bytes , almaceno la dirección de la etiqueta y uso el byte 2 call reg. Además, como estoy empujando valores en mi función, uso un en jmplugar de ret. Es muy posible que ser inteligente con un bucle y la pila evite llamar por completo.

No hice ningún truco elegante con cubos, como usar (k+1)^3 = k^3 + 3k^2 + 3k + 1.

Registro de cambios:

• Fix byte recuento usando noten lugar de neg/ dec.

• -2 bytes por no xoring edxya que probablemente sea 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

Aquí está mi versión de prueba que hace todos los cubos al final. Después de que los valores se introducen en la pila, el bucle de cubo sobrescribe los valores de la pila. Actualmente es de 42 40 bytes, pero debería haber algunas mejoras en alguna parte.

.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

Cúbicamente , 51 caracteres, 55 bytes

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

Pruébalo en línea!

Aparentemente, MDXF olvidó implementar el SBCS ...

Unefunge 98 , 35 bytes

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

Pruébalo en línea!

Utiliza la fórmula populares desde esta respuesta math.se .

Perl 5 -nE, 48 bytes

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

punta de sombrero

PowerShell Core , 52 bytes

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

Pruébalo en línea!

Utiliza la ecuación o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, donde k=o^3 - o; esta es una refactorización menor de lo popularl=o-o^3 (conk=-l ).

Como nota al margen, la expresión l=o-o^3parece un gato con una oreja lastimada.

Ruby , 43 bytes

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

Pruébalo en línea!