Un triple de Pythagore est constitué de trois entiers positifs a, b et c, tels que a ² + b ² = c ² . Un tel triple est couramment écrit (a, b, c), et un exemple bien connu est (3, 4, 5). Si (a, b, c) est un triple de Pythagore, alors il en est de même (ka, kb, kc) pour tout entier positif k. Un triple primitif de Pythagore est un triple dans lequel a, b et c sont coprimes .

En utilisant cette connaissance, nous pouvons créer une séquence en enchaînant les plus petites longueurs de triples, où l'élément suivant de la séquence est l'hypoténuse (le plus grand nombre) du plus petit triple primitif de Pythagore, contenant l'élément précédent en tant que plus petit de ses longueurs.

Commencez avec le plus petit triple primitif de Pythagore (3, 4, 5). La séquence commence par 3, et l'hypoténuse (élément suivant de la séquence) l'est 5. Ensuite, trouvez le plus petit triple primitif de Pythagore avec 5une jambe et vous obtenez (5, 12, 13). Donc la séquence continue avec 13.

Sortez la séquence pour toujours ou prenez une entrée entière net sortez les premiers néléments de la séquence, zéro ou un indexé.

Vous devez prendre en charge la sortie au moins jusqu'à et y compris 28455997, mais si la limite du type de données que vous utilisez était soudainement augmentée, il devrait fonctionner pour cette nouvelle limite. Vous ne pouvez donc pas coder en dur une liste de nombres.

3
5
13
85
157
12325
90733
2449525
28455997
295742792965
171480834409967437
656310093705697045
1616599508725767821225590944157
4461691012090851100342993272805
115366949386695884000892071602798585632943213
12002377162350258332845595301471273220420939451301220405

OEIS A239381

Séquences similaires (ne les sortez pas!):

• A018928
• A077034 (les termes impairs)

Gelée , 19 octets

o3ṄÆF*/€ŒPP€²+Ṛ$HṂß

Sauvegardé un octet grâce à @ Dennis en refacturant une séquence infinie.

Ne prend aucune entrée ni argument, puis affiche la séquence indéfiniment en imprimant chaque terme au fur et à mesure de son calcul. Cette méthode ralentit au fur et à mesure que le nombre augmente, car elle dépend de la factorisation en facteurs premiers.

Essayez-le en ligne!

Ceci calcule le terme suivant en calculant la factorisation de la puissance première du terme actuel. Pour 12325, il s’agit de {5 ² , 17, 29}. Il existe une variante de la formule de Euclide pour calculer les triples de Pythagore { a , b , c },

où m > n et le triple est primitif si et seulement si m et n sont coprimes.

Pour calculer la prochaine racine primitive à partir de 12325, recherchez m et n tels que mn = 12325 et choisissez m , n pour que gcd ( m , n ) = 1. Générez ensuite toutes les paires de m , n en créant tous les sous-ensembles de {5 ² , 17, 29} et trouver le produit de chacun de ces sous-ensembles qui sont {1, 25, 17, 29, 425, 725, 493, 12325}. Ensuite, divisez 12325 par chaque valeur et appliquez la paire de sorte que chaque paire soit m , n . Calculez la formule pour c en utilisant chaque paire et prenez le minimum qui est 90733.

• La méthode précédente échouait pour déterminer le terme suivant après 228034970321525477033478437478475683098735674620405573760405155755195495195195195195195195195195195495195. La nouvelle méthode est plus lente mais fonctionnera toujours car elle teste toutes les paires de coprimes pour trouver l'hypoténuse minimale.

Explication

o3ṄÆF*/€ŒPP€²+Ṛ$HṂß  Main link. Input: 0 if none, else an integer P
o3                   Logical OR with 3, returns P if non-zero else 3
  Ṅ                  Println and pass the value
   ÆF                Factor into [prime, exponent] pairs
     */€             Reduce each pair using exponentation to get the prime powers
        ŒP           Powerset of those
          P€         Product of each
            ²        Square each
               $     Monadic chain
             +         Add vectorized with
              Ṛ        the reverse
                H    Halve
                 Ṃ   Minimum
                  ß  Call recursively on this value

