给定一个整数，输出五个总和为该整数的理想立方体。请注意，多维数据集可以是正数，负数或零。例如，

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

因此对于输入-10您可以输出[-64, -64, 64, 27, 27]，尽管其他解决方案也是可行的。请注意，您应该输出多维数据集，而不是要输出的数字。

始终存在解决方案-您可能会为自己感到困惑。进一步推测四个立方体就足够了。

Brachylog，18个字节

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

在线尝试！

说明

我们基本上描述了该问题，并附加了一个约束，即我们希望输出列表的幅度不增加：这迫使Brachylog在5个值的所有可能组合上正确地回溯，而不是在最后一个值上无限地回溯列表的元素。

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

寻找不同的解决方案

通过附加一个 ≜，可以使用该谓词查找幅度增加的所有解决方案：例如，这是前10个解决方案42

Brachylog，11个字节

感谢Fatalize保存一个字节

~+l₅≥₁.√₃ᵐ∧

在线尝试！

首先~+要求输出（.）必须与输入求和。l₅再次限制输出，指示其长度必须为5。≥₁声明该列表必须以降序排列（我相信这对于阻止程序进入无限循环是必须的）

我们通过以下方式明确统一此列表 .输出变量，因为我们的下一个谓词将“更改”列表中的值。然后，使用来获取列表中每个值的立方根√₃ᵐ。由于Brachylog本质上是基于整数的，因此这表明列表中的所有数字都是多维数据集数字。

最后，我们使用，∧因为在.每行的末尾添加了一个隐式。由于我们不想.与多维数据集根目录列表统一，因此我们在较早时对其∧进行了统一，并在最后将其停止使用。

Python 2中，58个 57 54字节

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

在线尝试！

• -2个字节，感谢Rod
• -1字节，感谢尼尔

Python 3，65个字节

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

在线尝试！

我的意思是，即使在这里也有一个明确的公式（尽管他抽象了存在主义背后的构造）

Java 8，178 87 73 71 65字节

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

-6个字节，感谢@OlivierGrégoire。

底部也有相同的解释，但使用基本方程式而不是我之前使用的派生方程式（由于@LeakyNun的Python 3答案为隐式技巧）：

k =（n-n ³）/ 6
n == n ³ +（k + 1）³ +（k-1）³ -k ³ -k ³

在线尝试。

旧的178字节答案：

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

在线尝试。

说明：

我k从0向上循环直到找到解决方案。在每次迭代中，它将检查以下两个方程式：

• 正数k：n == n ³ +（k + 1）³ +（k-1）³ -k ³ -k ³
• 负数k：n == n ^3-（k + 1）^3-（k-1）³ + k ³ + k ³

为什么？

由于n-n ³ = n *（1-n）*（1 + n）然后是6 |（nn ³），因此可以写成n-n ³ = 6k。
6k =（k + 1）³ +（k-1）³ -k ³ -k ³。
因此，对于某些k，n = n ³ +（k + 1）³ +（k-1）³ -k ³ -k ³。资源。

果冻，13个字节

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

在线尝试！

独立找出公式。（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.

备用13个字节：在线尝试！

八度，47 40 33字节

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

在线尝试！

感谢Giuseppe，节省了6个字节，因为我忘了删除一些旧的括号。多亏了rafa11111，通过更改符号节省了另一个字节。

使用链接的math.se post中的公式：

1. 由于n-n ^ 3 = n（1-n）（1 + n），所以6 | （n-n ^ 3），我们可以写n-n ^ 3 = 6k。
2. 6k =（k + 1）^ 3 +（k-1）^ 3-k ^ 3-k ^ 3。

如果我尝试求解方程，它看起来会更长一些：（nn ^ 3）=（k + 1）^ 3 +（k-1）^ 3-k ^ 3-k ^ 3关于k，而不是使用等式。

Minecraft函数（18w11a，1.13个快照），813字节

使用六个功能：

一种

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

Ë

scoreboard players operation x b = x c

F

function e
function c

从名为计分板的目标“获取输入” n，使用创建它，/scoreboard objectives add n dummy然后使用进行设置/scoreboard players set x n 5。然后使用/function a

使用此math.se答案中的公式

JavaScript（Node.js），48 45字节

• 感谢@Arnauld减少了3个字节

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

在线尝试！

MATL，21字节

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

这将从set中尝试所有5元组的数字(-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3。因此它效率很低。

在线尝试！

Haskell，43 42字节

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

只是流行的答案，翻译为Haskell。感谢@ rafa11111节省了一个字节！

在线尝试！

外壳，12个字节

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

在线尝试！

尝试所有可能的5个多维数据集列表，并返回具有正确总和的第一个。

说明

ḟ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字节

@ceilingcat的分配重新排序，节省了4个字节，然后节省了6个字节

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

在线尝试！

Fortran（GFortran），53个字节

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

在线尝试！

Fortran超越Python？这里发生了什么？

Python 3，65 61 60字节

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

编辑：删除一些不必要的空格。

编辑：感谢rafa11111的智能重新排序。

灵感来自此。

在线尝试！

R，40 38字节

在链接的math.SE帖子中使用该公式。少了2个字节，感谢Giuseppe。

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

在线尝试！

APL（Dyalog Unicode），30 26字节

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

在线尝试！

APL翻译LeakyNun的答案。

感谢Adám保持默认状态的4个字节。

怎么样？

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

外壳，20字节

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

在线尝试！

使用这篇文章中的公式。

说明

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

86，41 39个字节

公式的最直接实现是ecx在堆栈中输入和输出。

有趣的是，我使用了cubing函数，但是由于call label是5字节，因此我存储标签的地址并使用2字节call reg。另外，由于我要在函数中推送值，因此我使用jmp代替ret。巧妙地使用循环和堆栈可以避免完全调用。

我没有像使用那样做任何花哨的小技巧(k+1)^3 = k^3 + 3k^2 + 3k + 1。

变更日志：

• 使用not代替neg/ 修复字节数dec。

• xor-ing -2个字节，edx因为可能为0 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

这是我的测试版本，可以完成所有提示。将值压入堆栈后，多维数据集循环将覆盖堆栈值。当前是42个 40字节，但是应该在某些地方进行一些改进。

.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

三次，51个字符，55字节

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

在线尝试！

显然，MDXF忘记了实施SBCS ...

Unefunge 98，35个字节

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

在线尝试！

它使用此math.se答案中的常用公式。

Perl 5，48 -nE个字节

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

帽尖

PowerShell核心，52字节

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

在线尝试！

使用等式o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3，其中k=o^3 - o; 这是对流行的l=o-o^3（k=-l）。

作为附带说明，表情l=o-o^3看起来像只耳朵受伤的猫。

红宝石，43个字节

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

在线尝试！