31

Đó là kiến thức cổ xưa rằng mọi số nguyên không âm có thể được viết lại dưới dạng tổng của bốn số nguyên bình phương. Ví dụ, số 1 có thể được biểu thị là . Hoặc, nói chung, đối với mọi số nguyên không âm , tồn tại các số nguyên sao cho $0^2+0^2+0^2+1^2$ $n$ $a,b,c,d$

n = a^{2} + b^{2} + c^{2} + d^{2}

$n = a^2+b^2+c^2+d^2$

Joseph-Louis Lagrange đã chứng minh điều này vào những năm 1700 và do đó, nó thường được gọi là Định lý Lagrange .

Điều này đôi khi được thảo luận liên quan đến tứ phương - một loại số được William Hamilton phát hiện vào những năm 1800, được biểu diễn dưới dạng trong đó là các số thực và và là các đơn vị tưởng tượng riêng biệt không nhân lên giao hoán. Cụ thể, nó được thảo luận liên quan đến bình phương mỗi thành phần của bậc bốn lượng này đôi khi được gọi là định mức, hoặc bình phương bình phương , hoặc cũng là tứ giác . Một số bằng chứng hiện đại về Định lý Lagrange sử dụng tứ phương.

w + x i + y j + z k

$w+x\textbf{i}+y\textbf{j}+z\textbf{k}$

w, x, y, z

$w,x,y,z$

i, j

$\textbf{i}, \textbf{j}$

k

$\textbf{k}$

w^{2} + x^{2} + y^{2} + z^{2}

$w^2+x^2+y^2+z^2$

Rudolf Lipschitz đã nghiên cứu các bậc bốn chỉ với các thành phần nguyên, được gọi là các quernions của Lipschitz. Sử dụng tứ giác, chúng ta có thể tưởng tượng rằng mọi tứ phương của Lipschitz có thể được nghĩ là có một người bạn trong các số nguyên. Ví dụ: quancyion có thể được coi là liên kết với số nguyên . Ngoài ra, nếu chúng ta đi ngược lại, thì mọi số nguyên có thể được coi là có một người bạn trong nhóm tứ phương của Lipschitz. $0+0\textbf{i}+0\textbf{j}+1\textbf{k}$ $1=0^2+0^2+0^2+1^2$

Nhưng có một chi tiết thú vị về định lý Lagrange - tổng kết không phải là duy nhất. Mỗi số nguyên có thể có một vài bộ bốn ô vuông khác nhau có thể được tổng hợp để tạo ra nó. Ví dụ: số 1 có thể được biểu thị theo 4 cách sử dụng số nguyên không âm (chúng ta chỉ xem xét không phủ định cho thử thách này):

1 = 0^{2} + 0^{2} + 0^{2} + 1^{2}

$1=0^2+0^2+0^2+1^2$

1 = 0^{2} + 0^{2} + 1^{2} + 0^{2}

$1=0^2+0^2+1^2+0^2$

1 = 0^{2} + 1^{2} + 0^{2} + 0^{2}

$1=0^2+1^2+0^2+0^2$

1 = 1^{2} + 0^{2} + 0^{2} + 0^{2}

$1=1^2+0^2+0^2+0^2$

Các triệu hồi luôn là bình phương 0 hoặc 1, nhưng chúng có thể ở các vị trí khác nhau trong biểu thức.

Đối với thử thách này, chúng ta cũng hãy "sắp xếp" các phép triệu hồi của chúng ta từ thấp nhất đến cao nhất, để loại bỏ các trùng lặp, để chúng ta có thể xem xét, đối với bài tập này, 1 chỉ có một cách được biểu diễn dưới dạng tổng của bốn hình vuông:

1 = 0^{2} + 0^{2} + 0^{2} + 1^{2}

$1=0^2+0^2+0^2+1^2$

Một ví dụ khác là số 42, có thể được biểu thị theo bốn cách (một lần nữa, chỉ xem xét không âm a, b, c, d và loại bỏ các sắp xếp thành phần trùng lặp)

42 = 0^{2} + 1^{2} + 4^{2} + 5^{2}

$42=0^2+1^2+4^2+5^2$

42 = 1^{2} + 1^{2} + 2^{2} + 6^{2}

$42=1^2+1^2+2^2+6^2$

42 = 1^{2} + 3^{2} + 4^{2} + 4^{2}

$42=1^2+3^2+4^2+4^2$

42 = 2^{2} + 2^{2} + 3^{2} + 5^{2}

$42=2^2+2^2+3^2+5^2$

