Viết chương trình, trong đó xác minh phỏng đoán Erdős của Straus .
Chương trình sẽ lấy đầu vào là một số nguyên n( 3 <= n <= 1 000 000) và in ba số nguyên thỏa mãn danh tính 4/n = 1/x + 1/y + 1/z, 0 < x < y < z.

Mã ngắn nhất sẽ thắng.

Vài ví dụ:

3 => {1, 4, 12}
4 => {2, 3, 6}
5 => {2, 4, 20}
1009 => {253, 85096, 1974822872}
999983 => {249996, 249991750069, 62495875102311369754692}
1000000 => {500000, 750000, 1500000}

Lưu ý rằng chương trình của bạn có thể in các kết quả khác cho những con số này vì có nhiều giải pháp.

Ruby, 119 106 ký tự

f=->s,c,a{m=s.to_i;c<2?m<s||(p a+[m];exit):(1+m...c*s).map{|k|f[s/(1-s/k),c-1,a+[k]]}}
f[gets.to_r/4,3,[]]

Mã sử ​​dụng giới hạn tối thiểu cho mỗi biến, ví dụ n/4<x<3n/4, tương tự cho y. Ngay cả ví dụ cuối cùng trả về ngay lập tức (thử ở đây ).

Ví dụ:

> 12
[4, 13, 156]

> 123
[31, 3814, 14542782]

> 1234
[309, 190654, 36348757062]

> 40881241801
[10220310451, 139272994276206121600, 22828913614743204775214996005450198400]

Toán học 62

Giải pháp vanilla đơn giản này hoạt động tốt - hầu hết thời gian.

f@n_ := FindInstance[4/n == 1/x + 1/y + 1/z && 0 < x < y < z, {x, y, z}, Integers]

Ví dụ và thời gian (tính bằng giây)

AbsoluteTiming[f[63]]
AbsoluteTiming[f[123]]
AbsoluteTiming[f[1003]]
AbsoluteTiming[f[3003]]
AbsoluteTiming[f[999999]]
AbsoluteTiming[f[1000000]]

{0,313671, {{x -> 16, y -> 1009, z -> 1017072}}}
{0.213965, {{x -> 31, y -> 3814, z -> 14542782}}}
{0.212016, {{x -> 251, y -> 251754, z -> 63379824762}}}
{0.431834, {{x -> 751, y -> 2255254, z -> 5086168349262}}}
{1.500.332, {{x -> 250000, y - > 249999750052, z -> 1201920673328124750000}}}
{1.126821, {{x -> 375000, y -> 1125000, z -> 2250000}}}

Nhưng nó không tạo thành một giải pháp hoàn chỉnh. Có một số con số mà nó không thể giải quyết. Ví dụ,

AbsoluteTiming[f[30037]]
AbsoluteTiming[f[130037]]

{2.066699, FindInstance [4/30037 == 1 / x + 1 / y + 1 / z && 0 <x <y <z, {x, y, z}, Số nguyên]}
{1.981802, FindInstance [4/130037 = = 1 / x + 1 / y + 1 / z && 0 <x <y <z, {x, y, z}, Số nguyên]}

C #

Disclamer: đây không phải là một câu trả lời nghiêm túc

Điều này chỉ phù hợp với tất cả các khả năng từ 1 đến 1 << 30. Nó rất lớn, rất chậm, tôi thậm chí không biết nó có hoạt động chính xác không, nhưng nó tuân theo các thông số kỹ thuật hoàn toàn theo nghĩa đen, vì nó kiểm tra tình trạng mỗi lần, vì vậy điều đó thật tuyệt. Tôi chưa thử nghiệm điều này vì ideone có giới hạn thời gian 5 giây cho các chương trình và do đó, việc này sẽ không hoàn thành.

(Trong trường hợp bất cứ ai cũng thắc mắc: đây là một con số khổng lồ 308 byte )

static double[]f(double n)
{
    for(double x=1;x<1<<30;x++)
    {
        for(double y=1;y<1<<30;y++)
        {
            for(double z=1;z<1<<30;z++)
            {
                if(4/n==1/x+1/y+1/z)
                    return new[]{x,y,z};
            }
        }
    }
    return null;
}

Cập nhật: đã sửa nó để nó thực sự hoạt động

Python 2 , 171 byte

from sympy import*
def f(n):
 for d in xrange(1,n*n):
  for p in divisors(4*d+n*n):
   q=(4*d+n*n)/p;x=(n+p)/4;y=(n+q)/4
   if (n+p)%4+(n+q)%4+n*x*y%d<1:return x,y,n*x*y/d

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

