페르마의 마지막 정리에 따르면 방정식에 a^n + b^n = c^n대한 긍정적이고 완전한 해는 없다고 합니다 n>2. 1994 년 Andrew Wiles가이 사실을 입증했습니다.

그러나, 디오 판틴 방정식을 거의 만족 시키지만 그것을 놓치는 많은 "근거리 미스"가 있습니다. 정확하게, 그것들은 모두 1보다 크며 적분의 해입니다 a^3 + b^3 = c^3 + 1(시퀀스는 방정식의 각 변의 값이며 순서가 증가합니다).

이 순서 n의 첫 번째 n값 을 인쇄하는 작업이 제공 됩니다.

시퀀스의 처음 몇 값은 다음과 같습니다.

1729, 1092728, 3375001, 15438250, 121287376, 401947273, 3680797185, 6352182209, 7856862273, 12422690497, 73244501505, 145697644729, 179406144001, 648787169394, 938601300672, 985966166178, 1594232306569, 2898516861513, 9635042700640, 10119744747001, 31599452533376, 49108313528001, 50194406979073, 57507986235800, 58515008947768, 65753372717929, 71395901759126, 107741456072705, 194890060205353, 206173690790977, 251072400480057, 404682117722064, 498168062719418, 586607471154432, 588522607645609, 639746322022297, 729729243027001

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

젤리 , 16 바이트

*3‘
ḊŒc*3S€ċǵ#Ç

무차별 대입 솔루션. 온라인으로 사용해보십시오!

*3‘           Helper link. Maps r to r³+1.

ḊŒc*3S€ċǵ#Ç  Main link. No arguments.

         µ    Combine the links to the left into a chain.
          #   Read an integer n from STDIN and execute the chain to the left for
              k = 0, 1, 2, ... until n matches were found. Yield the matches.
Ḋ             Dequeue; yield [2, ..., k].
 Œc           Yield all 2-combinations of elements of that range.
   *3         Elevate the integers in each pair to the third power.
     S€       Compute the sum of each pair.
        Ç     Call the helper link, yielding k³+1.
       ċ      Count how many times k³+1 appears in the sums. This yields a truthy 
              (i.e., non-zero) integer if and only if k is a match.
           Ç  Map the helper link over the array of matches.

Brachylog , 31 바이트

