Dato un numero intero, genera cinque cubi perfetti la cui somma è quel numero intero. Si noti che i cubi possono essere positivi, negativi o zero. Per esempio,

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

quindi per l'input -10potresti produrre [-64, -64, 64, 27, 27], anche se sono possibili altre soluzioni. Nota che dovresti produrre i cubi, non i numeri che vengono cubati.

Esiste sempre una soluzione : potresti divertirti a scervellarlo da solo. Si ipotizza inoltre che siano sufficienti quattro cubi.

Brachylog , 18 byte

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

Provalo online!

Spiegazione

Fondamentalmente descriviamo il problema, con l'ulteriore vincolo che vogliamo che la lista di output non sia in aumento in termini di grandezza: questo costringe Brachylog a tornare indietro correttamente su tutte le possibili combinazioni di 5 valori, invece di tornare indietro all'infinito sul valore dell'ultimo elemento dell'elenco.

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

Trovare soluzioni diverse

Aggiungendo a ≜, è possibile utilizzare questo predicato per trovare tutte le soluzioni con dimensioni crescenti: ad esempio, ecco le prime 10 soluzioni per42

Brachylog , 11 byte

Grazie Fatalize per aver salvato un byte

~+l₅≥₁.√₃ᵐ∧

Provalo online!

Innanzitutto ~+impone che l'output ( .) debba essere sommato all'input. l₅limita nuovamente l'output, dettando che deve avere una lunghezza di 5. ≥₁dichiara che l'elenco deve essere in ordine decrescente (credo che ciò sia necessario per impedire al programma di entrare in un ciclo infinito)

Unifichiamo esplicitamente questo elenco con .la variabile di output, perché il nostro prossimo predicato "cambierà" i valori all'interno dell'elenco. Quindi prendiamo la radice del cubo di ciascun valore nell'elenco con √₃ᵐ. Poiché Brachylog è intrinsecamente basato su numeri interi, ciò indica che tutti i numeri nell'elenco sono numeri cubici.

Infine, usiamo ∧perché c'è un implicito .aggiunto alla fine di ogni riga. Dal momento che non vogliamo .essere unificati con l'elenco delle radici del cubo, l'abbiamo unificato in precedenza e lo usiamo ∧per impedirne l'unificazione alla fine.

Python 2 , 58 57 54 byte

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

Provalo online!

• -2 byte, grazie a Rod
• -1 byte, grazie a Neil

Python 3 , 65 byte

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

Provalo online!

Voglio dire, una formula esplicita è anche qui (anche se ha sottratto la costruzione dietro un esistenziale)

Java 8, 178 87 73 71 65 byte

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

-6 byte grazie a @ OlivierGrégoire .

Stessa spiegazione in fondo, ma usando l'equazione di base invece di quella derivata che ho usato prima (grazie alla risposta Python 3 di @LeakyNun per il suggerimento implicito):

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

Provalo online.

I vecchi 178 byte rispondono:

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

Provalo online.

Spiegazione:

Ciclo kda 0 in su fino a trovare una soluzione. In ogni iterazione controllerà queste due equazioni:

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

Perché?

Poiché n - n ³ = n * (1-n) * (1 + n) e quindi 6 | (nn ³ ) , può essere scritto come n - n ³ = 6k .
6k = (k + 1) ³ + (k-1) ³ - k ³ - k ³ .
E quindi n = n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³ per alcuni k .
Fonte.

Gelatina , 13 byte

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

Provalo online!

Scopri la formula in modo indipendente. (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.

Alternativo 13 byte: provalo online!

Ottava , 47 40 33 byte

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

Provalo online!

Risparmio di 6 byte grazie a Giuseppe, poiché avevo dimenticato di rimuovere alcune vecchie parentesi. Salvati altri byte modificando i segni, grazie a rafa11111.

Utilizza la formula nel post math.se collegato :

1. Poiché n - n ^ 3 = n (1-n) (1 + n), quindi 6 | (n - n ^ 3) e possiamo scrivere n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Sembra più lungo se provo a risolvere l'equazione: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 rispetto a k , invece che solo usando l'equazione.

Funzioni di Minecraft (18w11a, istantanee 1.13), 813 byte

Utilizza sei funzioni:

un'

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

"Prende input" da un obiettivo del tabellone chiamato n, crearlo con /scoreboard objectives add n dummye quindi impostarlo utilizzando /scoreboard players set x n 5. Quindi chiamare la funzione utilizzando/function a

Usa la formula da questa risposta math.se

JavaScript (Node.js) , 48 45 byte

• grazie a @Arnauld per la riduzione di 3 byte

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

Provalo online!

MATL , 21 byte

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

Questo prova tutte le 5 tuple di numeri dal set (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. Quindi è molto inefficiente.

Provalo online!

Haskell , 43 42 byte

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

Solo la risposta popolare, tradotta in Haskell. Grazie a @ rafa11111 per aver salvato un byte!

Provalo online!

Buccia , 12 byte

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

Provalo online!

Cerca tutti i possibili elenchi di 5 cubi e restituisce il primo con la somma corretta.

Spiegazione

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

Salvato 4 byte e quindi 6 byte grazie al riordino delle assegnazioni di @ 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;}

Provalo online!

Fortran (GFortran) , 53 byte

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

Provalo online!

Fortran sta superando Python? Cosa sta succedendo qui?

Python 3, 65 61 60 byte

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

Modifica: eliminati alcuni spazi non necessari.

Modifica: grazie al riordino intelligente di rafa11111.

Ispirato da questo .

Provalo online!

R , 40 38 byte

Utilizza la formula nel post math.SE collegato. Fino a 2 byte grazie a Giuseppe.

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

Provalo online!

APL (Dyalog Unicode) , 30 26 byte

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

Provalo online!

Traduzione APL della risposta di LeakyNun .

Grazie ad Adám per 4 byte andando tacito.

Come?

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

Buccia , 20 byte

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

Provalo online!

Usa la formula di questo post .

Spiegazione

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 byte

Implementazione per lo più semplice della formula con input ecxe output in pila.

La cosa interessante è che ho usato una funzione cubing, ma dato che call labelè di 5 byte , memorizzo l'indirizzo dell'etichetta e utilizzo il 2 byte call reg. Inoltre, poiché sto spingendo i valori nella mia funzione, uso jmpinvece di ret. È molto probabile che essere intelligenti con un loop e lo stack possa evitare di chiamare completamente.

Non ho fatto trucchi fantasiosi con i cubetti, come usare (k+1)^3 = k^3 + 3k^2 + 3k + 1.

changelog:

• Correggi il conteggio dei byte utilizzando notinvece di neg/ dec.

• -2 byte non xoring in edxquanto probabilmente è 0 da 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

Ecco la mia versione di prova che fa tutto il cubing alla fine. Dopo che i valori sono stati inseriti nello stack, il ciclo del cubo sovrascrive i valori dello stack. Attualmente è di 42 40 byte, ma da qualche parte dovrebbero esserci dei miglioramenti.

.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

Cubicamente , 51 caratteri, 55 byte

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

Provalo online!

Apparentemente MDXF ha dimenticato di implementare SBCS ...

Unefunge 98 , 35 byte

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

Provalo online!

Esso utilizza la formula popolare da questa risposta math.se .

Perl 5 -nE, 48 byte

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

cappello-punta

PowerShell Core , 52 byte

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

Provalo online!

Utilizza l'equazione o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, dove k=o^3 - o; questo è un piccolo refactoring del popolare l=o-o^3(con k=-l).

Come nota a margine, l'espressione l=o-o^3sembra un gatto con un orecchio ferito.

Rubino , 43 byte

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

Provalo online!