bài tập

Nhiệm vụ của bạn là xây dựng một cấu trúc với $n$ khối. Thể tích khối theo trình tự sau (dưới -> trên)

$n^3, (n-1)^3, (n-2)^3,...,1^3$

đầu vào

Tổng khối lượng của cấu trúc ( ).$V$

đầu ra

giá trị của ( ), tức là: Tổng số khối.$n$

$V = n^3 + (n-1)^3 + .... + 1^3$

ghi chú

• Đầu vào sẽ luôn là một số nguyên.
• Đôi khi không thể theo trình tự, nghĩa là: không đại diện cho một giá trị cụ thể cho n . Trong sự kiện đó, trả về -1 hoặc giá trị sai lệch do bạn chọn (mặc dù tính nhất quán là bắt buộc).$V$$n$
• Đây là môn đánh gôn để câu trả lời ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.
• Không có câu trả lời sẽ được đánh dấu chấp nhận cho lý do nêu trên.

yêu cầu

• Đây là thử thách đầu tiên của tôi trên trang web, vì vậy hãy kiên nhẫn và tha thứ (và cho tôi biết về) bất kỳ sai lầm nào mà tôi đã gây ra.
• Vui lòng cung cấp một liên kết để mã của bạn có thể được kiểm tra.
• Nếu bạn có thể, vui lòng viết một lời giải thích về cách mã của bạn hoạt động, để người khác có thể hiểu và đánh giá cao công việc của bạn.

ví dụ

input  : 4183059834009
output : 2022

input  : 2391239120391902
output : -1

input  : 40539911473216
output : 3568

Cảm ơn @Arnauld về liên kết này:

Điều đó không tốt

Liên kết với orignial: Liên kết

JavaScript (ES7), 31 byte

Một công thức trực tiếp. Trả về 0nếu không có giải pháp.

v=>(r=(1+8*v**.5)**.5)%1?0:r>>1

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

Làm sao?

Tổng của n khối đầu tiên được cho bởi:$S_n$$n$

(Đây là A000537 . Công thức này có thể dễ dàng được chứng minh bằng cảm ứng. Dưới đây là một biểu diễn đồ họa đẹp của )$S_5$

Đối ứng lại, nếu là tổng của các khối x đầu tiên , phương trình sau thừa nhận một nghiệm nguyên, dương:$v$$x$

Vì là dương, điều này dẫn đến:$(x^2+x)/2$

Giải pháp tích cực được đưa ra bởi:

Nếu là một số nguyên, nó được đảm bảo để trở thành một trong những kỳ lạ, bởi vìΔbản thân là số lẻ. Do đó, giải pháp có thể được thể hiện như sau:$r=\sqrt{\Delta}$$\Delta$

Đã bình luận

v =>                    // v = input
  ( r =                 //
    (1 + 8 * v ** .5)   // delta = 1 + 8.sqrt(v)
    ** .5               // r = sqrt(delta)
  ) % 1 ?               // if r is not an integer:
    0                   //   return 0
  :                     // else:
    r >> 1              //   return floor(r / 2)

Phiên bản đệ quy, 36 35 byte

Trả về NaNnếu không có giải pháp.

f=(v,k=1)=>v>0?1+f(v-k**3,k+1):0/!v

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

Đã bình luận

f = (v,                   // v = input
        k = 1) =>         // k = current value to cube
  v > 0 ?                 // if v is still positive:
    1 +                   //   add 1 to the final result
    f(                    //   do a recursive call with:
      v - k ** 3,         //     the current cube subtracted from v
      k + 1               //     the next value to cube
    )                     //   end of recursive call
  :                       // else:
    0 / !v                //   add either 0/1 = 0 if v is zero, or 0/0 = NaN if v is
                          //   non-zero (i.e. negative); NaN will propagate all the
                          //   way to the final output

05AB1E , 6 byte

ÝÝOnIk

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

Câu trả lời của Jonathan Jonathan Jelly. Lấy tiền tích lũy của [0 ... n] , vuông mỗi và tìm ra chỉ số của V .

05AB1E , 7 byte

ÝÝ3mOIk

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

Làm thế nào nó hoạt động

