Pitagora si è fatto saltare una gamba in guerra. Doveva essere amputato e, sebbene fosse quasi morto, si fece avanti e si riprese completamente. Ora, dopo un anno di camminate con le stampelle, ottiene il privilegio di ottenere una gamba protesica! Il fatto è che ce ne sono molti che si adattano, ma quali?

L'obiettivo

Dato un intero positivo come input che è la lunghezza di una gamba di una tripla pitagorica, produce tutte le possibilità per l'altra gamba. Ad esempio, la più piccola tripla pitagorica è (3,4,5), che forma un triangolo con due zampe di lunghezza 3 e 4 e un ipotenusa di lunghezza 5.

Esempi

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

Le regole

• L'input sarà un singolo numero intero positivo n .
• L'output può essere in qualsiasi ordine, con qualsiasi delimitatore, in qualsiasi base (sebbene questa base debba essere coerente) e con parentesi graffe di apertura e chiusura opzionali e spazi bianchi finali opzionali. Cioè, 1 2 3, [1,2,3], e1,11,111 tutti in forma questa specifica di uscita.
• Puoi presumere che nnon sarà mai maggiore di un quarto della quarta radice del limite della tua lingua (senza usare le librerie). In pratica, si può presumere che l'input sarà inferiore a questo o a 10.000, a seconda di quale sia minore.

Pitagora ti sta aspettando, quindi meglio scrivere il tuo codice veloce e breve!

Pyth - 13 byte

Le forze brutali sono possibili fino a quel momento n^2+1.

f!%.a,TQ1S*QQ

Test Suite .

Gelatina , 8 byte

²R²+²Æ²O

Questa risposta non è competitiva, poiché utilizza funzionalità implementate dopo la pubblicazione della sfida. Provalo online!

Questo approccio non utilizza la matematica in virgola mobile, quindi fornirà la risposta corretta fino a quando gli elenchi intermedi potranno adattarsi alla memoria.

Idea

Se (a, b, c) è una tripla pitagorica, vi sono numeri interi assolutamente positivi k, m, n tali che vale l'uguaglianza impostata {a, b} = {km ² - kn ² , 2kmn} .

In particolare, ciò significa che una <b ² e b <a ² , quindi per ingresso un possiamo semplicemente verificare se un ² + b ² è un quadrato perfetto per ogni b in {1, ... un ² } .

Codice

            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 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce un array.

Per ciascuno ida 1 al quadrato di input, calcoliamo l'ipotenusa utilizzando la funzione integrata di Julia hypote determiniamo se la porzione frazionaria è 0. In tal caso, la manteniamo, altrimenti viene esclusa.

CJam, 17 byte

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

Questa è una funzione anonima che estrae un numero intero dallo stack e lascia un array in cambio.

Provalo online!

Idea

Se (a, b, c) è una tripla pitagorica, vi sono numeri interi assolutamente positivi k, m, n tali che vale l'uguaglianza impostata {a, b} = {km ² - kn ² , 2kmn} .

In particolare, ciò significa che una <b ² e b <a ² , quindi per ingresso un possiamo semplicemente verificare se un ² + b ² è un quadrato perfetto per ogni b in {1, ... un ² } .

Codice

: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

Come le altre risposte, controllando da 1 a a * a-1

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

Grazie a @ Mwr247 il modo più breve per creare un intervallo in ES6

2 byte salvati grazie a @ETHproductions

C, 96 byte

Aumenta alternativamente y(l'altra gamba) e z(l'ipotenusa) fino a quando la loro differenza non scende a 1. Emetti ogni corrispondenza esatta ( c==0) che incontri lungo la strada.

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

Chiama il programma compilato con n come parametro; produrrà un elenco separato da spazi di numeri decimali.

Ovviamente non il più breve; Potrei trovare conforto nell'avere il più veloce.

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

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

Sto usando una forma non documentata di Solve: quando l'elenco di variabili viene omesso, Solveper impostazione predefinita viene risolto per tutti i simboli nell'espressione. In questo modo risparmiamo 6 byte su quelli più regolari Solve[#^2+b^2==c^2,{b,c},PositiveIntegers].

PositiveIntegersè nuovo nella versione 12 di Mathematica e quindi non disponibile in TIO . Nel desktop Mathematica, otteniamo

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 byte

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

Una soluzione semplice che utilizza complesse absper calcolare la lunghezza dell'ipotenusa. n*nPerché è sicuro usare come limite superiore per l'altra gamba perché (n*n)^2 + n^2 < (n*n+1)^2. Ho provato a usare la ricorsione, ma non ho ottenuto niente di più breve.

Scherzi a parte, 20 byte

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

Stessa strategia della risposta Python di xnor: controlla i i in range(1,n*n)valori dove abs(i+nj) % 1 == 0e genera l'elenco.Provalo online

Spiegazione:

,;╗    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 byte

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

APL (NARS), 373 caratteri, 746 byte

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}

commento:

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'idea sarebbe un fattore di input per conoscere i possibili m, n che generano usando t tutto il triplo pitagorico che ha l'input come leg. Test:

  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 14 byte ^SBCS

Funzione prefisso tacito anonimo.

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

Provalo online!

×⍨ piazza (lett. selfie moltiplicazione di) l'argomento

(... ) applica la seguente funzione tacita anonima:

 ⍳ te nteger 1 attraverso l'argomento

 ⍳ moltiplicare per ɩ ntegers 1 per l'argomento (ovvero quadrato)

 ⊢(... ) applica la seguente funzione tacita anonima con l'argomento come argomento sinistro:

  + è la somma

  ∊ un membro di

  ⊢ vero?

 ⍸ d ndice di verità

Perl 5, 43 byte

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

Se vuoi che lo script termini, possiamo esaminare solo altre gambe fino a n², come spiegato da xnor , quindi abbiamo 48 byte:

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

Japt , 16 byte

1oU² f@!(MhXU %1

Provalo online!

Come funziona

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

î←■↑»⌐╚â

Esegui ed esegui il debug

In pseudo-codice:

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

05AB1E , 10 byte

nDLn+Ųƶ0K

Provalo online o verifica tutti i casi di test .

nDLʒnIn+Ų

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

²╒gƲk²+°

Provalo online!

Non è stato possibile trovare un modo efficace per rimuovere le ²s, che occupano 3/9 byte. Altrimenti è abbastanza semplice

Spiegazione

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

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

Provalo online.

Spiegazione:

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