Điều gì sẽ xảy ra nếu chúng ta tưởng tượng mỗi cách khác nhau để biểu thị một số nguyên có liên quan đến một tứ phương cụ thể? Sau đó, chúng ta có thể nói số 42 được liên kết với bốn nhóm này:

0 + 1 i + 4 j + 5 k

$0+1\textbf{i}+4\textbf{j}+5\textbf{k}$

1 + 1 i + 2 j + 6 k

$1+1\textbf{i}+2\textbf{j}+6\textbf{k}$

1 + 3 i + 4 j + 4 k

$1+3\textbf{i}+4\textbf{j}+4\textbf{k}$

2 + 2 i + 3 j + 5 k

$2+2\textbf{i}+3\textbf{j}+5\textbf{k}$

Nếu chúng ta tưởng tượng cách giải thích đồ họa máy tính tiêu chuẩn của một bậc bốn, trong đó , và là các vectơ trong không gian Euclide ba chiều , và do đó , các thành phần , và của tứ phương là tọa độ Cartesian 3 chiều , sau đó chúng ta có thể tưởng tượng rằng mỗi số nguyên, thông qua quá trình suy nghĩ này, có thể được liên kết với một tập hợp tọa độ 3 chiều trong không gian. Ví dụ: số 42 được liên kết với bốn tọa độ sau: $\textbf{i}$ $\textbf{j}$ $\textbf{k}$ $x$ $y$ $z$ $(x,y,z)$

(1, 4, 5), (1, 2, 6), (3, 4, 4), (2, 3, 5)

$(1,4,5),(1,2,6),(3,4,4),(2,3,5)$

Điều này có thể được coi là một đám mây điểm hoặc một tập hợp các điểm trong không gian. Bây giờ, một điều thú vị về một tập hợp các điểm hữu hạn trong không gian là bạn luôn có thể vẽ một hộp giới hạn tối thiểu xung quanh chúng - một hộp đủ lớn để phù hợp với tất cả các điểm, nhưng không lớn hơn. Nếu bạn tưởng tượng hộp là một hộp thông thường được căn chỉnh theo trục , thì nó được gọi là hộp giới hạn theo trục . Hộp giới hạn cũng có thể tích, có thể tính toán bằng cách xác định chiều rộng, chiều dài và chiều cao của nó và nhân chúng lại với nhau. $x,y,z$

Sau đó chúng ta có thể tưởng tượng khối lượng của một hộp giới hạn cho các điểm được hình thành bởi các bậc bốn của chúng ta. Đối với số nguyên 1, chúng ta có, sử dụng các tiêu chí của bài tập này, một phần tư có tứ giác là 1, . Đây là một đám mây điểm rất đơn giản, nó chỉ có một điểm, vì vậy hộp giới hạn của nó có thể tích 0. Đối với số nguyên 42, tuy nhiên, chúng ta có bốn điểm tứ phân, và do đó bốn điểm, xung quanh chúng ta có thể vẽ một hộp giới hạn. Điểm tối thiểu của hộp là và tối đa là dẫn đến chiều rộng, chiều dài và chiều cao là 2, 2 và 2, cho thể tích là 8. $0+0\textbf{i}+0\textbf{j}+1\textbf{k}$ $(1,2,4)$ $(3,4,6)$

Giả sử với một số nguyên , qvolume là thể tích của hộp giới hạn căn chỉnh trục của tất cả các điểm 3D được tạo bởi các bậc bốn có một tứ giác bằng , trong đó các thành phần của bậc bốn không âm và . $n$ $n$ $w+x\textbf{i}+y\textbf{j}+z\textbf{k}$ $w<=x<=y<=z$

Tạo một chương trình hoặc chức năng đó, cho một đơn nguyên không âm , ý chí đầu ra 's qvolume. $n$ $n$

Ví dụ:

input -> output
0 -> 0
1 -> 0
31 -> 4
32 -> 0
42 -> 8
137 -> 96
1729 -> 10032

Đây là mã golf, số byte nhỏ nhất sẽ thắng.

code-golf complex-numbers

— don sáng
nguồn

tôi cần thêm gì tôi có nghĩa là chỉ ra rằng số byte nhỏ nhất sẽ giành chiến thắng

— không sáng

3

Bạn đã quên thẻ golf-code, tôi đã giúp bạn thêm nó

— Hiện thân của sự thiếu hiểu biết vào

1

Đây là một thử thách thú vị nhưng nó sẽ còn tuyệt vời hơn IMHO nếu nó ít dài dòng hơn một chút. Ngoài ra, hãy cẩn thận với các liên kết không liên quan (Tôi không nói rằng tất cả các liên kết của bạn là không liên quan, nhưng chỉ một vài trong số chúng thực sự mang lại thông tin có ý nghĩa cho thử thách, trong khi các liên kết khác chỉ gây mất tập trung).