:{#T#>>:{:3^}aLhH,Lb+.-H,#T=,}y

온라인으로 사용해보십시오!

구속 조건을 사용하므로 완전한 무차별 대입은 아닙니다. 이것은 TIO에서 약간 느립니다 (약 20 초 동안 N = 5). 컴퓨터에서 약 5 초 N = 5, 13 초가 걸립니다 N = 6.

설명

:{                           }y    Return the first Input outputs of that predicate
  #T                               #T is a built-in list of 3 variables
    #>                             #T must contain strictly positive values
      >                            #T must be a strictly decreasing list of integers
       :{:3^}aL                    L is the list of cubes of the integers in #T
              LhH,                 H is the first element of L (the biggest)
                  Lb+.             Output is the sum of the last two elements of L
                     .-H,          Output - 1 = H
                         #T=,      Find values for #T that satisfy those constaints

펄, 78 바이트

#!perl -nl
grep$_<(($_+2)**(1/3)|0)**3,map$i**3-$_**3,2..$i++and$_-=print$i**3+1while$_

무차별 대입 접근. shebang을 두 개로 쿠팅하고 stdin에서 입력을 가져옵니다.

샘플 사용법

$ echo 10 | perl fermat-near-miss.pl
1729
1092728
3375001
15438250
121287376
401947273
3680797185
6352182209
7856862273
12422690497

온라인으로 사용해보십시오!

Mathematica, 95 바이트

(b=9;While[Length[a=Select[Union@@Array[#^3+#2^3&,{b,b},2],IntegerQ[(#-1)^3^-1]&,#]]<#,b++];a)&

명명되지 않은 함수는 단일 양의 정수 인수 #를 사용하여 원하는 #정수 목록을 반환합니다 . 인간의 가독성을위한 공간 :

1  (b = 9; While[
2    Length[ a =
3      Select[
4        Union @@ Array[#^3 + #2^3 &, {b, b}, 2],
5        IntegerQ[(# - 1)^3^-1] &
6      , #]
7    ] < #, b++
8  ]; a) &

4 행은 2와 b+1 ( b=91 행 의 초기화 사용) 사이의 정수 큐브의 가능한 모든 합계를 정렬 된 순서로 계산합니다. 3-5 행은 완벽한 큐브보다 하나 이상인 합계 만 선택합니다. 6 행은 최대 #값으로 나열되며이 값은에 저장됩니다 a. 그러나이 목록에 실제로 #값 보다 작은 경우 While1-7 행 의 루프가 증가 b하고 다시 시도합니다. 마지막으로 8 행 a은 올바른 길이가되면 출력 합니다.

이 버전은 느리다! 여분의 바이트 하나에 대해서는 b++7 행 b*=9에서 코드를 실제로 적절한 시간에 실행하도록 만들 수 있습니다 (실제로 테스트 한 방식).

라켓 166 바이트

(let((c 0)(g(λ(x)(* x x x))))(for*((i(in-naturals))(j(range 1 i))(k(range j i))#:final(= c n))
(when(=(+(g j)(g k))(+ 1(g i)))(displayln(+ 1(g i)))(set! c(+ 1 c)))))

언 골프 드 :

(define (f n)
  (let ((c 0)
        (g (λ (x) (* x x x))))
    (for* ((i (in-naturals))
           (j (range 1 i))
           (k (range j i))
           #:final (= c n))
      (when (= (+ (g j) (g k))
               (+ 1 (g i)))
        (displayln (+ 1(g i)))
        (set! c (add1 c))))))

테스트 :

(f 5)

산출:

1729
1092728
3375001
15438250
121287376

파이썬 2 , 102 98 바이트

def f(n,c=2):z=c**3+1;t=z in[(k/c)**3+(k%c)**3for k in range(c*c)];return[z]*n and[z]*t+f(n-t,c+1)

온라인으로 사용해보십시오!

Pari / GP, 107 바이트

F(n)=c=2;while(n>0,c++;C=c^3+1;a=2;b=c-1;while(a<b,K=a^3+b^3;if(K==C,print(C);n--;break);if(K>C, b--,a++)))

10 초 안에 처음 10 개의 솔루션을 찾습니다.

목표 : a ^ 3 + b ^ 3 = c ^ 3 + 1

1. 함수 인수 n 으로 필요한 솔루션 수를 가져 옵니다.

2. c 를 3 에서 증가 시키고 각 c ^ 3 + 1에 대해 a ^ 3 + b ^ 3 = c ^ 3 + 1 과 같이 1 <a <= b <c로 a 및 b 를 검색 합니다 . 발견되면, 필요한 추가 오염 물질 수 n 을 1 씩 줄이고 반복하십시오

3. 추가로 필요한 솔루션의 수 ( n )가 0 인 경우 완료

처음 10 가지 솔루션을 얻으려면 전화하십시오 .

F(10)

읽을 수있는 코드 (함수의 블록 표시를위한 지표로 선행 및 후행 괄호가 필요합니다. 또한 편의를 위해 솔루션의 모든 변수를 인쇄합니다) :

{F(m) = c=2;
   while(m>0,        
     c++;C=c^3+1;             
     a=2;b=c-1;                
     while(a<b,                
           K=a^3+b^3;               
            if(K==C,print([a,b,c,C]);m--;break);
            if(K>C, b--,a++);
          );
    );}

Pari / GP, 93 바이트

(데니스의 개선)

F(n)=c=2;while(n,C=c^3+1;a=2;b=c++;while(a<b,if(K=a^3+b^3-C,b-=K>0;a+=K<0,print(C);n--;b=a)))              

파이썬 2, 122 119 바이트

^{왜 여전히 투표를합니까? 데니스는이 대답을 분쇄했다;)}

이 질문에 대한 가장 긴 해결책에 오신 것을 환영합니다 : / 더 긴 조건을 만들고 가능한 한 들여 쓰기를 제거하여 전체 바이트를 줄였습니다.

x,y,z=2,3,4
n=input()
while n:
 if y**3+x**3-z**3==1and x<y<z:print z**3+1;n-=1
 x+=1
 if y<x:y+=1;x=2
 if z<y:z+=1;y=3

에 대한 출력 n = 5:

1729
1092728
3375001
15438250
121287376

TI 기본, 90 바이트

더 짧은 방법이 있어야합니다 ...

Prompt N
2->X
3->Y
4->Z
While N
If 1=X³+Y³-Z³ and X<Y and Y<Z
Then
DS<(N,0
X+1->X
If Y<X
Then
2->X
Y+1->Y
End
If Z<Y
Then
3->Y
Z+1->Z
End
End

MATLAB, 94 바이트

또 다른 무차별 솔루션 :

for z=4:inf,for y=3:z,for x=2:y,c=z^3+1;if x^3+y^3==c,n=n-1;c,if~n,return,end,end,end,end,end

에 대한 출력 n=4:

>> n=4; fermat_near_misses    
c =
        1729
c =
     1092728
c =
     3375001
c =
    15438250

c=디스플레이 의 일부를 억제하면 코드가 100 바이트로 증가합니다

for z=4:inf,for y=3:z,for x=2:y,c=z^3+1;if x^3+y^3==c,n=n-1;disp(c),if~n,return,end,end,end,end,end

>> n=4; fermat_near_misses_cleandisp    
        1729
     1092728
     3375001
    15438250

C #을 188 174 187 136 바이트

훌륭한 코드 골프 및 팁을 제공 한 TheLethalCoder 덕분에 골프 버전 ( 온라인 시도 ) :

n=>{for(long a,b,c=3;n>0;c++)for(a=2;a<c;a++)for(b=a;b<c;b++)if(a*a*a+b‌​*b*b==c*c*c+1)System‌​.Console.WriteLin‌e(‌​c*c*(a=c)+n/n--);};

i10 랩탑에서 처음 10 개의 숫자를 찾는 실행 시간 : 33,370842 초 (원래 버전은 같은 작업에서 9,618127 초)

언 골프 버전 :

using System;

public class Program
{
    public static void Main()
    {
        Action<int> action = n =>
        {
            for (long a, b, d, c = 3; n > 0; c++)
                for (a = 2; a < c; a++)
                    for (b = a; b < c; b++)
                        if (a * a * a + b‌ * b * b == c * c * c + 1)
                            System‌.Console.WriteLin‌e( c * c * (a = c) + n / n--);
        };

        //Called like
        action(5);
    }
}

이전 골프 187 바이트 버전 포함 using System;

using System;static void Main(){for(long a,b,c=3,n=int.Parse(Console.ReadLine());n>0;c++)for(a=2;a<c;a++)for(b=a;b<c;b++)if(a*a*a+b*b*b==c*c*c+1)Console.WriteLin‌​e(c*c*(a=c)+n/n--);}

이전 골프 174 바이트 버전 (Peter Taylor 덕분) :

static void Main(){for(long a,b,c=3,n=int.Parse(Console.ReadLine());n>0;c++)for(a=2;a<c;a++)for(b=a;b<c;b++)if(a*a*a+b*b*b==c*c*c+1)Console.WriteLin‌​e(c*c*(a=c)+n/n--);}

이전 (원본) 골프 188 바이트 버전 ( 온라인 시도! ) :

static void Main(){double a,b,c,d;int t=0,n=Convert.ToInt32(Console.ReadLine());for(c=3;t<n;c++)for(a=2;a<c;a++)for(b=a;b<c;b++){d=(c*c*c)+1;if(a*a*a+b*b*b==d){Console.WriteLine(d);t++;}}}

i7 랩탑에서 처음 10 개의 숫자를 찾는 실행 시간 : 9,618127 초

이것은 C # 코딩에서 처음 시도한 것입니다 ... 다른 언어에 비해 조금 장황합니다 ...

GameMaker 언어, 119 바이트

왜 show_message()이렇게 길어요 :(

x=2y=3z=4w=argument0 while n>0{if x*x*x+y*y*y-z*z*z=1&x<y&y<z{show_message(z*z*z+1)n--}x++if y<x{x=2y++}if z<y{y=3z++}}

x, y, z = 2,3,4 n = input () n : y 3 + x 3-z3 == 1이고 x3 + 1; n- = 1 x + = 1 인 경우 y

공리, 246 바이트

h(x:PI):List INT==(r:List INT:=[];i:=0;a:=1;repeat(a:=a+1;b:=1;t:=a^3;repeat(b:=b+1;b>=a=>break;q:=t+b^3;l:=gcd(q-1,223092870);l~=1 and(q-1)rem(l^3)~=0=>0;c:=round((q-1)^(1./3))::INT;if c^3=q-1 then(r:=cons(q,r);i:=i+1;i>=x=>return reverse(r)))))

ungof와 결과

-- hh returns x in 1.. numbers in a INT list [y_1,...y_x] such that 
-- for every y_k exist a,b,c in N with y_k=a^3+b^3=c^3+1 
hh(x:PI):List INT==
   r:List INT:=[]
   i:=0;a:=1
   repeat
      a:=a+1
      b:=1
      t:=a^3
      repeat
          b:=b+1
          b>=a=>break
          q:=t+b^3
          l:=gcd(q-1,223092870);l~=1 and (q-1)rem(l^3)~=0 =>0 -- if l|(q-1)=> l^3|(q-1)
          c:=round((q-1.)^(1./3.))::INT
          if c^3=q-1 then(r:=cons(q,r);i:=i+1;output[i,a,b,c];i>=x=>return reverse(r))

(3) -> h 12
   (3)
   [1729, 1092728, 3375001, 15438250, 121287376, 401947273, 3680797185,
    6352182209, 7856862273, 12422690497, 73244501505, 145697644729]
                                                       Type: List Integer