Pythagore s'est fait exploser la jambe pendant la guerre. Il a dû être amputé et, bien qu'il ait failli mourir, il s'en est tiré et s'est complètement rétabli. Maintenant, après un an de marche avec des béquilles, il a le privilège de se faire faire une prothèse de jambe! La chose est, cependant, il y en a plusieurs qui correspondent, mais lesquels?

La tâche

Si vous entrez un nombre entier positif correspondant à la longueur d'une jambe d'un triple de Pythagore, affichez toutes les possibilités pour l'autre jambe. Par exemple, le plus petit triple de Pythagore est (3,4,5), qui forme un triangle avec deux jambes de longueur 3 et 4 et une hypoténuse de longueur 5.

Exemples

Leg:5
12

Leg:28
21
45
96
195

Leg:101
5100

Leg:1001
168
468
660
2880
3432
4080
5460
6468
10200
38532
45540
71568
501000

Les règles

• L'entrée sera un seul entier positif n.
• La sortie peut être dans n’importe quel ordre, avec n’importe quel délimiteur, dans n’importe quelle base (même si cette base doit être cohérente), avec des accolades optionnelles pour l’ouverture et la fermeture et des espaces de fin optionnels. C'est-à- 1 2 3dire [1,2,3], et que 1,11,111tous correspondent à cette spécification de sortie.
• Vous pouvez supposer que nne dépassera jamais le quart de la quatrième racine de la limite de votre langue (sans utiliser de bibliothèques). En pratique, vous pouvez supposer que l’entrée sera inférieure ou égale à 10 000, la valeur la moins élevée étant retenue.

Pythagore vous attend, alors mieux vaut écrire votre code rapidement et brièvement!

Pyth - 13 octets

Brute force tous les possibles jusqu'à n^2+1.

f!%.a,TQ1S*QQ

Suite de test .

Gelée , 8 octets

²R²+²Æ²O

Cette réponse est non compétitive, car elle utilise des fonctionnalités qui ont été mises en œuvre après la publication du défi. Essayez-le en ligne!

Cette approche n'utilise pas de calcul en virgule flottante, elle donnera donc la bonne réponse tant que les listes intermédiaires pourront être mémorisées.

Idée

Si (a, b, c) est un triple de Pythagore, il existe des entiers strictement positifs k, m, n tels que l'égalité définie {a, b} = {km ² - kn ² , 2kmn} est vérifiée .

En particulier, cela signifie que a <b ² et b <a ² , donc pour l'entrée a, nous pouvons simplement vérifier si a ² + b ² est un carré parfait pour chaque b dans {1,… a ² } .

Code

            Input: x

²           Compute x².
 R          Get get range 1 ... x².
  ²         Square each integer in that range.
   +²       Add x² to each resulting square.
     Ʋ     Check if the resulting sums are perfect squares.
       O    Get all indices of ones.

Julia, 35 octets

n->filter(i->hypot(i,n)%1==0,1:n^2)

C'est une fonction anonyme qui accepte un entier et retourne un tableau.

Pour chaque valeur iallant de 1 à l'entrée au carré, nous calculons l'hypoténuse à l'aide de la fonction intégrée de Julia hypotet déterminons si la partie fractionnaire est 0. Si c'est le cas, nous la conservons, sinon elle est exclue.

CJam, 17 octets