Brachylog , 36 octets

3{@wB:?>:^a+~^=C:B:?:{$pd}ac#d,C:1&}

Essayez-le en ligne!

Vous devez attendre la fin du programme (1 minute) avant que TIO ne vide la sortie. Dans REPL de SWI-Prolog, cela s'imprime dès qu'il trouve la valeur.

Cela imprimera la séquence pour toujours.

Après quelques minutes d'interprétation hors ligne de SWI-Prolog, j'ai obtenu 90733après 12325. Je l'ai arrêté après ce point.

Ce n'est pas un effort brutal complet, car il utilise des contraintes pour trouver des triples pythagoriciens, bien qu'il ne soit évidemment pas optimisé pour la vitesse.

Explication

3{                                 }    Call this predicate with 3 as Input
  @w                                    Write the Input followed by a line break
    B:?>                                B > Input
           +                            The sum...
        :^a                             ...of Input^2 with B^2...
            ~^                          ...must equal a number which is itself a square
              =C                        Assign a fitting value to that number and call it C
               C:B:?:{$pd}a             Get the lists of prime factors of C, B and Input
                                          without duplicates
                           c#d,         Concatenate into a single list; all values must be
                                          different
                               C:1&     Call recursively with C as Input

Perl, 73 octets

for($_=3;$_<1e9;$_=$a**2+$b**2){$a++until($b=($_+$a**2)**.5)==($b|0);say}

Tous les triples de Pythagore a²+b²=c²satisfont a=r(m²-n²), b=2rmn, c=r(m²+n²)pour certains entiers r,m,n. Quand r=1et m,nsont coprimes avec exactement un divisible par 2, alors a,b,cest un triple primitif, où a,b,csont tous deux coprimes.

Gardant cela à l’esprit, aj’utilise un algorithme de force brute pour calculer le plus petit ntel qu’il a²-n²s’agit d’un carré, à savoir m². Alors, cest égal à n²+m².

Python 3, 178 octets

from math import*
p,n=[3,5],int(input())
while len(p)<n:
 for i in range(p[-1],p[-1]**2):
  v=sqrt(i**2+p[-1]**2)
  if v==int(v)and gcd(i,p[-1])==1:
   p+=[int(v)];break
print(p)

Ceci est fondamentalement juste un algorithme de force brute, et est donc très lent. Il faut la quantité de termes à afficher en entrée.

Je ne suis pas sûr à 100% de l'exactitude de cet algorithme, le programme vérifie que l'autre jambe correspond à la première jambe carrée, ce qui est suffisant, mais je n'ai pas fait le calcul.

Essayez-le sur repl.it! (Obsolète) (Merci de ne pas l'essayer pour des nombres supérieurs à 10, ce sera très lent)

MATL , 27 octets

Ii:"`I@Yyt1\~?3MZdZdq]}6MXI

Cela produit les premiers termes de la séquence. L'entrée est basée sur 0.

Le code est très inefficace. Le compilateur en ligne expire pour des entrées supérieures à 5. L'entrée 6prenait une minute et demie hors ligne (et produisait le 907336ème terme correct ).

Essayez-le en ligne!

I            % Push 3 (predefined value of clipboard I)
i            % Input n
:"           % For each (i.e. execute n times)
  `          %   Do...while
    I        %     Push clipboard I. This is the latest term of the sequence
    @        %     Push iteration index, starting at 1
    Yy       %     Hypotenuse of those two values
    t1\      %     Duplicate. Decimal part
    ~?       %     If it is zero: we may have found the next term. But we still
             %     need to test for co-primality
      3M     %       Push the two inputs of the latest call to the hypotenuse 
             %       function. The stack now contains the hypotenuse and the
             %       two legs
      ZdZd   %       Call GCD twice, to obtain the GCD of those three numbers
      q      %       Subtract 1. If the three numbers were co-prime this gives
             %       0, so the do...while loop will be exited (but the "finally" 
             %       part will be executed first). If they were not co-prime  
             %       this gives non-zero, so the do...while loop proceeds 
             %       with the next iteration
    ]        %     End if
             %     If the decimal part was non-zero: the duplicate of the 
             %     hypotenuse that is now on the top of the stack will be used
             %     as the (do...while) loop condition. Since it is non-zero, 
             %     the loop will proceed with the next iteration
  }          %   Finally (i.e. execute before exiting the do...while loop)
    6M       %     Push the second input to the hypotenuse function, which is
             %     the new term of the sequence
    XI       %     Copy this new term into clipboard I
             %   Implicitly end do...while
             % Implicitly end for each
             % Implicitly display the stack, containing the sequence terms

Raquette 106 octets

(let p((h 3))(println h)(let p2((i 1))(define g(sqrt(+(* h h)(* i i))))(if(integer? g)(p g)(p2(add1 i)))))

Ungolfed:

(define (f)
  (let loop ((h 3))
    (let loop2 ((i 1))
      (define g (sqrt (+(* h h) (* i i))))
      (if (not(integer? g))
          (loop2 (add1 i))
          (begin (printf "~a ~a ~a~n" h i g)
                 (loop g))))))

Essai:

(f)

Sortie de la version golfée:

3
5
13
85
157
12325
12461
106285
276341
339709
10363909
17238541

Sortie de la version non-golfée:

3 4 5
5 12 13
13 84 85
85 132 157
157 12324 12325
12325 1836 12461
12461 105552 106285
106285 255084 276341
276341 197580 339709
339709 10358340 10363909
10363909 13775220 17238541

(Erreur après ceci sur ma machine)

Wolfram Language (Mathematica) , 74 octets

Nest[c/.#&@@Solve[{#^2+b^2==c^2,#<b<c&&GCD[b,c]==1},{b,c},Integers]&,3,#]&

Essayez-le en ligne!

Wolfram Language (Mathematica) , 74 octets

Nest[#&@@Cases[Divisors@#,d_/;GCD[d,#/d]<2&&d^2>#:>(d^2+(#/d)^2)/2]&,3,#]&

Essayez-le en ligne!

PHP, 139 octets

for($k=3;$i=$k,print("$k\n");)for($j=$i+1;($k=sqrt($m=$i*$i+$j*$j))>(int)$k||gmp_intval(gmp_gcd(gmp_gcd((int)$i,(int)$j),(int)$k))>1;$j++);

Le code ci-dessus se rompt après 28455997 sur les systèmes 32 bits. Si des nombres plus élevés sont nécessaires, cela devient 156 octets:

for($k=3;$i=$k,print("$k\n");)for($j=$i+1;!gmp_perfect_square($m=bcadd(bcpow($i,2),bcpow($j,2)))||gmp_intval(gmp_gcd(gmp_gcd($i,$j),$k=bcsqrt($m)))>1;$j++);

Java 8, 133 octets

-25 octets grâce aux miles Utilisation de n * n à la place de Math.pow (n, 2)

-24 octets grâce aux miles Utilisation des boucles for à la place de while, modification du type de données, élimination de () en raison de l'ordre des opérations

()->{long b=3,c,n;for(;;){for(n=1;;n++){c=b+2*n*n;double d=Math.sqrt(c*c-b*b);if(d==(int)d&b<d){System.out.println(b);break;}}b=c;}};

Utilise le fait que

pour toute paire d'entiers m> n> 0. Par conséquent, C est égal à A plus 2 (N) ² . La fonction ci-dessus trouve la plus petite valeur de N qui satisfait cette relation, tout en faisant du deuxième élément du triple de Pythagore un entier et supérieur au premier élément. Ensuite, il définit la valeur du premier élément sur le troisième élément et répète avec le premier élément mis à jour.

Ungolfed:

void printPythagoreanTriples() {
    long firstElement = 3, thirdElement, n;
    while (true) {
        for (n = 1; ; n++) {
            thirdElement = firstElement + (2 * n * n);
            double secondElement = Math.sqrt(thirdElement * thirdElement - firstElement * firstElement);
            if (secondElement == (int) secondElement && firstElement < secondElement) {
                System.out.println("Found Pythagorean Triple [" +
                        firstElement + ", " +
                        secondElement + ", " +
                        thirdElement + "]");
                break;
            }
        }
        firstElement = thirdElement;
    }
}

Ideone ça!

* L'idéone n'imprime pas le dernier élément requis en raison de délais, comme vous pouvez le constater à travers la logique du programme et la version non-golfée (qui imprime le 28455997 en tant que troisième élément du précédent triple de Pythagore plutôt que le premier la suivante), les valeurs sont, avec une limite de temps supérieure, imprimées.

Python 3.5, 97 octets

Mauvaise sortie après 28455997, à cause des limites du type de données à virgule flottante. La sqrtfonction ne suffit pas, mais si la précision était augmentée comme par magie, cela fonctionnerait.

Assez simple à comprendre. L'incrémentation cde deux au lieu de un réduit le temps d'exécution de moitié, et seuls les nombres impairs doivent de toute façon être vérifiés, car les éléments sont toujours impairs.

import math
c=a=3
while 1:
	c+=2;b=(c*c-a*a)**.5;i=int(b)
	if math.gcd(a,i)<2<a<b==i:print(a);a=c

Essayez-le en ligne

Le programme ne peut pas être exécuté sur Ideone, car Ideone utilise Python 3.4

Pour que la sortie reste précise plus longtemps, je devrais utiliser decimal:

import math
from decimal import*
c=a=3
while 1:
	c+=2;b=Decimal(c*c-a*a).sqrt();i=int(b)
	if i==b>a>2>math.gcd(a,i):print(a);a=c

Essayez-le en ligne

Pour rester précis indéfiniment, je pourrais faire quelque chose d’horrible comme celui-ci (augmenter la précision requise à chaque itération :

import math
from decimal import*
c=a=3
while 1:
	c+=2;b=Decimal(c*c-a*a).sqrt();i=int(b);getcontext().prec+=1
	if i==b>a>2>math.gcd(a,i):print(a);a=c

J , 54 47 octets

-:@+/@:*:@((*/:~)/)@,.&1@x:@(^/)@(2&p:)^:(<12)3

TIO

scission gourmande de facteurs premiers en facteurs de coprime

vieux 54 octets TIO

Paris / GP , 71 octets

n->a=3;for(i=1,n,a=[d^2+e^2|d<-divisors(a),gcd(d,e=a/d)<2&&d>e][1]/2);a

Essayez-le en ligne!

APL (NARS), 169 caractères, 338 octets

h←{{(m n)←⍵⋄(mm nn)←⍵*2⋄(2÷⍨nn+mm),(2÷⍨nn-mm),m×n}a⊃⍨b⍳⌊/b←{⍵[2]}¨a←a/⍨{(≤/⍵)∧1=∨/⍵}¨a←(w÷a),¨a←∪×/¨{k←≢b←1,π⍵⋄∪{b[⍵]}¨↑∪/101 1‼k k}w←⍵}⋄p←{⍺=1:⍵⋄⍵,(⍺-1)∇↑h ⍵}⋄q←{⍵p 3x}

test ok jusqu'à 14 comme argument de q:

  q 1
3 
  q 2
3 5 
  q 10
3 5 13 85 157 12325 90733 2449525 28455997 295742792965 
  q 12
3 5 13 85 157 12325 90733 2449525 28455997 295742792965 171480834409967437 656310093705697045 
  q 13
3 5 13 85 157 12325 90733 2449525 28455997 295742792965 171480834409967437 656310093705697045 
  1616599508725767821225590944157 
  q 14
NONCE ERROR
  q 14
  ∧

cette ci-dessous trouverait tous les diviseurs de son argument ...

∪×/¨{k←≢b←1,π⍵⋄∪{b[⍵]}¨↑∪/101 1‼k k}

JavaScript (Node.js) , 101 octets

_=>{for(var a=3,b,c;;){for(c=1;;c++)if(b=a+2*c*c,d=Math.sqrt(b*b-a*a),d==+d&a<d){alert(a);break}a=b}}

Essayez-le en ligne!

Les suggestions sur le golf sont les bienvenues