[Question]
  [
Given `a, b, c` the length of the three sides of a triangle, say if the triangle is **right-angled** (i.e. has one angle equal to 90 degrees) or not.
## Input
Three **positive** integer values **in any order**
## Output
Either a specific true output (`true`, `1`, `yes`, ...) or a specific false output (`false`, `0`, `no`, ...)
## Example
```
5, 3, 4        --> yes
3, 5, 4        --> yes
12, 37, 35     --> yes
21, 38, 50     --> no
210, 308, 250  --> no
```
## Rules
* The input and output can be given [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963).
* In your submission, please state the true and the false values.
* No need to handle **negative** values or **invalid edge** triple
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an online testing environment so other people can try out your code!
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
²µSHe
```
[Try it online!](https://tio.run/##y0rNyan8///QpkNbgz1S////b6xjomMKAA "Jelly – Try It Online")
Technical note: Bytes are counted in Jelly codepage.
Explanation:
```
²µSHe  Main link.
²      Square each number.
 µ     With the new list,
  S    calculate its sum,
   H   and halve it.
    e  Check if the result exists in the new list (squared input)
```
The problem is equivalent to being given three numbers `a, b, c`, and asking if there is a permutation such that `a² + b² = c²`. This is equivalent to whether `(a² + b² + c²) ÷ 2` is one of `a², b² or c²`, so the program just checks that.
[Answer]
# [Python 2](https://docs.python.org/2/), 37 bytes
```
a,b,c=sorted(input())
1/(a*a+b*b-c*c)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P1EnSSfZtji/qCQ1RSMzr6C0RENTk8tQXyNRK1E7SStJN1krWfP//2hDIx0FY3MgNo0FAA "Python 2 – Try It Online")
-2 thanks to [FlipTack](https://codegolf.stackexchange.com/users/60919/fliptack).  
-1 thanks to [Craig Gidney](https://codegolf.stackexchange.com/users/74349/craig-gidney).
Outputs via exit code (`0` = false, `1` = true).
[Answer]
# Java 8, 44 bytes
```
(a,b,c)->(a*=a)+(b*=b)==(c*=c)|a+c==b|b+c==a
```
**Explanation:**
[Try it here.](https://tio.run/##hc5BasMwEAXQfU7xl5KjmDitaSGoN2g2WZYuRhO1KHUkEyuB0vjs7rjOthg0DGIen3@kK61S6@Px8DVwQ12HVwrxZwGEmP35g9hjN34Bl1LjKYKVnEBmFHDTYr0V08vI6zLlwNghwmJQZJxhvXpRVFjSS@UK67S1igvL@kZLttbd3Lho2E4J7cU1knAPuqZwwElqqX0@h/j59g7SU6f9d5f9qUyXXLZyyk1UsWRVGzwYPOq/Vv8qIfW8qjYS9iRTz8BNJehZMmfdWuBaZHWn/aIffgE)
```
(a,b,c)->                // Method with three integer parameters and boolean return-type
  (a*=a)+(b*=b)==(c*=c)  //  Return if `a*a + b*b == c*c`
  |a+c==b                //  or `a*a + c*c == b*b`
  |b+c==a                //  or `b*b + c*c == a*a`
                         // End of method (implicit / single-line return-statement)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 37 bytes
```
lambda*l:sum(x*x/2for x in l)**.5in l
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSvHqrg0V6NCq0LfKC2/SKFCITNPIUdTS0vPFMT4X1CUmVeikaZhqqNgrKNgoqnJBRMBck1RRQyNgIrMgdgUSdDIEChgAVSLImYAFDQAihoChf8DAA "Python 3 – Try It Online")
Might run into float precision issues with large inputs.
[Answer]
# JavaScript (ES6), ~~43~~ ~~41~~ 40 bytes
*Saved 1 byte and fixed a bug thanks to @Neil*
Takes input as an array of 3 integers. Returns `true` for right-angled and `false` otherwise.
```
a=>a.some(n=>Math.hypot(...a,...a)==n*2)
```
```
let f =
a=>a.some(n=>Math.hypot(...a,...a)==n*2)
console.log(f([5, 3, 4     ])) //  --> yes
console.log(f([3, 5, 4     ])) //  --> yes
console.log(f([12, 37, 35  ])) //  --> yes
console.log(f([21, 38, 5   ])) //  --> no
console.log(f([210, 308, 15])) //  --> no
```
---
# Original version, 44 bytes
Takes input as 3 integers. Returns `1` for right-angled and `0` otherwise.
```
(a,b,c)=>(a*=a)+(b*=b)==(c*=c)|a+c==b|b+c==a
```
### Test cases
```
let f =
(a,b,c)=>(a*=a)+(b*=b)==(c*=c)|a+c==b|b+c==a
console.log(f(5, 3, 4     )) //  --> yes
console.log(f(3, 5, 4     )) //  --> yes
console.log(f(12, 37, 35  )) //  --> yes
console.log(f(21, 38, 5   )) //  --> no
console.log(f(210, 308, 15)) //  --> no
```
[Answer]
# [Triangular](https://github.com/aaronryank/triangular), 57 bytes
I haven't seen any in this language yet and it seemed appropriate to try and do one. It took a bit ... as I had to get my head around it first and I believe this could be golfed some more.
```
,$\:$:*/%*$"`=P:pp.0"*>/>-`:S!>/U+<U"g+..>p`S:U/U"p`!g<>/
```
[Try it online!](https://tio.run/##KynKTMxLL81JLPr/X0clxkrFSktfVUtFKcE2wKqgQM9ASctO3043wSpY0U4/VNsmVCldW0/PriAh2CpUP1SpIEEx3cZO//9/EwVTBWMA "Triangular – Try It Online")
This expands to the following triangle.
```
          ,
         $ \
        : $ :
       * / % *
      $ " ` = P
     : p p . 0 "
    * > / > - ` :
   S ! > / U + < U
  " g + . . > p ` S
 : U / U " p ` ! g <
> /
```
The path is quite convoluted, but I'll try and explain what I have done. I will skip the directional pointers. Most of the code is stack manipulation.
* `$:*` Square the first input.
* `$:*` Square the second input.
* `S":Ug!` Test if the second value is greater than the first.
	+ ***true*** `p"` Swap with the first.
	+ ***false*** `p` Do Nothing.
* `$:*` Square the third input.
* `P":USg!` Test if the third value is greater than the greatest of the previous.
	+ ***true*** `p+U-` sum the current stack and take away stored third value
	+ ***false*** `p"U+-` sum the least and stored third and subtract from greatest
* `0=%` test equality to zero and output result.
[Answer]
# Haskell (33 32 31 bytes)
```
(\x->(sum x)/2`elem`x).map(^2)
```
Original version:
```
(\x->2*maximum x==sum x).map(^2)
```
Anonymous function. Takes a list in the form [a,b,c]. Outputs True or False.
First version checked if the sum of the squares was twice the square of the maximum.
Second, slightly better version checks if half the sum of squares is an element in the list of squares.
Edit: Accidentally counted a newline, thanks H.PWiz
[Answer]
# [Perl 6](http://perl6.org/), 24 bytes
```
{(*²+*²==*²)(|.sort)}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WkPr0CZtILa1BRKaGjV6xflFJZq1/60VihMrFZRU4q0UqtMUVOJrlRTS8osUbEwVjBVM7HQUbIwVTCEMQyMFY3MFY1MQ28hQwdhCAco0UDA2sFAwNLWz/g8A "Perl 6 – Try It Online")
`*²+*²==*²` is an anonymous function that returns true if the sum of the squares of its first two arguments is equal to the square of its third argument. We pass the sorted input list to this function, flattening it into the argument list with `|`.
[Answer]
# [R](https://www.r-project.org/), 31 ~~26~~ ~~30~~ bytes
```
cat(sum(a<-scan()^2)/max(a)==2)
```
I don't like this one as much, but it is shorter. Sums the squares and divides by the largest square. Truthy if 2.
***Previous Version (modified with cat and with @Guiseppe's tip)***
```
cat(!sort(scan())^2%*%c(1,1,-1))
```
Do a sum of the sorted input with the last item negated and return the `!` not.
[Try it online!](https://tio.run/##K/r/v7g0VyPRRrc4OTFPQzPOSFM/N7FCI1HT1tbov6mCsYLJfwA "R – Try It Online")
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 68 bytes
```
({({({})({}[()])}{}<>)<>})<>({<(({}){}<>[({})])>(){[()](<{}>)}{}<>})
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X6MaBGs1gThaQzNWs7a61sZO08auFog1qm00QHIgoWgQI1bTTkOzGqROw6a61g6iuFbz/38jQwUjSwUjAwA "Brain-Flak – Try It Online")
Uses the observation in user202729's answer.
```
 {                      }      for each input number
   {({})({}[()])}{}            compute the square
  (                <>)<>       push onto second stack
(                        )     push sum of squares onto first stack
                          <>   move to second stack
 {                                    }    for each square
   (({}){}<>[({})])                        compute 2 * this square - sum of squares
  <                >(){[()](<{}>)}{}<>     evaluate loop iteration as 1 iff equal
(                                      )   push 1 if any squares matched, 0 otherwise
```
[Answer]
# [Python 2](https://docs.python.org/2/), 43 bytes
```
lambda a,b,c:(a*a+b*b+c*c)/2in(a*a,b*b,c*c)
```
[Try it online!](https://tio.run/##VcqxDkAwFIXh3VN0pG5CS0Mk3sRyWxESSsTi6esYBMMZ/i9nO49x9ToMbRdmXmzPgsmSa2KWnFppUyddkunJ30AAuiFs@@QPMcSGREGiTKIHUOYHSuNSYeY1rdA1nl/KYTlQQcMF "Python 2 – Try It Online")
# [Python 2](https://docs.python.org/2/), ~~79~~ ~~70~~ ~~68~~ 62 bytes
```
lambda*l:any(A*A+B*B==C*C for A,B,C in zip(l,l[1:]+l,l[2:]+l))
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSvHKjGvUsNRy1HbScvJ1tZZy1khLb9IwVHHScdZITNPoSqzQCNHJyfa0CpWG0QbgWhNzf8FRZl5JQppGqY6CsY6CiaaXDABIM8URcDQCKjEHIhNEWJGhkC@BVAlspABUMwAKGgIFP0PAA "Python 2 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 49 bytes
```
n(a,b,c){return(a*=a)+(b*=b)-(c*=c)&a+c-b&b+c-a;}
```
[Try it online!](https://tio.run/##fYzBCsIwDIbvfYoycTRbJ@u0KMz5JF7adGpBq8zuNPbsNXh2BhL4830JVlfEtPIB76Pr@fEdnX9ubieWgjDSSoRp6OM4UCo6A6WwRWehElh0CLkpsbK5pWnaOfkQ@cP4IIBNjFO9BlpdRLZ255DJILTkW8l3AO1PTEz/waqh8z21XjIaRfRAX5aFmoyaFPV12Jw@ "C (gcc) – Try It Online")
Improves on [Kevin Cruijssens](https://codegolf.stackexchange.com/a/146064) technique
Returns 0 for a valid triangle, and a non-zero value otherwise
[Answer]
# [MATL](https://github.com/lmendo/MATL), 7 bytes
```
SU&0)s=
```
[Try it online!](https://tio.run/##y00syfn/PzhUzUCz2Pb//2hDIx0FY3MgNo0FAA "MATL – Try It Online")
### Explanation
Consider input `[12, 37, 35]`.
```
S     % Implicit input. Sort
      % [12, 35, 37]
U     % Square each entry
      % [144, 1225, 1369]
&0)   % Push last entry and remaining entries
      % STACK: 1369, [144, 1225]
s     % Sum of array
      % STACK: 1369, 1369
=     % Isequal? Implicit display
      % STACK: 1
```
[Answer]
# C, ~~68~~ 54 bytes
Using [user202729's solution](https://codegolf.stackexchange.com/a/146061/61405).
```
f(a,b,c){return!((a*=a)+(b*=b)-(c*=c)&&a-b+c&&a-b-c);}
```
*Thanks to @Christoph for golfing 14 bytes!*
[Try it online!](https://tio.run/##fY7BCoMwDIbvPkUmTBJtwerKBuKb7NJmc3iwjOJO4rN3mdfNhYRAvo@fsH4wpzSgU14xLfE@v2I4ILqyd1ShL3tPGrnsmYrCaV/xtjRTt6YxzDC5MSBlSwZSzyinAfPj7RpyBQMaBZ8m6n5zq6BVcNrlAu0/bhoJOMtY2HUa@aC9SNC3IRw2oxalFsds0pre)
# C, 85 bytes
```
#define C(a,b,c)if(a*a+b*b==c*c)return 1;
f(a,b,c){C(a,b,c)C(b,c,a)C(c,a,b)return 0;}
```
[Try it online!](https://tio.run/##fcxNCoMwEIbhvacYLIUknYKxlRbEldfoJommZGEoYlfi2dMPqav@BDKBvA/jjnfnUtp1vQ@xp1YYtuxk8MIoc7DKNo1TTo799Bwj6TrzbzFvtBWYbPBist1oUS8pxIkGE6KQ2ZwRzmPElxf5vrvFnMmLiunEdJay/t4Rq39dl1hwwa3opyk1@hWLPgU6raIAKWD0ipb0Ag)
[Answer]
# [Julia 0.6](http://julialang.org/), 16 bytes
```
!x=x⋅x∈2x.*x
```
[Try it online!](https://tio.run/##yyrNyUw0@/9fscK24lF3a8Wjjg6jCj2tiv9p@UUKFQqZeQoa0aY6CsY6CiaxOgrRQNoUyjQ0AgqbA7EpiGdkCGRZAGUhHAMgzwDINTSN1eTidCgoyswrSdNQUtU1NClW0LVTUC2OyVPSUajQUVCs0ORKzUv5DwA "Julia 0.6 – Try It Online")
### How it works
Let **x = [a, b, c]**.
`x⋅x` is the dot product of **x** and itself, so it yields **a² + b² + c²**.
`2x.*x` is the element-wise product of **2x** and **x**, so it yields **[2a², 2b², 2c²]**.
Finally, `∈` tests if the integer **a² + b² + c²** belongs to the vector **[2a², 2b², 2c²]**, which is true iff  
**a² + b² + c² = 2a²** or **a² + b² + c² = 2b²** or **a² + b² + c² = 2c²**, which itself is true iff  
**b² + c² = a²** or **a² + c² = b²** or **a² + b² = c²**.
[Answer]
# J, 10 bytes
*-6 bytes thanks to FrownyFrog*
```
=`+/@\:~*:
```
## original answer
```
(+/@}:={:)@/:~*:
```
`/:` sort the squares `*:`, then check if the sum of the first two `+/@}:` equals the last `{:`
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/zW09R1qrWyrrTQd9K3qtKz@a3Ip6Smop9laqSvoKNRaKaQVc3GlJmfkK6QpGCuYKJgqgICfk55CZWoxQsIUKIVFwtBIwdhcwdgUQ8LIUMHYAmwYSCIvHyFuoGBsYKFgaAqX@Q8A "J – Try It Online")
[Answer]
# [Triangularity](https://github.com/Mr-Xcoder/Triangularity), ~~49~~ 31 bytes
```
...)...
..IEO..
.M)2s^.
}Re+=..
```
[Try it online!](https://tio.run/##KynKTMxLL81JLMosqfz/X09PTxOIufT0PF39QbSvplFxnB5XbVCqtq2e3v//0YZGOgrG5kBsGgsA "Triangularity – Try It Online")
### Explanation
Every Triangularity program must have a triangular padding (excuse the pun). That is, the **i**th line counting from the bottom of the program must be padded with **i - 1** dots (`.`) on each side. In order to keep the dot-triangles symmetrical and aesthetically pleasant, each line must consist of **2L - 1** characters, where **L** is the number of lines in the program. Removing the characters that make up for the necessary padding, here is how the code works:
```
)IEOM)2s^}Re+=     Full program. Input: STDIN, Output: STDOUT, either 1 or 0.
)                  Pushes a zero onto the stack.
 IE                Evaluates the input at that index.
   O               Sorts the ToS (Top of the Stack).
    M)2s^}         Runs the block )2s^ on a separate stack, thus squaring each.
          R        Reverse.
           e       Dump the contents separately onto the stack.
            +      Add the top two items.
             =     Check if their sum is equal to the other entry on the stack (c^2).
```
Checking if a triangle is right-angled in Triangularity...
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
m²ø½*Ux²
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=bbL4vSpVeLI&input=WzEyLDM3LDM1XQ)
# [Japt](https://github.com/ETHproductions/japt) [`-x¡`](https://codegolf.meta.stackexchange.com/a/14339/), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
Ë²Ñ¶Ux²
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LXih&code=y7LRtlV4sg&input=WzEyLDM3LDM1XQ)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 39 bytes
```
$a,$b,$c=$args|sort;$a*$a+$b*$b-eq$c*$c
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyVRRyVJRyXZViWxKL24pji/qMRaJVFLJVFbJUlLJUk3tVAlWUsl@f///0aG/40t/psCAA "PowerShell – Try It Online")
Sorts the input, stores that into `$a,$b,$c` variables. Then uses Pythagorean theorem to check whether `a*a + b*b = c*c`. Output is either Boolean `True` or `False`.
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 6 bytes
```
s¦ΣḥuĖ
```
[Try it online!](https://tio.run/##ASEA3v9nYWlh//9zwqbOo@G4pXXElv9l4oaR/1sxMiAzNyAzNV0 "Gaia – Try It Online")
* `s¦` - **s**quare each.
* `Σ` - sum.
* `ḥ` - **ḥ**alve.
* `u` - sq**u**are root.
* `Ė` - contains? Check if the square root is in the input.
[Answer]
# [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), 10 bytes
```
§²2^r]‘\+e
```
## Explained
```
§²2^r]‘\+e
§           # Sort the input list
 ²2^r       # Square each element in the list.
     ]      # Duplicate it on the reg stack.
      ‘     # Pop the top (largest) element off it
       \+   # Swap it, sum the rest of the list.
         e  # Are they equal?