ÝÝ3mOIk – Full program.
ÝÝ      – Yield [[0], [0, 1], [0, 1, 2], ... [0, 1, 2, ... V]].
  3mO   – Raise to the 3rd power.
     Ik – And find the index of the input therein. Outputs -1 if not found.

Thay thế 8 byte : ÝÝÅΔ3mOQ.

R , 42 40 byte

-2 byte nhờ Giuseppe

function(v,n=((1+8*v^.5)^.5-1)/2)n*!n%%1

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

Câu trả lời JavaScript của cảng Arnauld . Cũng trả về 0 nếu không có giải pháp.

Thạch ,  5  4 byte

RIJi

Một liên kết đơn, năng suất 0nếu không thể.

Hãy thử trực tuyến! cách quá không hiệu quả cho các trường hợp thử nghiệm! (O (V) không gian: p)

Đây là phiên bản 8 byte thực hiện một khối lập phương của V trước tiên để biến nó thành O (V ^ (1/3)). Sử dụng phiên bản 8 byte đó ở đây là một bộ thử nghiệm

Làm sao?

RIJi - Link: integer, V
R    - range of v -> [1,2,3,...,V]
 Ä   - cumulative sums -> [1,3,6,...,(1+2+3+...+V)]
  ²  - square -> [1,9,36,...,(1+2+3++...+V)²] ( =[1³,1³+2³,1³+2³+3³,...,(1³+2³+3³+...+V³)] )
   i - first 1-based index of v? (0 if not found)

Thuốc tiên , 53 byte

&Enum.find_index 0..&1,fn n->&1*4==n*n*(n+1)*(n+1)end

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

Câu trả lời của Jonathan Jonathan Jelly.

Thuốc tiên , 74 byte

fn v->Enum.find_index 0..v,&v==Enum.sum Enum.map(0..&1,fn u->u*u*u end)end

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

Chắc chắn là tối ưu phụ. Nhưng tôi chỉ là một người mới chơi Elixir! :) Trả về nilgiá trị "không hợp lệ" của V.

Japt, 7 byte

o³å+ bU

Thử nó

Giải trình

            :Implicit input of integer U
o           :Range [0,U)
 ³          :Cube each
  å+        :Cumulatively reduce by addition
     bU     :0-based index of U

Thay thế

Çõ³xÃbU

Thử nó

Cubix , 27 byte (hoặc khối lượng 27?)

Có vẻ như đúng nơi cho ngôn ngữ này.

I@.1OW30pWpP<s)s;;q\.>s-.?/

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

Điều này kết thúc vào một khối 3x3x3 như sau

      I @ .
      1 O W
      3 0 p
W p P < s ) s ; ; q \ .
> s - . ? / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Xem nó chạy

Nó cần thiết các lực lượng vũ phu bằng cách tăng khối lượng ra khỏi đầu vào. Nếu kết quả bằng 0, hãy xuất nkhác nếu có kết quả âm, in 0 và thoát.

Perl 6 , 30 29 26 byte

-4 byte nhờ Jo King

{first :k,.sqrt,[\+] ^1e4}

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

Giải pháp Brute-force cho n <10000. Sử dụng phương trình từ câu trả lời của Jonathan Allan. Giải pháp 37 36 byte cho n lớn hơn ( -1 byte nhờ Jo King ):

{!.[*-1]&&$_-2}o{{$_,*-$++³...1>*}}

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

Trả về Falsenếu không có giải pháp.

Giải trình

               o  # Combination of two anonymous Blocks
                {                 }  # 1st Block
                 {               }   # Reset anonymous state variable $
                  $_,*-$++³...1>*    # Sequence n,n,n-1³,n-1³-2³,... while positive
{             }  # 2nd Block
 !.[*-1]&&       # Return False if last element is non-zero
          $_-2   # Return length of sequence minus two otherwise

JavaScript (Node.js) , 28 byte

a=>a**.5%1?0:(2*a**.5)**.5|0

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

Tôi biết đó là câu hỏi của riêng tôi và tất cả, nhưng tôi đã có câu trả lời tốt hơn (cho lang này) sau đó có mặt, vì vậy tôi đã đăng. Hy vọng nó ổn

APL (Dyalog) , 18 byte

