Special pythagorean triplet: Difference between revisions

<br><br>

=={{header|11l}}==

L(a) 1 .. PERIMETER

L(b) a + 1 .. PERIMETER

V c = PERIMETER - a - b

I a * a + b * b == c * c

{{out}}

Uses Euclid's formula, as in the XPL0 sample but also uses the fact that M and N must be factors of half the triangle's perimeter to reduce the number of candidate M's to check. A loop is not needed to find N once a candidate M has been found.

<br>Does not stop after the solution has been found, thus verifying there is only one solution.

# a + b + c = 1000, a2 + b2 = c2, a < b < c #

INT perimeter = 1000;

OD;

print( ( whole( count, 0 ), " iterations", newline ) )

{{out}}

<pre>

{{trans|Wren}}

...but doesn't stop on the first solution (thus verifying there is only one).

for a := 1 until 1000 div 3 do begin

integer a2, b;

end for_b ;

endB:

{{out}}

<pre>

</pre>

=={{header|AWK}}==

# syntax: GAWK -f SPECIAL_PYTHAGOREAN_TRIPLET.AWK

# converted from FreeBASIC

}

}

{{out}}

<pre>

=={{header|C++}}==

#include <concepts>

#include <iostream>

cout << "Perimeter not found\n";

}

{{out}}

<pre>

A conventional solution:

(defun special-triple (sum)

(loop

when (= (* c c) (+ (* a a) (* b b)))

do (return-from conventional-triple-search (list a b c)))))

This version utilizes SCREAMER which provides constraint solving:

(ql:quickload "screamer")

(in-package :screamer-user)

(print (one-value (special-pythagorean-triple 1000)))

;; => (200 375 425 31875000)

=={{header|F_Sharp|F#}}==

Here I present a solution based on the ideas on the discussion page. It finds all Pythagorean triplets whose elements sum to a given value. It runs in O[n] time. Normally I would exclude triplets with a common factor but for this demonstration I prefer to leave them.

// Special pythagorean triplet. Nigel Galloway: August 31st., 2021

let fG n g=let i=(n-g)/2L in match (n+g)%2L with 0L->if (g*g)%(4L*i)=0L then Some(g,i-(g*g)/(4L*i),i+(g*g)/(4L*i)) else None

let E9 n=let fN=fG n in seq{1L..(n-2L)/3L}|>Seq.choose fN|>Seq.iter(fun(n,g,l)->printfn $"%d{n*n}(%d{n})+%d{g*g}(%d{g})=%d{l*l}(%d{l})")

[1L..260L]|>List.iter(fun n->printfn "Sum = %d" n; E9 n)

{{out}}

<pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Brute force

=={{header|Go}}==

{{trans|Wren}}

import (

}

}

{{out}}

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

| range($a+1;1000) as $b

| (1000 - $a - $b) as $c

| select($a*$a + $b*$b == $c*$c)

{{out}}

<pre>

Or, with a tiny bit of thought:

| range($a+1;1000/2) as $b

| (1000 - $a - $b) as $c

| select($a*$a + $b*$b == $c*$c)

=={{header|Julia}}==

</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

FindInstance[

a + b + c == 1000 && a > 0 && b > 0 && c > 0 &&

a^2 + b^2 == c^2, {a, b, c}, Integers];

{{out}}<pre>

My solution from Project Euler:

from math import floor, sqrt

echo fmt"a: {(s - int(r)) div 2}"

echo fmt"b: {(s + int(r)) div 2}"

{{out}}

=={{header|Perl}}==

use warnings;

print "$a² + $b² = $c²\n$a + $b + $c = 1000\n" and last if $a2 + $b**2 == $c**2

}

{{out}}

<pre>200² + 375² = 425²

=== brute force (83000 iterations) ===

Not that this is in any way slow (0.1s, or 0s with the displays removed), and not that it deliberately avoids using sensible loop limits, you understand.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1000</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d iterations\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">count</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=== smarter (166 iterations) ===

It would of course be 100 iterations if we quit once found (whereas the above would be 69775).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1000</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d iterations\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">count</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

Based on the XPL0 solution.

<br>As the original 8080 PL/M compiler only has unsigned 8 and 16 bit integer arithmetic, the PL/M [https://www.rosettacode.org/wiki/Long_multiplication long multiplication routines] and also a square root routine based that in the PL/M sample for the [https://www.rosettacode.org/wiki/Frobenius_numbers Frobenius Numbers task] are used - which makes this somewhat longer than it would otherwose be...

/* CP/M BDOS SYSTEM CALL */

END;

{{out}}

<pre>

=={{header|Raku}}==

my $a2 = $a²;

for $a + 1 .. 999 -> $b {

and exit if $a2 + $b² == $c²

}

{{out}}

<pre>200² + 375² = 425²

Also, there were multiple shortcuts to limit an otherwise exhaustive search; &nbsp; Once a sum or a square was too big,

<br>the next integer was used &nbsp; (for the previous DO loop).

parse arg sum hi n . /*obtain optional argument from the CL.*/

if sum=='' | sum=="," then sum= 1000 /*Not specified? Then use the default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

s: if arg(1)==1 then return arg(3); return word(arg(2) 's', 1) /*simple pluralizer*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

Various algorithms presented, some are quite fast. Timings are from Tio.run. On the desktop of a core i7-7700 @ 3.60Ghz, it goes about 6.5 times faster.

? "working..."

? "Elapsed time = " + et / tf + " ms" + nl

{{out}}

<pre>working...

=={{header|Wren}}==

Very simple approach, only takes 0.013 seconds even in Wren.

while (true) {

var b = a + 1

}

a = a + 1

{{out}}

<br>

Incidentally, even though we are '''told''' there is only one solution, it is almost as quick to verify this by observing that, since a < b < c, the maximum value of a must be such that 3a + 2 = 1000 or max(a) = 332. The following version ran in 0.015 seconds and, of course, produced the same output:

var b = a + 1

while (true) {

b = b + 1

}

=={{header|XPL0}}==

for N:= 1 to sqrt(1000) do

for M:= N+1 to sqrt(1000) do

if A+B+C = 1000 then

IntOut(0, A*B*C);

{{out}}