{:A2#{Amh1%!},1>}

C'est une fonction anonyme qui extrait un entier de la pile et laisse un tableau en retour.

Essayez-le en ligne!

Idée

Si (a, b, c) est un triple de Pythagore, il existe des entiers strictement positifs k, m, n tels que l'égalité définie {a, b} = {km ² - kn ² , 2kmn} est vérifiée .

En particulier, cela signifie que a <b ² et b <a ² , donc pour l’entrée a nous pouvons simplement vérifier si a ² + b ² est un carré parfait pour chaque b dans {1,… a ² } .

Code

:A               Save the input in A.
  2#             Square it.
    {      },    Filter; for each B in {0, ..., A**2}:
     Amh           Calculate the hypotenuse of (A, B).
        1%!        Apply logical NOT to its fractional part.
                 Keep B if ! pushed 1.
             1>  Discard the first kept B (0).  

JavaScript ES6, 60 62

Identique aux autres réponses, en vérifiant de 1 à a * a-1

a=>[...Array(a*a).keys()].filter(b=>b&&!(Math.hypot(a,b)%1))

Merci à @ Mwr247 le le plus de créer une gamme dans ES6

2 octets enregistrés thx @ETHproductions

C, 96 octets

Incrémentez alternativement y(l'autre jambe) et z(l'hypoténuse) jusqu'à ce que leur différence chute à 1. Affichez chaque correspondance exacte ( c==0) que vous rencontrez en chemin.

int x,y,z;main(int c,char**a){for(x=z=atoi(a[1]);++y<z;c=x*x+y*y-z*z,c?z+=c>0:printf("%d ",y));}

Appelez le programme compilé avec n comme paramètre; il produira une liste de nombres décimaux séparés par des espaces.

Évidemment pas le plus court; Je peux trouver du réconfort en ayant le plus rapide.

$ time ./pyth 9999
200 2020 13332 13668 16968 44440 45360 54540 55660 137532 164832 168168 413080 494900 504900 617120 1514832 1851468 4544540 5554440 16663332 49990000 
real    0m0.846s
user    0m0.800s
sys     0m0.000s

Wolfram Language (Mathematica) , 40 octets

b/.Solve[#^2+b^2==c^2,PositiveIntegers]&

J'utilise une forme non documentée Solve: lorsque la liste de variables est omise, la Solverésolution par défaut de tous les symboles de l'expression est résolue. Nous économisons ainsi 6 octets sur le plus régulier Solve[#^2+b^2==c^2,{b,c},PositiveIntegers].

PositiveIntegersest nouveau dans la version 12 de Mathematica et n'est donc pas disponible dans TIO . Dans Mathematica, nous obtenons

F = b/.Solve[#^2+b^2==c^2,PositiveIntegers]& ;

F[5]
(*    {12}    *)

F[28]
(*    {21, 45, 96, 195}    *)

F[101]
(*    {5100}    *)

F[1001]
(*    {168, 468, 660, 2880, 3432, 4080, 5460, 6468, 10200, 38532, 45540, 71568, 501000}    *)

Python 2, 53 octets

lambda n:[i for i in range(1,n*n)if abs(i+n*1j)%1==0]

Une solution simple en utilisant complexe abspour calculer la longueur de l'hypoténuse. C'est sûr d'utiliser n*ncomme limite supérieure pour l'autre jambe parce que (n*n)^2 + n^2 < (n*n+1)^2. J'ai essayé d'utiliser la récursivité à la place, mais rien de plus court.

Sérieusement, 20 octets

,;╗ªDR;`╜@ÇA1@%Y`M@░

Même stratégie que la réponse Python de xnor: i in range(1,n*n)recherchez les valeurs où abs(i+nj) % 1 == 0et affichez la liste.Essayez-le en ligne

Explication:

,;╗    get input and save a copy in register 0
ªDR;   push two copies of range(1,n*n)
`╜@ÇA1@%Y`M    map the function across one of the ranges:
    ╜@ÇA         compute abs(i+nj)
    1@%Y         push 1 if result % 1 is 0, else 0
M@░    swap the two lists, take values in the original range where the corresponding values in the second range are truthy

PARI / GP, 36 octets

x->[y|y<-[1..x^2],issquare(x^2+y^2)]

APL (NARS), 373 caractères, 746 octets

C←{h←{0=k←⍺-1:,¨⍵⋄(k<0)∨k≥i←≢w←⍵:⍬⋄↑,/{w[⍵],¨k h w[(⍳i)∼⍳⍵]}¨⍳i-k}⋄1≥≡⍵:⍺h⍵⋄⍺h⊂¨⍵}⋄P←{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨P w[a∼⍵]}¨a←⍳k}⋄d←{∪×/¨{k←≢b←1,π⍵⋄∪{b[⍵]}¨↑∪/101 1‼k k}⍵}⋄t←{(-/k),(×/2,⍵),+/k←⍵*2}⋄b←{⍬≡a←3 C d w←⍵:(⊂1,⍵,1)⋄(⊂1,⍵,1),a/⍨{⍵[2]>⍵[3]}¨a←↑∪/P¨,a/⍨{w=×/⍵}¨a}⋄u←{(↑⍵),2÷⍨(+/a),-/a←1↓⍵}⋄t1←{(↑¨⍵)×t¨1↓¨⍵}⋄f1←{0=2∣⍵:↑¨t1 b⍵÷2⋄{2⊃⍵}¨t1 u¨b⍵}⋄f←{m←⎕ct⋄⎕ct←0⋄r←f1⍵⋄⎕ct←m⋄r}

commentaire:

C: ⍺ combination in ⍵ list
P: permutations  in ⍵ list
d: divisors of ⍵ unsigned
t: Pythagorian triple from ⍵ list 2 unsigned
b: if argument ⍵ is one unsigned it would return the list of (k,i,j) where 
   k,i,j are all divisors of ⍵, and ⍵=k×i×j and i>j
u: from one triple (k,i,j) return (k,(i+j)/2,(i-j)/2)
t1: apply (k,i,j) to t in the way  k×t i,j 
f: the function of this exercise

L'idée serait de prendre en compte l'entrée pour connaître le m possible, n générant en utilisant tout le triple de Pythagore ayant l'entrée comme jambe. Tester:

  f 18298292829831839x
167413760243137645229428509060960 15219432749376149566311682641900 99808869980900940 
  1383584795397831778755607512840 
  f 5
12
  f 28
195 96 21 45 
  f 101
5100
  f 1001
501000 6468 38532 2880 468 660 168 5460 45540 4080 71568 3432 10200 
  ≢f 1001
13
  f 1663481166348349x
1383584795397831778755607512900 
  f 198820182831x
19764732550476133587280 346749693868002343608 5664631173992 6083327962596530720 613900915408 115583231289334114460 
  18249983887789596492 1883559626820 1040249081604007030900 54749951663368790920 6588244183492044529092 
  265093577108 2196081394497348176360 

APL (Dyalog Extended) , 15 ^{SBCS de} 14 octets

Fonction de préfixe tacite anonyme.

(⍸⊢(+∊⊢)⍳×⍳)×⍨

Essayez-le en ligne!

×⍨ square (lit. multiplication selfie of) de l'argument

(… ) Applique la fonction tacite anonyme suivante:

 ⍳ ɩ ntegers 1 à l'argument

 ⍳ multiplier par ɩ ntegers 1 à l'argument (c. -à- carré)

 ⊢(… ) Applique la fonction tacite anonyme suivante avec l'argument comme argument de gauche:

  + est la somme

  ∊ un membre de

  ⊢ il?

 ⍸ d conseils de vérités

Perl 5, 43 octets

$i=<>;{sqrt(++$_**2+$i**2)!~/\./&&say;redo}

Si vous voulez que le script se termine, nous pouvons inspecter d’autres branches jusqu’à n², comme expliqué par xnor . Nous avons donc 48 octets:

map{sqrt(++$_**2+$i**2)!~/\./&&say}1..($i=<>)**2

Japt , 16 octets

1oU² f@!(MhXU %1

Essayez-le en ligne!

Comment ça marche

        // Implicit: U = input integer
1oU²    // Generate a range of integers from 1 to U squared.
f@!(    // Keep only items X that return falsily to:
MhXU %1 //  Math.hypot(X,U) % 1.
        // This keeps only the items where sqrt(X*X+U*U) = 0.
        // Implicit: output last expression

Stax , 8 octets

î←■↑»⌐╚â

Exécuter et déboguer

En pseudo-code:

(1..n²).filter(d -> is-square(n² + d²))

05AB1E , 10 octets

nDLn+Ųƶ0K

Essayez-le en ligne ou vérifiez tous les cas de test .

nDLʒnIn+Ų

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

n           # Take the square of the (implicit) input-integer
 D          # Duplicate it
  L         # Create a list in the range [1, input^2]
   n        # Square each value in this list
    +       # Add the input^2 we duplicated to each
     Ų     # Check for each of these if it's a square (1 if truthy; 0 if falsey)
       ƶ    # Multiply each value by its 1-based index
        0K  # Remove all 0s from the list
            # (after which the result is output implicitly)

nDL         # Same as above
   ʒ        # Filter this list by:
    n       #  Get the square of the current number
     In+    #  Add the squared input to it
        Ų  #  And check if it's a square
            # (after the filter, implicitly output the result)

MathGolf , 9 octets

²╒gƲk²+°

Essayez-le en ligne!

Impossible de trouver un bon moyen de supprimer les ²s, qui occupent 3/9 octets. Sinon, c'est assez simple

Explication

²           square input
 ╒          range(1,n+1)
  gÆ        filter list using next 5 operators
    ²       square list element
     k²     push input squared
       +    pop a, b : push(a+b)
        °   is perfect square

Java 8, 72 octets

n->{for(int i=0;++i<n*n;)if(Math.hypot(i,n)%1==0)System.out.println(i);}

Essayez-le en ligne.

Explication:

n->{                           // Method with integer as parameter and no return-type
  for(int i=0;++i<n*n;)        //  Loop `i` in the range (0, n²)):
    if(Math.hypot(i,n)         //   If sqrt(i² + n²)
       %1==0)                  //   has no decimal digits after the comma (so is an integer)
      System.out.println(i);}  //    Output `i` with trailing newline