{o×⍵≥o←⍵⍳⍨+\3*⍨⍳⍵}

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

Matlab, 27 byte

@(v)find(cumsum(1:v).^2==v)

Trả về nnếu tồn tại hoặc một ma trận trống nếu không.

Làm thế nào nó hoạt động

            1:v            % Creates a 1xV matrix with values [1..V]
     cumsum(   )           % Cumulative sum
                .^2        % Power of 2 for each matrix element
                   ==v     % Returns a 1xV matrix with ones where equal to V
find(                 )    % Returns a base-1 index of the first non-zero element

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

Lưu ý Nó không thành công lớn vdo giới hạn bộ nhớ.

Python 3 , 60 byte

lambda V:[*[(n*-~n/2)**2for n in range(V+1)],V].index(V)%-~V

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

-6 cảm ơn ông Xcoder .

Nếu chúng ta có thể đưa ra một lỗi trong trường hợp không có $n$ cho một đặc biệt $V$, chúng ta có thể giảm xuống còn 51 byte:

lambda V:[(n*-~n/2)**2for n in range(V+1)].index(V)

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

Perl 6 , 33 byte

{$!+>1 if ($!=sqrt 1+8*.sqrt)%%1}

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

Điều này sử dụng phương pháp của Arnauld . Trả về một đối tượng rỗng nếu số không hợp lệ.

dc , 19 byte

4*dvvdddk*+d*-0r^K*

Đầu vào và đầu ra là từ ngăn xếp, trả về 0 nếu không có giải pháp.

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

Giải trình

Nếu có một giải pháp n, đầu vào là ((n^2+n)^2)/4. Vì vậy, chúng tôi sẽ tính toán một giải pháp thử nghiệm như n=sqrt(sqrt(4*input)), sử dụng mặc định 0 thập phân vị trí chính xác dc cho căn bậc hai, sau đó so sánh (n^2+n)^2để 4*inputđể xem nếu nó thực sự là một giải pháp.

4*dvv         Calculate a trial solution n (making a copy of 4*input for later use)
dddk          Store the trial solution in the precision and make a couple copies of it
*+d*          Calculate (n^2+n)^2
-             Subtract from our saved copy of 4*input - now we have 0 iff n is a solution
0r^           Raise 0 to that power - we now have 1 if n is a solution, 0 if not
K*            Multiply by our saved trial solution

Dòng áp chót dựa trên một thực tế không rõ ràng là dc, 0^x=0cho tất cả các khác không x(thậm chí âm x!) Nhưng 0^0=1.

Python 3 , 53 48 byte

f=lambda V,n=1:V>0and f(V-n**3,n+1)or(not V)*n-1

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

-3 byte từ Jo King

Trả về -1không có câu trả lời.

Chỉ hoạt động n=997với giới hạn đệ quy mặc định.

Liên tục lấy các khối lớn hơn và lớn hơn từ âm lượng cho đến khi nó về 0 (thành công, trả lại số khối bị loại bỏ) hoặc số âm (không có câu trả lời).

Giải trình:

f=lambda V,n=1: # f is a recursive lambda taking the volume and the cube size (defaulting to 1)

               V>0and               # if the volume is positive
                      f(V-n**3,n+1) # then we are not to the right cube size yet, try again with n+1, removing the volume of the nth cube

                                   or # if V is not positive
                                     (not V)*n-1
                         # case V == 0:
                         # (not V)*n == n; return n-1, the number of cubes
                         # case V < 0:
                         # (not V)*n == 0; return -1, no answer

mã gvm (cam kết 2612106 ), 70 59 byte

(-11 byte bằng cách nhân trong một vòng lặp thay vì viết mã để nhân hai lần)

Hexdump:

> hexdump -C cubes.bin
00000000  e1 0a 00 10 00 1a 03 d3  8a 00 f6 2a fe 25 c8 d3  |...........*.%..|
00000010  20 02 2a 04 0a 01 1a 02  00 00 20 08 4a 01 fc 03  | .*....... .J...|
00000020  d1 6a 02 52 02 cb f8 f4  82 04 f4 e8 d1 6a 03 0a  |.j.R.........j..|
00000030  03 fc d5 a8 ff c0 1a 00  a2 00 c0                 |...........|
0000003b