Câu trả lời đầu tiên đủ nhanh để được kiểm tra toàn diện. Đây là khả năng tìm ra giải pháp cho tất cả 3 ≤ n ≤ 1000000 trong khoảng 24 phút tổng , cho trung bình khoảng 1,4 mili giây mỗi.

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

Viết lại 4 / n = 1 / x + 1 / y + 1 / z dưới dạng z = n · x · y / d , trong đó d = 4 · x · y - n · x - n · y . Sau đó, chúng ta có thể hệ số 4 · d + n ² = (4 · x - n ) · (4 · y - n ), điều này cho chúng ta một cách nhanh hơn để tìm kiếm x và y miễn là dnhỏ. Với x < y < z , ít nhất chúng ta có thể chứng minh d <3 · n ^2/4 (do đó bị ràng buộc ở vòng ngoài), mặc dù trong thực tế, nó có xu hướng nhỏ hơn nhiều 95% thời gian, chúng ta có thể sử dụng d = 1, 2 hoặc 3. Trường hợp xấu nhất là n = 769129, trong đó d nhỏ nhất là 1754 (trường hợp này mất khoảng 1 giây).

Toán học, 99 byte

f[n_]:=(x=1;(w=While)[1>0,y=1;w[y<=x,z=1;w[z<=y,If[4/n==1/x+1/y+1/z,Return@{x,y,z}];++z];++y];++x])

Đó là lực lượng vũ phu khá ngây thơ, vì vậy nó không thực sự mở rộng quy mô. Tôi chắc chắn sẽ nhận được một triệu (vì vậy hãy thoải mái xem xét điều này không hợp lệ trong thời điểm hiện tại). n = 100mất nửa giây, nhưng n = 300đã mất 12 giây.

Golflua 75

Đọc ntừ dấu nhắc (sau khi gọi trong thiết bị đầu cuối), nhưng về cơ bản lặp lại như giải pháp Sở thích của Calvin :

n=I.r()z=1@1~@y=1,z-1~@x=1,y-1?4*x*y*z==n*(y*z+x*z+x*y)w(n,x,y,z)~$$$z=z+1$

Một phiên bản Lua không được đề cập ở trên là

n=io.read()
z=1
while 1 do
   for y=1,z-1 do
      for x=1,y-1 do
         if 4*x*y*z==n*(y*z+x*z+x*y) then
            print(n,x,y,z)
            return
         end
      end
   end
   z=z+1
end

Ví dụ:

n=6     -->     3      4     12
n=12    -->     6     10     15
n=100   -->    60     75    100
n=1600  -->  1176   1200   1225

Con trăn, 117

n=input();r=range;z=0
while 1:
 z+=1
 for y in r(z):
  for x in r(y):
    if 4*x*y*z==n*(y*z+x*z+x*y):print x,y,z;exit()

Thí dụ:

16 --> 10 12 15

Không có gì quá đặc biệt.

C # - 134

Chà, tôi đã đăng một câu trả lời ở đây trước đây, nhưng nó không thực sự nghiêm trọng đến thế. Khi điều đó xảy ra, tôi rất thường xuyên rất buồn chán, vì vậy tôi đã chơi golf một chút.

Nó tính toán tất cả các ví dụ về mặt kỹ thuật một cách chính xác (tôi đã không thử hai lần cuối bởi vì, một lần nữa, ideone sẽ giới hạn thời gian 5 giây) nhưng những ví dụ đầu tiên mang lại kết quả chính xác (không nhất thiết là kết quả bạn đã tính, nhưng là kết quả đúng). Nó lạ kết quả đầu ra số ra khỏi trật tự (Tôi không có đầu mối tại sao) và nó mang lại 10, 5, 2cho 5(đó là một câu trả lời hợp lệ theo wikipedia).

Bây giờ là 134 byte, tôi có thể chơi nó nhiều hơn một chút.

float[]f(float n){float x=1,y,z;for(;x<1<<30;x++)for(y=1;y<x;y++)for(z=1;z<y;z++)if(4/n==1/x+1/y+1/z)return new[]{x,y,z};return null;}

Haskell - 150 ký tự

main = getLine >>= \n -> (return $ head $ [(x,y,z) | x <- [1..y], y <- [1..z], z <- [1..], (4/n') == (1/x) + (1/y) + (1/z)]) where n' = read n

Điều này nên hoạt động, nhưng tôi chưa biên dịch nó. Nó gần như chắc chắn rất rất chậm. Nó kiểm tra mọi bộ ba số nguyên hợp lệ có thể và sẽ dừng khi thấy một bộ hoạt động.