Her negatif olmayan tamsayının dört kare tamsayının toplamı olarak yeniden yazılabileceği eski bir bilgidir. Örneğin, 1 sayısı olarak ifade edilebilir . Ya da, genel olarak, negatif olmayan bir tamsayı , orada tamsayıyı ana kadar , a, b, c, d bu tür$0^2+0^2+0^2+1^2$$n$$a,b,c,d$

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

Joseph-Louis Lagrange bunu 1700'lerde kanıtladı ve bu yüzden genellikle Lagrange Teoremi olarak adlandırılır .

Bu bazen kuaterniyonlarla ilgili olarak tartışılır - William Hamilton tarafından 1800'lerde keşfedilen ve

$$w+x\textbf{i}+y\textbf{j}+z\textbf{k}$$ olarak gösterilen bir sayı türü, burada $w,x,y,z$ , gerçek sayılardır ve $\textbf{i}, \textbf{j}$ ve $\textbf{k}$ , komütatif olarak çarpmayan farklı hayali birimlerdir. Spesifik olarak, kuaterniyonun her bir bileşeninin $$w^2+x^2+y^2+z^2$$ karesi ile ilgili olarak tartışılmaktadır. Bu miktar bazen norm veya kare norm veya dörtlü olarak da adlandırılmaktadır . Lagrange Teoreminin bazı modern ispatları kuaterniyonlar kullanır.

Rudolf Lipschitz , kuaterniyonları sadece Lipschitz kuaterniyonları adı verilen tam sayı bileşenleriyle çalıştı. Quadrance kullanarak, her Lipschitz kuaterniyonunun, tam sayılarda bir arkadaş sahibi olabileceğini düşünebiliriz. Örneğin, kuaterniyon $0+0\textbf{i}+0\textbf{j}+1\textbf{k}$ , $1=0^2+0^2+0^2+1^2$ tamsayı ile ilişkili olarak düşünülebilir. 2 . Ayrıca, geriye doğru gidersek, her tamsayı Lipschitz kuaterniyonlarında bir arkadaşa sahip olduğu düşünülebilir.

Ancak Lagrange'in teoreminin ilginç bir detayı var - toplam benzersiz değil. Her tamsayı, oluşturmak için toplanabilecek birkaç farklı kare kümeye sahip olabilir. Örneğin, 1 sayısı, negatif olmayan tam sayılar kullanarak 4 şekilde ifade edilebilir (bu sorun için yalnızca negatif olmayanları düşünelim):

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

Summands her zaman 0 veya 1 olan karelerdir, ancak ifadede farklı konumlarda olabilirler.

Bu zorluk için, aynı zamanda yinelemeleri ortadan kaldırmak için en küçükten en yükseğe en yüksekden en yükseğe en yüksek dereceye kadar "sıralayalım", böylece bu alıştırma için, 1'in dört kare toplamı olarak temsil edilmenin tek bir yolunu bulunduğunu düşünebiliriz:

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

Diğer bir örnek, dört şekilde ifade edilebilecek olan 42 sayısıdır (yine, yalnızca negatif olmayan a, b, c, d ve yinelenen bileşen düzenlemelerinin ortadan kaldırılması düşünüldüğünde).

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

Bir tamsayının belirli bir kuaterniyonla ilişkili olduğunu ifade etmenin bu farklı yollarının her birini hayal edersek ne olur? Sonra 42 sayısının bu dört kuaterniyonla ilişkili olduğunu söyleyebiliriz:

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

Bir kuaterniyonun standart bilgisayar grafik yorumunu hayal edersek, burada , ve , üç boyutlu Öklid uzayındaki vektörlerdir ve böylece kuaterniyonun , ve bileşenleridir. 3 boyutlu Kartezyen koordinatlardır, o zaman her bir tamsayının, bu düşünce süreci boyunca, uzayda bir 3 boyutlu koordinat kümesi ile ilişkilendirilebileceğini hayal edebiliriz. Örneğin, 42 sayısı aşağıdaki dört koordinatla ilişkilidir :$\textbf{i}$$\textbf{j}$$\textbf{k}$$x$$y$$z$$(x,y,z)$

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

Bu bir nokta bulutu veya uzayda bir dizi nokta olarak düşünülebilir. Şimdi, uzaydaki sınırlı noktalarla ilgili ilginç bir şey, etraflarına her zaman minimum sınırlayıcı bir kutu çizebilmenizdir - tüm noktalara uyacak kadar büyük, ancak daha büyük olmayan bir kutu. Kutuyu, eksenleriyle hizalanmış sıradan bir kutu olarak hayal ederseniz eksene hizalanmış sınırlama kutusu olarak adlandırılır . Sınırlayıcı kutu ayrıca genişliğini, uzunluğunu ve yüksekliğini belirleyerek ve bunları çarparak hesaplanabilen bir hacme sahiptir.$x,y,z$

Daha sonra kuaternyonlarımızın oluşturduğu noktalar için sınırlayıcı bir kutunun hacmini hayal edebiliriz. 1 tamsayısı için, bu alıştırmanın ölçütlerini kullanarak, kadranı 1, olan bir kuaterniyona sahibiz . Bu çok basit bir nokta bulutu, sadece bir noktaya sahip, bu yüzden sınırlayıcı kutuda hacim 0 var. Bununla birlikte, tamsayı 42 için dört tane kuaterniyonumuz var ve etrafına bir sınırlayıcı kutu çizebileceğimiz dört nokta var. Kutunun minimum noktası ve maksimum , 8, hacim vererek 2, 2 ve 2 genişlik, uzunluk ve yükseklik ile sonuçlanır.$0+0\textbf{i}+0\textbf{j}+1\textbf{k}$$(1,2,4)$$(3,4,6)$

