Cho một số nguyên, xuất ra năm khối hoàn hảo có tổng là số nguyên đó. Lưu ý rằng hình khối có thể là dương, âm hoặc bằng không. Ví dụ,

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

Vì vậy, đối với đầu vào, -10bạn có thể xuất ra [-64, -64, 64, 27, 27], mặc dù các giải pháp khác là có thể. Lưu ý rằng bạn nên xuất các hình khối, không phải các số được lập phương.

Một giải pháp luôn tồn tại - bạn có thể thích tự đánh đố điều này. Nó tiếp tục phỏng đoán rằng bốn khối đủ.

Brachylog , 18 byte

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

Hãy thử trực tuyến!

Giải trình

Về cơ bản, chúng tôi mô tả vấn đề, với ràng buộc bổ sung mà chúng tôi muốn danh sách đầu ra không tăng về độ lớn: điều này buộc Brachylog phải quay lại chính xác trên tất cả các kết hợp 5 giá trị có thể, thay vì quay ngược lại vô hạn so với giá trị cuối cùng yếu tố của danh sách.

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

Tìm giải pháp khác nhau

Bằng cách nối thêm a ≜, có thể sử dụng vị từ này để tìm tất cả các giải pháp với cường độ tăng dần: ví dụ: đây là 10 giải pháp đầu tiên cho42

Brachylog , 11 byte

Cảm ơn Fatalize đã lưu một byte

~+l₅≥₁.√₃ᵐ∧

Hãy thử trực tuyến!

Đầu tiên ~+thực thi rằng đầu ra ( .) phải tổng hợp với đầu vào. l₅một lần nữa ràng buộc đầu ra, ra lệnh rằng nó phải có độ dài 5. ≥₁tuyên bố rằng danh sách phải theo thứ tự giảm dần (tôi tin rằng điều này là cần thiết để dừng chương trình đi vào một vòng lặp vô hạn)

Chúng tôi thống nhất rõ ràng danh sách này với ., biến đầu ra, bởi vì vị từ tiếp theo của chúng tôi sẽ "thay đổi" các giá trị bên trong danh sách. Sau đó chúng tôi lấy căn bậc ba của từng giá trị trong danh sách với √₃ᵐ. Vì Brachylog vốn dựa trên số nguyên, điều này cho thấy rằng tất cả các số trong danh sách là số khối.

Cuối cùng, chúng tôi sử dụng ∧vì có một ẩn .được thêm vào cuối mỗi dòng. Vì chúng tôi không muốn .thống nhất với danh sách các khối lập phương, chúng tôi đã thống nhất nó sớm hơn và sử dụng ∧để ngăn chặn việc thống nhất ở cuối.

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]

Hãy thử trực tuyến!

• -2 byte, nhờ có Rod
• -1 byte, nhờ 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]

Hãy thử trực tuyến!

Ý tôi là, một công thức rõ ràng thậm chí còn ở đây (mặc dù ông đã trừu tượng hóa việc xây dựng đằng sau một sự tồn tại)

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 nhờ @ OlivierGrégoire .

Cùng một lời giải thích ở phía dưới, nhưng sử dụng phương trình cơ sở thay vì phương trình dẫn xuất mà tôi đã sử dụng trước đó (nhờ câu trả lời Python 3 của @LeakyNun cho mẹo ẩn):

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

Hãy thử trực tuyến.

Câu trả lời cũ 178 byte:

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

Hãy thử trực tuyến.

Giải trình:

Tôi lặp ktừ 0 trở lên cho đến khi tìm thấy giải pháp. Trong mỗi lần lặp, nó sẽ kiểm tra hai phương trình sau:

• Tích cực k: n == n ³ + (k + 1) ³ + (k-1) ³ - k ³ - k ³
• Phủ định k: n == n ³ - (k + 1) ³ - (k-1) ³ + k ³ + k ³

Tại sao?

Vì n - n ³ = n * (1-n) * (1 + n) và sau đó là 6 | (nn ³ ) , nên nó có thể được viết là n - n ³ = 6k .
6k = (k + 1) ³ + (k - 1) ³ - k ³ - k ³ .
Và do đó n = n ³ + (k + 1) ³ + (k - 1) ³ - k ³ - k ³ với một số k .
Nguồn.

Thạch , 13 byte

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

Hãy thử trực tuyến!

