Pythagorean triples: Difference between revisions

===Brute force===

===Parent/child===

{{trans|Perl 6}} (with limited modification for saving a few BigInteger operations)

{{works with|Java|1.5+}}

This can also go "forever" theoretically. Letting it go to another order of magnitude overflowed the stack on the computer this was tested on. This version also does not show the triples as it goes, it only counts them.

<lang java5>import java.math.BigInteger;

public class Triples{

public static BigInteger LIMIT;

public static final BigInteger TWO = BigInteger.valueOf(2);

public static final BigInteger THREE = BigInteger.valueOf(3);

public static final BigInteger FOUR = BigInteger.valueOf(4);

public static final BigInteger FIVE = BigInteger.valueOf(5);

public static long primCount = 0;

public static long tripCount = 0;

//I don't know Japanese :p

public static void parChild(BigInteger a, BigInteger b, BigInteger c){

BigInteger perim = a.add(b).add(c);

if(perim.compareTo(LIMIT) > 0) return;

primCount++; tripCount += LIMIT.divide(perim).longValue();

BigInteger a2 = TWO.multiply(a), b2 = TWO.multiply(b), c2 = TWO.multiply(c),

c3 = THREE.multiply(c);

parChild(a.subtract(b2).add(c2),

a2.subtract(b).add(c2),

a2.subtract(b2).add(c3));

parChild(a.add(b2).add(c2),

a2.add(b).add(c2),

a2.add(b2).add(c3));

parChild(a.negate().add(b2).add(c2),

TWO.negate().multiply(a).add(b).add(c2),

TWO.negate().multiply(a).add(b2).add(c3));

}

public static void main(String[] args){

for(long i = 100; i <= 10000000; i*=10){

LIMIT = BigInteger.valueOf(i);

primCount = tripCount = 0;

parChild(THREE, FOUR, FIVE);

System.out.println(LIMIT + ": " + tripCount + " triples, " + primCount + " primitive.");

}

}

}</lang>

Output:

<pre>100: 17 triples, 7 primitive.

1000: 325 triples, 70 primitive.

10000: 4858 triples, 703 primitive.

100000: 64741 triples, 7026 primitive.

1000000: 808950 triples, 70229 primitive.

10000000: 9706567 triples, 702309 primitive.</pre>