En bir tamsayı için diyelim e eşit, qvolume bir quadrance sahip quaternions oluşturduğu tüm 3B noktaları eksen hizalı sınırlayıcı kutu hacmi , burada quaternion bileşenleri negatif değildir ve .$n$$n$$w+x\textbf{i}+y\textbf{j}+z\textbf{k}$$w<=x<=y<=z$

Tek bir negatif olmayan tamsayı verildiğinde qvolume değerini verecek bir program veya işlev oluşturun .$n$$n$

Örnekler:

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

Bu kod-golf, en küçük bayt sayısı kazanır.

Wolfram Dili (Mathematica) , 67 58 bayt

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

Çevrimiçi deneyin!

                         ...&   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.

Jöle , 17 bayt

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

Çevrimiçi deneyin! (oldukça yavaş - lideri½ olan tüm test durumları için yeterince hızlı hale getirin)

Nasıl?

Żœċ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

Haskell , 132 123 bayt

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

Çevrimiçi deneyin!

Oldukça basit bir çözüm. Brute, 0'dan n'ye kadar tüm değerler üzerinde yineleyerek tüm olası çözümleri zorlar (yol aşırtma ama kısa bayt sayısı). Noktayı liste halinde çıkarıyorum, böylece @ Lynn'in sihir (!)operatörünü kullanabiliriz. Bu operatör her bir boyutu sol taraftaki işlevle daraltır, böylece max!pher bir boyut boyunca maksimumlardan oluşan ve min!pminimum için de aynı olan 3 boyut listesini verir . Sonra her boyutta minimum büyüklüğü bulduk (min değerini max ile çıkartarak z(-)) ve bunları çarpın.

Bazı katlama zip sihirbazı ile 9 byte ayırdığınız için @Lynn'e çok teşekkürler!

Balyoz 0.2, 12 bayt

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

Mathematica 11.2 ve bu meydan okumadan önce gelen Balyoz'un bu versiyonuyla kullanın . Bir GUI'ye sahip olan ve bir Mathematica ifadesi üreten, 0.3 sürümünde çalışan bir sürüm için düzenleme geçmişine bakın.

Bu girdiyi yığına iter ve komutların sırasını çağırır

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

benim Wolfram Dili cevabımdan türetilen aşağıdaki Wolfram kodunu değerlendirmeye eşdeğerdir :

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

Çevrimiçi deneyin!

Python 2 , 138 bayt

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

Çevrimiçi deneyin!

Tekrarlanan sıradaki kuaternyonları verilen norm ile tekrarlı olarak üretir, ardından ürünü ilk üç endekste tüm olası değerlerin maks. Ve min. Arasında alır.

itertools Gibi gülünç uzun isimler kullanmamış olsaydı bir atış olabilirdi itertools.combinations_with_replacement

Python 2 , 161 bayt

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

Çevrimiçi deneyin!

Bu yüzden itertoolscevap asla değil .

JavaScript (ES6),  148  143 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

dizisini 3 boş diziyle başlattık .$r$

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

Her geçerli değeri için , ilk dizideki değeri ayarlayacağız . Sırasıyla 2. ve 3. dizilerle ve için aynı şeyler .$x$$1$$x+1$$y$$z$

Sınırlama kutusunun boyutları, bu dizilerde birinci ve son giriş arasındaki mesafeden düşülecektir.$1$

Aşama 1

Dolgu için , biz özyinelemeli işlevini kullanın .$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

Adım 2

Biz şu anda ürün hesaplayabilir boyutlarının.$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

C # (Visual C # Etkileşimli Derleyici) , 229 bayt

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

Çevrimiçi deneyin!

05AB1E , 18 bayt

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

Çevrimiçi deneyin!

Jonathan Allan Limanı'nın jöle cevabı .

Haskell , 108 bayt

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

Çevrimiçi deneyin! (büyük test durumlarında zaman aşımına uğradı)

Burada bazı garip optimizasyonlar var. Belirli bir pozisyondaki elemanların maximum l-minimum llistesini hesaplamak için, likinci terimi: maximum l+maximum(map((-1)*))lveya eşit bir şekilde ihmal ederek her ikisini de maksimaya dönüştürmek bağlamında daha kısa hale gelir sum[maximum$map(b*)l||b<-[-1,1]].

Üç boyutu çarpmak için, sadece f n=n%0*n%1*n%2herhangi bir döngü kullanmaktan çok ürünü yazmak için kısalır . Burada, indeksleme ile çıkarılan birinci koordinat değerlerinin n%imin ve max ideğerleri arasındaki farktır !!i.

Geçerli dört grubun oluşturulması için [0..n]karelerinin toplamı nazalan ve azalan sırada bulunan dört sayının listesini alırız . Biz ters-sortedness kontrol tile scanr1 max t==tHaskell yerleşik tür pahalı bir ithalat olmadan bulunmadığından ters çalışan maksimum, kendisini ise görür. Python cevaplarımdaki gibi dört tote'i tekrarlı bir şekilde üretmek için çeşitli yollar denedim, fakat hepsi bu kaba kuvvet üretme ve filtreleme yönteminden daha uzundu.