Le dernier théorème de Fermat dit qu'il n'y a pas de solutions intégrales positives à l'équation a^n + b^n = c^npour aucune n>2. Cela a été prouvé par Andrew Wiles en 1994.

Cependant, il existe de nombreux "quasi-accidents" qui satisfont presque à l'équation diophantienne mais la manquent d'une unité. Précisément, ils sont tous supérieurs à 1 et sont des solutions intégrales de a^3 + b^3 = c^3 + 1(la séquence est la valeur de chaque côté de l'équation, dans l'ordre croissant).

Votre tâche est donnée n, d'imprimer les premières nvaleurs de cette séquence.

Voici les premières valeurs de la séquence:

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

C'est le code-golf , donc le code le plus court en octets gagne!

Gelée , 16 octets

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

Solution de force brute. Essayez-le en ligne!

*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 octets

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

Essayez-le en ligne!

Ce n'est pas une force brute complète car cela utilise des contraintes. C'est un peu lent sur TIO (environ 20 secondes pour N = 5). Prend environ 5 secondes pour N = 5et 13 secondes pour N = 6sur ma machine.

Explication

:{                           }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

Perl, 78 octets

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

Approche par force brute. Coutant le shebang comme deux, l'entrée est tirée de stdin.

Exemple d'utilisation

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

Essayez-le en ligne!

Mathematica, 95 octets

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

Fonction sans nom prenant un seul argument entier positif #et retournant une liste des #entiers souhaités . Espacé pour la lisibilité humaine:

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

La ligne 4 calcule toutes les sommes possibles de cubes d'entiers compris entre 2 et b+1 (avec l'initialisation b=9à la ligne 1) dans l'ordre trié. Les lignes 3 à 5 ne choisissent parmi ces sommes que celles qui sont aussi un de plus qu'un cube parfait; la ligne 6 limite cette liste à au plus des #valeurs, qui sont stockées dans a. Mais si cette liste contient en fait moins de #valeurs, la Whileboucle des lignes 1 à 7 s'incrémente bet réessaye. Enfin, la ligne 8 sort aune fois qu'elle a la bonne longueur.

Merde, cette version est lente! Pour un octet supplémentaire, nous pouvons changer b++à la ligne 7 b*=9et faire exécuter le code dans un délai raisonnable (en effet, c'est comme ça que je l'ai testé).

Raquette 166 octets

(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)))))

Ungolfed:

(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))))))

Essai:

(f 5)

Sortie:

1729
1092728
3375001
15438250
121287376

Python 2 , 102 98 octets

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)

Essayez-le en ligne!

Pari / GP, 107 octets

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++)))

Trouve les 10 premières solutions en 10 sec.

Objectif: a ^ 3 + b ^ 3 = c ^ 3 + 1

1. Obtient le nombre de solutions requises par argument de fonction n

2. Augmente c de 3 et pour chaque c ^ 3 + 1 recherche a et b avec 1 <a <= b <c tel que a ^ 3 + b ^ 3 = c ^ 3 + 1 . Si trouvé, diminuez le nombre requis d'autres soulutions n de 1 et répétez

3. Termine, lorsque le nombre de solutions supplémentaires requises (en n ) est égal à 0

Appelez-le pour obtenir les dix premières solutions:

F(10)

Code lisible (nécessite des accolades de tête et de fin comme indicateurs pour la notation par blocs de la fonction. Imprime également toutes les variables d'une solution pour plus de commodité):

{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 octets

(Amélioration par Dennis)

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

Python 2, 122 119 octets

^{pourquoi votez-vous toujours? Dennis a écrasé cette réponse;)}

Bienvenue dans la solution la plus longue à cette question: / J'ai réussi à raser un octet entier en allongeant les conditions et en supprimant autant de retrait que possible.

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

Sortie pour n = 5:

1729
1092728
3375001
15438250
121287376

TI-Basic, 90 octets

Il doit y avoir un chemin plus court ...

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 octets

Une autre solution de force brute:

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

Sortie pour n=4:

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

La suppression de la c=partie de l'affichage augmente le code à 100 octets

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 136 octets

Version golfée grâce à TheLethalCoder pour son excellent code de golf et ses conseils ( Essayez en ligne! ):

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

Temps d'exécution pour trouver les 10 premiers chiffres: 33,370842 secondes sur mon ordinateur portable i7 (la version originale ci-dessous était de 9,618127 secondes pour la même tâche).

Version non-golfée:

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

Version précédente de 187 octets 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--);}

Version précédente de 174 octets de golf (merci à 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--);}

Version précédente (originale) de 188 octets ( essayez en ligne! ):

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

Temps d'exécution pour trouver les 10 premiers chiffres: 9,618127 secondes sur mon ordinateur portable i7.

C'est ma toute première tentative de codage C # ... Un peu verbeux par rapport à d'autres langages ...

GameMaker Language, 119 octets

Pourquoi est-ce show_message()si long :(

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 () tandis que n: si y 3 + x 3-z3 == 1et x3 + 1; n- = 1 x + = 1 si y

Axiome, 246 octets

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 et résultat

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