```
[Try it online!](https://tio.run/##Kyooyk/P0zX6r2FopGBsrmBsqvn/0PJDm4ziimIfNcyI0U79/x8A "RProgN 2 – Try It Online")
[Answer]
# [Racket](https://racket-lang.org/), ~~64~~ 60 bytes
```
(λ(a b c)(=(+(* a a)(* b b)(* c c))(*(expt(max a b c)2)2)))
```
[Try it online!](https://tio.run/##bYw7DsIwEET7nGIkmlloiDsKDrM2GxQRLGQZkbtxh1zJbEgbTfE0mk/R9LDaDpPmO8rfdLzZMGbD8M5oXL5URCThlSceoVBxRMQVyQMnbX5VPnXG1g0ukSYdP2WsNmVwfQtnhAtCL3tBj@Cj9gM "Racket – Try It Online")
### How it works
Tests if `a^2 + b^2 + c^2` is equal to twice the largest of `a^2`, `b^2`, and `c^2`.
Returns `#t` for right triangles and `#f` for all other inputs.
---
* *-4 bytes thanks to @xnor's suggestion to use `expt`.*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
n{R`+Q
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/rzooQTvw//9oQx0gjAUA "05AB1E – Try It Online")
[Answer]
# Ruby, 31 bytes
```
->a{a,b,c=*a.sort;a*a+b*b==c*c}
```
Takes input as a list of 3 integers. Uses some ideas from other solutions.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 68 bytes
```
a->{java.util.Arrays.sort(a);return a[0]*a[0]+a[1]*a[1]==a[2]*a[2];}
```
[Try it online!](https://tio.run/##lY7BasMwDIbveQodnS01cbqyQUihD7Beegw5qKk7nLlysJ2OEvLsmVK2eyuQEJK@X3@HV1y5XlN3@p5biyHAJxoaDUXtz9hq2I9H56xGglbwtG4A03IKEaNpYQ8EFcy42o4dK8khGit33uMtyOB8FHzrdRw8AdZ587KUV6zV0qmmqrAulrZoymkuk344Whb90746c4ILmxGH6A193T@PCXAcbiHqi3RDlD2voiVBshWkf@BucVxn8JbBZkrT8mFgw8zjgCoyWL9zPvGkUHz/8ZSvQuXM5Aypf2pKpvkX "Java (OpenJDK 8) – Try It Online")
[Answer]
# TI-Basic, ~~13~~ ~~11~~ 10 bytes
```
max(Ans=R►Pr(min(Ans),median(Ans
```
Now works for inputs in any order and is shorter as well. Another -1 thanks to @MishaLavrov
[Answer]
# CJam, 9
```
q~$W%~mh=
```
[Try it online](http://cjam.aditsu.net/#code=q%7E%24W%25%7Emh%3D&input=%5B3%205%204%5D)
**Explanation:**
```
q~      read and evaluate the input (given as an array)
$W%     sort and reverse the array
~       dump the array on the stack
mh      get the hypotenuse of a right triangle with the given 2 short sides
=       compare with the longer side
```
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), ~~29~~ 24 bytes
```
f(v)=v~==2*vecmax(v)^2
```
[Try it online!](https://tio.run/##K0gsytRNL/j/P02jTNO2TKusztbWSKssNTk3sQIoEmf0v6AoM69EI00j2ljHRMc0VlOTCy5iqgMUwxAxBor8BwA "Pari/GP – Try It Online")
Saved five bytes by an obvious change from `norml2(v)` to `v*v~`.
Inspired by other answers.
Here `v` must be a row vector ~~or a column vector~~ with three coordinates.
Example of use: `f([3,4,5])`
Of course, you get rational side lengths for free, for example `f([29/6, 10/3, 7/2])`.
If I do not count the `f(v)=` part, that is 19 bytes. The first part can also be written `v->` (total 22 bytes).
**Explanation:** If the three coordinates of `v` are `x`, `y` and `z`, then the product of `v` and its transpose `v~` gives a scalar `x^2+y^2+^z^2`, and we need to check if that is equal to twice the square of the maximum of the coordinates `x`, `y`, `z`.
**Extra:** The same `f` tests for a [Pythagorean quadruple](https://en.wikipedia.org/wiki/Pythagorean_quadruple) if your input vector has four coordinates, and so on.
[Answer]
# [Ohm v2](https://github.com/MiningPotatoes/Ohm), ~~8~~ 6 bytes
```
²DS)Σε
```
[Try it online!](https://tio.run/##y8/INfr//9Aml2DNc4vPbf3/P9rQSEfB2ByITWMB "Ohm v2 – Try It Online")
[Answer]
# Common Lisp, 64 bytes
```
(apply(lambda(x y z)(=(+(* x x)(* y y))(* z z)))(sort(read)#'<))
```
[Try it online!](https://tio.run/##Fck7DoAgEEXRrUxi4Rst1U4XM34KEtQJUDBsHrE6N7mHd1ErNLgnVYiqN3i591OQyagwNowYKFPmhpHxb2mnRXxDQrjk5K5fmStXLDTTxB8)
As usual in Common Lisp, true is `T` and false is `NIL`.
]