Chạy thử:

> echo 0 | ./gvm cubes.bin
0
> echo 1 | ./gvm cubes.bin
1
> echo 2 | ./gvm cubes.bin
-1
> echo 8 | ./gvm cubes.bin
-1
> echo 9 | ./gvm cubes.bin
2
> echo 224 | ./gvm cubes.bin
-1
> echo 225 | ./gvm cubes.bin
5

Không thực sự là một điểm thấp, chỉ sử dụng câu hỏi hay này để kiểm tra gvmở đây;) Cam kết cũ hơn câu hỏi tất nhiên. Lưu ý đây là máy ảo 8 bit, vì vậy sử dụng một số mã chỉ xử lý phạm vi số không dấu tự nhiên0-255 , các trường hợp thử nghiệm được đưa ra trong câu hỏi sẽ không hoạt động.

Lắp ráp thủ công từ đây:

0100  e1         rud                     ; read unsigned decimal
0101  0a 00      sta     $00             ; store to $00 (target sum to reach)
0103  10 00      ldx     #$00            ; start searching with n = #0
0105  1a 03      stx     $03             ; store to $03 (current cube sum)
0107  d3         txa                     ; X to A
                   loop:
0108  8a 00      cmp     $00             ; compare with target sum
010a  f6 2a      beq     result          ; equal -> print result
010c  fe 25      bcs     error           ; larger -> no solution, print -1
010e  c8         inx                     ; increment n
010f  d3         txa                     ; as first factor for power
0110  20 02      ldy     #$02            ; multiply #02 times for ...
0112  2a 04      sty     $04             ; ... power (count in $04)
                   ploop:
0114  0a 01      sta     $01             ; store first factor to $01 ...
0116  1a 02      stx     $02             ; ... and second to $02 for multiplying
0118  00 00      lda     #$00            ; init product to #0
011a  20 08      ldy     #$08            ; loop over 8 bits
                   mloop1:
011c  4a 01      lsr     $01             ; shift right first factor
011e  fc 03      bcc     noadd1          ; shifted bit 0 -> skip adding
0120  d1         clc                     ; 
0121  6a 02      adc     $02             ; add second factor to product
                   noadd1:
0123  52 02      asl     $02             ; shift left second factor
0125  cb         dey                     ; next bit
0126  f8 f4      bpl     mloop1          ; more bits -> repeat
0128  82 04      dec     $04             ; dec "multiply counter" for power
012a  f4 e8      bne     ploop           ; not 0 yet -> multiply again
012c  d1         clc
012d  6a 03      adc     $03             ; add power to ...
012f  0a 03      sta     $03             ; ... current cube sum
0131  fc d5      bcc     loop            ; repeat unless adding overflowed
                   error:
0133  a8 ff      wsd     #$ff            ; write signed #$ff (-1)
0135  c0         hlt                     ; 
                   result:
0136  1a 00      stx     $00             ; store current n to $00
0138  a2 00      wud     $00             ; write $00 as unsigned decimal
013a  c0         hlt

chỉnh sửa : Tôi vừa sửa một lỗi trong gvm; không có sửa lỗi này, gvmđã cố đọc các chương trình nhị phân ở chế độ văn bản , có thể bị hỏng (đoạn mã trên không chứa bất kỳ 0xdbyte nào nên sẽ không bị hỏng trên windows nếu không sửa lỗi này).

K (oK) , 21 byte

{(,_r%2)@1!r:%1+8*%x}

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

Câu trả lời JS của cảng Arnauld .

Làm sao:

{(,_r%2)@1!r:%1+8*%x} # Main function, argument x
             %1+8*%x  # sqrt(1+(8*(sqrt(x)))
           r:         # Assign to r
         1!           # r modulo 1
        @             # index the list:
 (,_r%2)              # enlist (,) the floor (_) of r modulo 2.

hàm sẽ trả về (_r%2)iff 1!r == 0, nếu không nó sẽ trả về null ( 0N). Đó là do một yếu tố duy nhất trong danh sách có chỉ số 0 và cố gắng lập chỉ mục danh sách đó với bất kỳ số nào khác 0 sẽ trả về null.