tasks a-s

Task/Pythagorean-triples/Java/pythagorean-triples-1.java

@@ -0,0 +1,51 @@
+import java.math.BigInteger;
+import static java.math.BigInteger.ONE;
+
+public class PythTrip{
+
+    public static void main(String[] args){
+        long tripCount = 0, primCount = 0;
+
+        //change this to whatever perimeter limit you want;the RAM's the limit
+        BigInteger periLimit = BigInteger.valueOf(100),
+                peri2 = periLimit.divide(BigInteger.valueOf(2)),
+                peri3 = periLimit.divide(BigInteger.valueOf(3));
+
+        for(BigInteger a = ONE; a.compareTo(peri3) < 0; a = a.add(ONE)){
+            BigInteger aa = a.multiply(a);
+
+            for(BigInteger b = a.add(ONE);
+                    b.compareTo(peri2) < 0; b = b.add(ONE)){
+                BigInteger bb = b.multiply(b);
+                BigInteger ab = a.add(b);
+                BigInteger aabb = aa.add(bb);
+
+                for(BigInteger c = b.add(ONE);
+                        c.compareTo(peri2) < 0; c = c.add(ONE)){
+
+                    int compare = aabb.compareTo(c.multiply(c));
+                    //if a+b+c > periLimit
+                    if(ab.add(c).compareTo(periLimit) > 0){
+                        break;
+                    }
+                    //if a^2 + b^2 != c^2
+                    if(compare < 0){
+                        break;
+                    }else if (compare == 0){
+                        tripCount++;
+                        System.out.print(a + ", " + b + ", " + c);
+
+                        //does binary GCD under the hood
+                        if(a.gcd(b).equals(ONE)){
+                            System.out.print(" primitive");
+                            primCount++;
+                        }
+                        System.out.println();
+                    }
+                }
+            }
+        }
+        System.out.println("Up to a perimeter of " + periLimit + ", there are "
+                + tripCount + " triples, of which " + primCount + " are primitive.");
+    }
+}

Task/Pythagorean-triples/Java/pythagorean-triples-2.java

@@ -0,0 +1,38 @@
+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),
+                 a2.negate().add(b).add(c2),
+                 a2.negate().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.");
+        }
+    }
+}