— Arnauld

1

Có, nhưng tại sao chỉ lấy i, j, k làm không gian 3D mà không lấy không gian 4D?

— tsh

1

@tsh vì Đệ tứ không nhất thiết phải đại diện cho một không gian Euclide 4 chiều. Hamilton đã phát hiện ra chúng trong khi tìm kiếm cách làm việc với không gian 3 chiều. Có thể thực hiện phiên bản 4d nhưng tôi đã cân nhắc việc sử dụng chúng trong không gian 3d khi tôi đặt câu hỏi

— đừng sáng

13

Ngôn ngữ Wolfram (Mathicala) , 67 58 byte

Volume@BoundingRegion[Rest/@PowersRepresentations[#,4,2]]&

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

                         ...&   Pure function:
PowersRepresentations[#,4,2]    Get the sorted reprs. of # as sums of 4 2nd powers
Rest/@                         Drop the first coordinate of each
BoundingRegion[...]            Find the bounding region, a Cuboid[] or Point[].
                               By default Mathematica finds an axis-aligned cuboid.
Volume                         Find volume; volume of a Point[] is 0.

— lirtosiast
nguồn

4

wow, tôi không biết rằng một cái gì đó như PowersRepftimeations sẽ được tích hợp trong một ngôn ngữ. tôi thực sự đã nghĩ đến việc thực hiện một thử thách để chỉ ra các cách khác nhau để tính một số nguyên là bốn hình vuông nhưng tôi rất vui vì tôi đã không làm vậy.

— don sáng

4

Lol, Mathicala thậm chí còn có một nội dung để xác định dê trong một hình ảnh , do đó, việc tích hợp sẵn cho việc này thực sự không làm tôi ngạc nhiên. xD

— Kevin Cruijssen

8

Thạch , 17 byte

Żœċ4²S⁼ɗƇ⁸ZḊṢ€I§P

Hãy thử trực tuyến! (khá chậm - làm cho nó đủ nhanh cho tất cả các trường hợp thử nghiệm có hàng đầu½ )

Làm sao?

Żœċ4²S⁼ɗƇ⁸ZḊṢ€I§P - Link: non-negative integer, n    e.g. 27
Ż                 - zero-range                            [0,1,2,...,27]
   4              - literal four                          4
 œċ               - combinations with replacement         [[0,0,0,0],[0,0,0,1],...,[0,0,0,27],[0,0,1,1],[0,0,1,2],...,[27,27,27,27]]
        Ƈ         - filter keep those for which:          e.g.: [0,1,1,5]
       ɗ          -   last three links as a dyad:
    ²             -     square (vectorises)                     [0,1,1,25]
     S            -     sum                                     27
      ⁼  ⁸        -     equal to? chain's left argument, n      1
                  -                                       -> [[0,1,1,5],[0,3,3,3],[1,1,3,4]]
          Z       - transpose                             [[0,0,1],[1,3,1],[1,3,3],[5,3,4]]
           Ḋ      - dequeue                               [[1,3,1],[1,3,3],[5,3,4]]
            Ṣ€    - sort each                             [[1,1,3],[1,3,3],[3,4,5]]
              I   - incremental differences (vectorises)  [[ 0,2 ],[ 2,0 ],[ 1,1 ]]
               §  - sum each                              [2,2,2]
                P - product                               8

— Jonathan Allan
nguồn

6

Haskell , 132 123 byte

z=zipWith
(!)=foldr1.z
h n=[0..n]
f n|p<-[[c,b,a]|a<-h n,b<-h a,c<-h b,d<-h c,a^2+b^2+c^2+d^2==n]=product$z(-)(max!p)$min!p

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

Giải pháp khá đơn giản. Brute buộc tất cả các giải pháp có thể bằng cách lặp qua tất cả các giá trị từ 0 đến n (cách quá mức nhưng ngắn hơn bytecount). Tôi xuất ra điểm dưới dạng một danh sách để chúng ta có thể sử dụng (!)toán tử ma thuật của @ Lynn . Toán tử đó thu gọn từng kích thước với chức năng ở phía bên trái để max!ptrả về danh sách kích thước 3 bao gồm các mức tối đa dọc theo mỗi kích thước và min!pthực hiện tương tự tối thiểu. Sau đó, chúng tôi chỉ tìm kích thước tối thiểu trong mỗi thứ nguyên (bằng cách trừ giá trị tối thiểu từ giá trị tối đa z(-)) và nhân chúng với nhau.

Cảm ơn rất nhiều đến @Lynn vì đã lấy ra 9 byte với một số ma thuật zip gấp!

— người dùng1472751
nguồn

1

Tôi đã loại bỏ một vài byte bằng cách chuyển vị trí có lợi cho một số zipWithlogic. 123 byte

— Lynn

5

Sledgehammer 0,2, 12 byte

⡌⢎⣟⡊⢘⣚⡏⡨⠍⠁⡇⠨

Sử dụng với Mathematica 11.2 và phiên bản Sledgehammer này, trước thách thức. Xem lịch sử chỉnh sửa cho phiên bản hoạt động trong phiên bản 0.3, có GUI và tạo biểu thức Mathicala.

Thao tác này sẽ đẩy đầu vào vào ngăn xếp và gọi chuỗi lệnh

{intLiteral[4], intLiteral[2], call["PowersRepresentations", 3], call["Thread", 1], call["Rest", 1], call["Thread", 1], call["BoundingRegion", 1], call["Volume", 1]}

tương đương với việc đánh giá mã Wolfram sau đây được lấy từ câu trả lời Ngôn ngữ Wolfram của tôi :

Volume[BoundingRegion[Thread@Rest@Thread@PowersRepresentations[#, 4, 2]]]&

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

— lirtosiast
nguồn

Điều này có yêu cầu toán học để kiểm tra nó?

— don sáng

@don sáng Có, kho lưu trữ có hướng dẫn. Đây là một công việc đang tiến triển nên chưa thân thiện với người dùng. Sau khi chạy setup.wls, bạn có thể kiểm tra bằng wolframscript hoặc tương tác_app.wls.

— lirtosiast

2

@Downgoat Vâng. Tôi dự định thực hiện một thư viện chơi gôn, nhưng hiện tại nó giải nén thành Mathicala đơn giản.

— lirtosiast

2

@pipe Phiên bản cũ hơn sẽ hoạt động (bây giờ tôi nghĩ về nó, mã hoàn toàn giống với một phiên bản cũ hơn), nhưng tôi phải tải xuống và chạy lại thiết lập. (Các thay đổi kể từ đó chủ yếu là viết GUI và tái cấu trúc mã mà không có thay đổi lớn về chức năng.) Vì câu trả lời này là ngắn nhất nên việc chứng minh tính đủ điều kiện là rất quan trọng, vì vậy tôi sẽ làm điều đó vào sáng mai.

— lirtosiast

1

bất cứ ai khác có thể chạy này? tôi muốn xác minh nó hoạt động trước khi đánh dấu chọn ol '.

— don sáng

4

Python 2 , 138 byte

q=lambda n,x=0,*t:[t]*(n==0)if t[3:]else q(n-x*x,x,x,*t)+q(n,x+1,*t+(0,)*(x>n))
p=1
for l in zip(*q(input()))[:3]:p*=max(l)-min(l)
print p

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

Đệ quy tạo các bậc bốn được sắp xếp ngược với định mức đã cho, sau đó lấy sản phẩm giữa giá trị cực đại và cực tiểu của tất cả các giá trị có thể trong ba chỉ số đầu tiên.

itertools có thể đã bị bắn nếu nó không sử dụng những cái tên dài đến nực cười như itertools.combinations_with_replacement

Python 2 , 161 byte

from itertools import*
n=input();p=1
for l in zip(*[t[1:]for t in combinations_with_replacement(range(n+1),4)if sum(x*x for x in t)==n]):p*=max(l)-min(l)
print p

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

Đây là lý do tại sao itertoolskhông bao giờ là câu trả lời .

— xnor
nguồn

3

JavaScript (ES6), 148 143 byte

n=>(r=[[],[],[]]).map(a=>p*=a.length+~a.indexOf(1),(g=(s,k=0,a=[])=>a[3]?s||r.map(r=>r[a.pop()]=p=1):g(s-k*k,k,[...a,++k],k>s||g(s,k,a)))(n))|p

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

Đã bình luận

Chúng tôi khởi tạo một mảng với 3 mảng trống. $r$

r = [ [], [], [] ]

Đối với mỗi giá trị hợp lệ của , chúng tôi sẽ đặt thành giá trị tại trong mảng đầu tiên. Ditto cho và với mảng thứ 2 và thứ 3 tương ứng. $x$ $1$ $x+1$ $y$ $z$

Kích thước của hộp giới hạn sẽ được suy ra từ khoảng cách giữa mục nhập đầu tiên và mục nhập cuối cùng được đặt thành trong các mảng này. $1$

Bước 1

Để điền , chúng ta sử dụng hàm đệ quy . $r$ $g$

g = (              // g is a recursive function taking:
  s,               // s   = current sum, initially set to the input n
  k = 0,           // k   = next value to be squared
  a = []           // a[] = list of selected values
) =>               //
  a[3] ?           // if we have 4 values in a[]:
    s ||           //   if s is equal to zero (we've found a valid sum of 4 squares):
      r.map(r =>   //     for each array r[] in r[]:
        r[a.pop()] //       pop the last value from a[]
        = p = 1    //       and set the corresponding value in r[] to 1
                   //       (also initialize p to 1 for later use in step 2)
      )            //     end of map()
  :                // else:
    g(             //   do a recursive call:
      s - k * k,   //     subtract k² from s
      k,           //     pass k unchanged
      [...a, ++k], //     increment k and append it to a[]
      k > s ||     //     if k is less than or equal to s:
        g(s, k, a) //       do another recursive call with s and a[] unchanged
    )              //   end of outer recursive call

Bước 2

Bây giờ chúng ta có thể tính sản phẩm của kích thước. $p$

r.map(a =>         // for each array a[] in r[]:
  p *=             //   multiply p by:
    a.length +     //     the length of a[]
    ~a.indexOf(1)  //     minus 1, minus the index of the first 1 in a[]
) | p              // end of map(); return p

— Arnauld
nguồn

2

C # (Trình biên dịch tương tác Visual C #) , 229 byte

a=>{uint b=0,c=~0U,d,e,f=0,g=0,h=0,i=c,j=c,k=c;for(;b*b<=a;b++)for(c=b;c*c<=a;c++)for(d=c;d*d<=a;d++)for(e=d;e*e<=a;e++)if(b*b+c*c+d*d+e*e==a){f=c>f?c:f;g=d>g?d:g;h=e>h?e:h;i=c<i?c:i;j=d<j?d:j;k=e<k?e:k;}return(f-i)*(g-j)*(h-k);}

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

— Hiện thân của vô minh
nguồn

2

05AB1E , 18 byte

Ý4ãʒnOQ}€{ζ¦ε{¥O}P

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

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

— Grimmy
nguồn

1

Haskell , 108 byte

n%i=sum[maximum[t!!i*b|t<-mapM([0..n]<$f)[0..3],sum(map(^2)t)==n,scanr1 max t==t]|b<-[-1,1]]
f n=n%0*n%1*n%2

Hãy thử trực tuyến! (lần ra vào các trường hợp thử nghiệm lớn hơn)

Có một số tối ưu hóa kỳ lạ ở đây. Để tính toán maximum l-minimum ldanh sách lcác phần tử tại một vị trí nhất định, nó sẽ rút ngắn hơn trong ngữ cảnh để chuyển đổi cả hai thành cực đại bằng cách phủ định thuật ngữ thứ hai : maximum l+maximum(map((-1)*))l, hoặc tương đương sum[maximum$map(b*)l||b<-[-1,1]].

Để nhân ba chiều, nó chỉ viết ra sản phẩm ngắn f n=n%0*n%1*n%2hơn là sử dụng bất kỳ loại vòng lặp nào. Ở đây, n%ilà sự khác biệt giữa igiá trị cực tiểu và cực đại của các giá trị tọa độ thứ, được trích xuất bằng cách lập chỉ mục !!i.

Để tạo bốn bộ dữ liệu hợp lệ, chúng tôi lấy danh sách bốn số từ số [0..n]bình phương của chúng tổng hợp nvà theo thứ tự giảm dần. Chúng tôi kiểm tra tính sắp xếp ngược của tvới scanr1 max t==t, xem liệu mức tối đa đang chạy của chính nó có phải không, vì Haskell không có loại tích hợp sẵn mà không phải nhập khẩu tốn kém. Tôi đã thử nhiều cách khác nhau để tạo đệ quy bốn bộ dữ liệu như trong các câu trả lời Python của mình, nhưng tất cả chúng đều dài hơn cách tạo và lọc bộ lọc vũ phu này.

— xnor
nguồn

Số qvolume của một số nguyên

Ngôn ngữ Wolfram (Mathicala) , 67 58 byte

Thạch , 17 byte

Làm sao?

Haskell , 132 123 byte

Sledgehammer 0,2, 12 byte

Python 2 , 138 byte

JavaScript (ES6), 148 143 byte

Đã bình luận

Bước 1

Bước 2

C # (Trình biên dịch tương tác Visual C #) , 229 byte

05AB1E , 18 byte

Haskell , 108 byte