Chỉ ra công thức độc lập. (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 byte thay thế: Hãy thử trực tuyến!

Octave , 47 40 33 byte

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

Hãy thử trực tuyến!

Đã lưu 6 byte nhờ Giuseppe, vì tôi đã quên xóa một số dấu ngoặc đơn cũ. Đã lưu một byte khác bằng cách thay đổi các dấu hiệu, nhờ rafa11111.

Sử dụng công thức trong bài math.se được liên kết :

1. Kể từ n - n ^ 3 = n (1-n) (1 + n) sau đó 6 | (n - n ^ 3) và chúng ta có thể viết n - n ^ 3 = 6k .
2. 6k = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 .

Nó dường như dài hơn nếu tôi cố gắng giải phương trình: (nn ^ 3) = (k + 1) ^ 3 + (k-1) ^ 3 - k ^ 3 - k ^ 3 liên quan đến k , thay vì chỉ sử dụng phương trình.

Hàm Minecraft (18w11a, ảnh chụp nhanh 1,13), 813 byte

Sử dụng sáu chức năng:

một

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

"Lấy đầu vào" từ một mục tiêu bảng điểm được đặt tên n, tạo nó với /scoreboard objectives add n dummyvà sau đó đặt nó bằng cách sử dụng /scoreboard players set x n 5. Sau đó gọi hàm bằng/function a

Sử dụng công thức từ câu trả lời math.se này

JavaScript (Node.js) , 48 45 byte

• cảm ơn @Arnauld vì đã giảm 3 byte

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

Hãy thử trực tuyến!

MATL , 21 byte

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

Điều này sẽ thử tất cả 5 bộ số từ bộ (-abs(n))^3, (-abs(n)+1)^3, ..., abs(n)^3. Vì vậy, nó là rất không hiệu quả.

Hãy thử trực tuyến!

Haskell , 43 42 byte

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

Chỉ là câu trả lời phổ biến, được dịch sang Haskell. Cảm ơn @ rafa11111 vì đã tiết kiệm một byte!

Hãy thử trực tuyến!

Husk , 12 byte

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

Hãy thử trực tuyến!

Thử tất cả các danh sách có thể có của 5 hình khối và trả về cái đầu tiên với tổng chính xác.

Giải trình

ḟ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

Đã lưu 4 byte và sau đó là 6 byte nhờ sắp xếp lại các bài tập

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

Hãy thử trực tuyến!

Fortran (GFortran) , 53 byte

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

Hãy thử trực tuyến!

Fortran vượt trội hơn Python? Những gì đang xảy ra ở đây?

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

Chỉnh sửa: bỏ một số khoảng trống không cần thiết.

Chỉnh sửa: nhờ sắp xếp lại thông minh của rafa11111.

Lấy cảm hứng từ điều này .

Hãy thử trực tuyến!

R , 40 38 byte

Làm cho việc sử dụng công thức trong bài toán.SE được liên kết. Xuống tới 2 byte nhờ Giuseppe.

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 30 26 byte

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

Hãy thử trực tuyến!

Bản dịch APL của câu trả lời của LeakyNun .

Cảm ơn Adám cho 4 byte bằng cách đi ngầm.

Làm sao?

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

Husk , 20 byte

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

Hãy thử trực tuyến!

Sử dụng công thức từ bài viết này .

Giải trình

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

Chủ yếu là thực hiện đơn giản công thức với đầu vào ecxvà đầu ra trên ngăn xếp.

Điều thú vị là tôi đã sử dụng hàm tạo khối, nhưng vì call labellà 5 byte , tôi lưu địa chỉ của nhãn và sử dụng 2 byte call reg. Ngoài ra, vì tôi đang đẩy các giá trị trong hàm của mình, tôi sử dụng jmpthay thế ret. Rất có thể là thông minh với một vòng lặp và ngăn xếp có thể tránh được việc gọi hoàn toàn.

Tôi đã không làm bất kỳ thủ thuật ưa thích nào với hình khối, như sử dụng (k+1)^3 = k^3 + 3k^2 + 3k + 1.

Thay đổi:

• Sửa lỗi đếm byte bằng cách sử dụng notthay vì neg/ dec.

• -2 byte bằng cách không xoring edxvì nó có thể là 0 từ 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

Đây là phiên bản thử nghiệm của tôi, tất cả các hình khối ở cuối. Sau khi các giá trị được đẩy trên ngăn xếp, vòng lặp khối sẽ ghi đè lên các giá trị ngăn xếp. Hiện tại nó có 42 40 byte nhưng cần có một số cải tiến ở đâu đó.

.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

Về cơ bản , 51 ký tự, 55 byte

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

Hãy thử trực tuyến!

Rõ ràng MDXF đã quên thực hiện SBCS ...

Hủy kết nối 98 , 35 byte

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

Hãy thử trực tuyến!

Nó sử dụng công thức phổ biến từ câu trả lời math.se này .

Perl 5 -nE, 48 byte

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

Đầu mũ

Lõi PowerShell , 52 byte

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

Hãy thử trực tuyến!

Sử dụng phương trình o=o^3 + (1-k)^3 + (-k-1)^3 + k^3 + k^3, ở đâu k=o^3 - o; đây là một cấu trúc nhỏ của phổ biếnl=o-o^3 (với k=-l).

Như một lưu ý phụ, biểu hiện l=o-o^3trông giống như một con mèo bị đau tai.

Ruby , 43 byte

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

Hãy thử trực tuyến!