public class problem2 {
        public static void main(String[] args) {
                int total = 2;
                int[] num = new int[1000000];
               
                for(int i = 1; i < 1000000; i++){
                        if(i == 1){
                                num[1] = 1;
                        }
                        if(i == 2) {
                                num[2] = 2;
                        }
                        else if(i > 2){
                                num[i] = num[i - 2] + num[i - 1];
                                if (num[i] % 2 == 0){
                                        total = total + num[i];
                                }
                        }
                }
                System.out.println(total);
        }
}

public class Problem20 {
        public static void main (String[] args){
                int n = 100;
                int total = 100;
                int sum = 0;
               
                for (int i = 1; i <= 99; i++){
                        total = total * (n-i);
                        }
                for (int j = 1; j <= total; j++){
                        sum = sum + j;
                }
                System.out.println(sum);               
        }
}

(define (fact n)
  (letrec ((fact-helper (lambda (n acc)
                          (if (<= n 1)
                              acc
                              (fact-helper (- n 1) (* n acc))))))
    (fact-helper n 1)))

(define (sum-digits n)
  (letrec ((sum-helper (lambda (n acc)
                         (if (= n 0)
                             acc
                             (sum-helper (floor (/ n 10))
                                         (+ acc (remainder n 10)))))))
    (sum-helper n 0)))

(define (sum-digits n)
  (letrec ((sum-helper (lambda (n acc)
                         (if (= n 0)
                             acc
                             (sum-helper (floor (/ n 10))
                                         (+ acc (remainder n 10)))))))
    (sum-helper n 0)))

(display (sum-digits (expt 2 1000)))

(defun sum-digits (n &optional (acc 0))
  (if (= n 0)
      acc
      (sum-digits (floor (/ n 10)) (+ acc (mod n 10)))))

(format t "~D~%" (sum-digits (expt 2 1000)))

def digits_sum(number)
  number.to_s.scan(/./).inject(0) { |sum, e| sum + e.to_i }
end

puts digits_sum(3 ** 10000) #=> 21663

class Example {
        public static void main (String[] args) {
                int sum = 0;
                String num = "37107287533902102798797998220837590246510135740250" +
"46376937677490009712648124896970078050417018260538" +
"74324986199524741059474233309513058123726617309629" +
"91942213363574161572522430563301811072406154908250" +
"23067588207539346171171980310421047513778063246676" +
"89261670696623633820136378418383684178734361726757" +
"28112879812849979408065481931592621691275889832738" +
"44274228917432520321923589422876796487670272189318" +
"47451445736001306439091167216856844588711603153276" +
"70386486105843025439939619828917593665686757934951" +
"62176457141856560629502157223196586755079324193331" +
"64906352462741904929101432445813822663347944758178" +
"92575867718337217661963751590579239728245598838407" +
"58203565325359399008402633568948830189458628227828" +
"80181199384826282014278194139940567587151170094390" +
"35398664372827112653829987240784473053190104293586" +
"86515506006295864861532075273371959191420517255829" +
"71693888707715466499115593487603532921714970056938"+
"54370070576826684624621495650076471787294438377604"+
"53282654108756828443191190634694037855217779295145"+
"36123272525000296071075082563815656710885258350721"+
"45876576172410976447339110607218265236877223636045"+
"17423706905851860660448207621209813287860733969412"+
"81142660418086830619328460811191061556940512689692"+
"51934325451728388641918047049293215058642563049483"+
"62467221648435076201727918039944693004732956340691"+
"15732444386908125794514089057706229429197107928209"+
"55037687525678773091862540744969844508330393682126"+
"18336384825330154686196124348767681297534375946515"+
"80386287592878490201521685554828717201219257766954"+
"78182833757993103614740356856449095527097864797581"+
"16726320100436897842553539920931837441497806860984"+
"48403098129077791799088218795327364475675590848030"+
"87086987551392711854517078544161852424320693150332"+
"59959406895756536782107074926966537676326235447210"+
"69793950679652694742597709739166693763042633987085"+
"41052684708299085211399427365734116182760315001271"+
"65378607361501080857009149939512557028198746004375"+
"35829035317434717326932123578154982629742552737307"+
"94953759765105305946966067683156574377167401875275"+
"88902802571733229619176668713819931811048770190271"+
"25267680276078003013678680992525463401061632866526"+
"36270218540497705585629946580636237993140746255962"+
"24074486908231174977792365466257246923322810917141"+
"91430288197103288597806669760892938638285025333403"+
"34413065578016127815921815005561868836468420090470"+
"23053081172816430487623791969842487255036638784583"+
"11487696932154902810424020138335124462181441773470"+
"63783299490636259666498587618221225225512486764533"+
"67720186971698544312419572409913959008952310058822"+
"95548255300263520781532296796249481641953868218774"+
"76085327132285723110424803456124867697064507995236"+
"37774242535411291684276865538926205024910326572967"+
"23701913275725675285653248258265463092207058596522"+
"29798860272258331913126375147341994889534765745501"+
"18495701454879288984856827726077713721403798879715"+
"38298203783031473527721580348144513491373226651381"+
"34829543829199918180278916522431027392251122869539"+
"40957953066405232632538044100059654939159879593635"+
"29746152185502371307642255121183693803580388584903"+
"41698116222072977186158236678424689157993532961922"+
"62467957194401269043877107275048102390895523597457"+
"23189706772547915061505504953922979530901129967519"+
"86188088225875314529584099251203829009407770775672"+
"11306739708304724483816533873502340845647058077308"+
"82959174767140363198008187129011875491310547126581"+
"97623331044818386269515456334926366572897563400500"+
"42846280183517070527831839425882145521227251250327"+
"55121603546981200581762165212827652751691296897789"+
"32238195734329339946437501907836945765883352399886"+
"75506164965184775180738168837861091527357929701337"+
"62177842752192623401942399639168044983993173312731"+
"32924185707147349566916674687634660915035914677504"+
"99518671430235219628894890102423325116913619626622"+
"73267460800591547471830798392868535206946944540724"+
"76841822524674417161514036427982273348055556214818"+
"97142617910342598647204516893989422179826088076852"+
"87783646182799346313767754307809363333018982642090"+
"10848802521674670883215120185883543223812876952786"+
"71329612474782464538636993009049310363619763878039"+
"62184073572399794223406235393808339651327408011116"+
"66627891981488087797941876876144230030984490851411"+
"60661826293682836764744779239180335110989069790714"+
"85786944089552990653640447425576083659976645795096"+
"66024396409905389607120198219976047599490197230297"+
"64913982680032973156037120041377903785566085089252"+
"16730939319872750275468906903707539413042652315011"+
"94809377245048795150954100921645863754710598436791"+
"78639167021187492431995700641917969777599028300699"+
"15368713711936614952811305876380278410754449733078"+
"40789923115535562561142322423255033685442488917353"+
"44889911501440648020369068063960672322193204149535"+
"41503128880339536053299340368006977710650566631954"+
"81234880673210146739058568557934581403627822703280"+
"82616570773948327592232845941706525094512325230608"+
"22918802058777319719839450180888072429661980811197"+
"77158542502016545090413245809786882778948721859617"+
"72107838435069186155435662884062257473692284509516"+
"20849603980134001723930671666823555245252804609722"+
"53503534226472524250874054075591789781264330331690";
               
               
                for (int i = 0; i < 5000;i++) {
                        sum = sum + num.charAt(i);
                }
                System.out.println(sum);
        }
}

public class Problem12 {
        public static void main (String[] args) {
                int num = 0;
                int cnt;
               
                for (int i = 1; i < 1000000000; i++) {
                        cnt = 0;
                        num = num + i;
                        for (int j = 1; j <= num; j++) {
                                if (num % j == 0) {
                                        cnt = cnt + 1;
                                }
                        }
                        if (cnt >= 500) {
                                System.out.println (num);
                        }
                }
        }
}

48 = 2 * 2 * 2 * 2 * 3

48 = 2^4 * 3^1

5*2=10

x = p_0^k_0 * p_1^k_1 * p_2^k_2 * ... * p_n^k_n

(k_0 + 1) * (k_1 + 1) * (k_2 + 1) * ... * (k_n +1)

primes = [2]

public class Problem14 {
        public static void main (String[] args) {
                int n;
                int cnt = 1;
                int oldcnt = 0;
                int term = 0;
               
                for (int i = 1; i <= 999999; i++) {
                        n = i;
                        do {
                                if (n % 2 == 0) {
                                        n = n / 2;
                                }
                                else {
                                        n = 3 * n + 1;
                                }
                                cnt = cnt + 1;
                        }
                        while (n != 1); 
                       
                        if (oldcnt <= cnt) {
                                oldcnt = cnt;
                                term = i;
                        }
                        cnt = 1;       
                }
                System.out.println(term);
        }
}

primes = (2:200000)';
primes = primes(isprime(primes));
primes(10001)

public class Problem125 {
        public static void main (String[] args) {
                String ii = "";  //stores the string of the number
                String reversed;        //stores the reversed number
                int consecutive;        //stores the sum of the consecutive square numbers
                int sum = 0;        //stores the sum of all the palindroms - where the sum of consecutive square numbers adds up to the palindrom
                int cnt = 0;        //stores the number of consecutive integers to make sure its greater than one
               
                for (int i = 2; i < 100000000; i++) {
                        boolean correct = false;       
                        ii = Integer.toString(i);       //converts the number to a string to reverse it using substring
                        reversed = "";
                       
                        //reverses the number to see if its a palindrom
            for (int j=0; j <ii.length(); j++) {
               reversed = ii.substring(j, j+1) + reversed;
            }
           
            //converts the string reversed number to integer so we can compare if its a palindrom
            int ireversed = Integer.parseInt(reversed);
           
            if (ireversed == i) {       //checks if its a palindrom
                //checks if the sum of consecutive squares is equal to the original number
                for (int a = 1; a < i ; a++) {     
                    consecutive = 0;
                    cnt = 0;
                    if (correct == false) {
                                for (int k = a; k < i ; k++) {
                                    consecutive = consecutive + (k*k);
                                    cnt = cnt + 1;
                                    if (consecutive == i && cnt > 1) {
                                        sum = sum + i;
                                        correct = true;
                                    }
                                }
                        }
                }
            }
                }
                System.out.println(sum);
        }
}

            if (ireversed == i) {       //checks if its a palindrom
                for (int n2 = 1; n2 < 1000; n2++) {
                    for (int n = 1; n < 1000; n++) {
                                        s1 = (n * (n + 1) * (2 * n + 1)) / 6;
                                        s2 = (n2 * (n2 + 1) * (2 * n2 + 1)) / 6;
                                        if (s2 - s1 == i) {
                                           sum = sum + i;
                                        }
                                    }
                                }
            }

2x^3 + 3x^2 + x - diff*6 = 0

var num : int := 1
var count : int := 1
var answer : int
loop
    count := 1
    num += 1
    put num
    loop
        if num mod count = 0 then
            count += 1
        else
            exit
        end if
        exit when count = 20
    end loop
    exit when count = 20
end loop

answer := num

put "The answer is: ", answer

class Problem_5
{
        public static void main(String[] args)
        {
                long num = 0;
                long answer;
                boolean divisible = false;
               
                while(!divisible)
                {
                        num += 1260;
                        divisible = true;
                        System.out.println(num);
                        for (int count = 11; count <= 20; count++)
                        {
                                if (num % count != 0)
                                {
                                        divisible = false;
                                }
                        }
                }
                answer = num;
                System.out.println("The answer is: " + answer);
        }
}

import java.math.*;

public class Problem125 {
        public static void main (String[] args) {
                String ii = "";  //stores the string of the number
                String reversed;        //stores the reversed number
                int consecutive;        //stores the sum of the consecutive square numbers
                int sum = 0;        //stores the sum of all the palindroms - where the sum of consecutive square numbers adds up to the palindrom
                int cnt = 0;        //stores the number of consecutive integers to make sure its greater than one
                int s1 = 0;
                int s2 = 0;
               
                for (int i = 2; i < 100000000; i++) {   
                        boolean correct = false;
                        ii = Integer.toString(i);       //converts the number to a string to reverse it using substring
                        reversed = "";
                       
                        //reverses the number to see if its a palindrom
            for (int j=0; j <ii.length(); j++) {
               reversed = ii.substring(j, j+1) + reversed;
            }
           
            //converts the string reversed number to integer so we can compare if its a palindrom
            int ireversed = Integer.parseInt(reversed);
           
            if (ireversed == i) {       //checks if its a palindrom
                                for (int n2 = 1; n2 < Math.sqrt(i); n2++) {
                                        if (correct == true) {
                                break;
                         }
                                        s2 = (n2 * (n2 + 1) * (2 * n2 + 1)) / 6;
                        for (int n = 1; n < (n2 - 1); n++) {
                            s1 = (n * (n + 1) * (2 * n + 1)) / 6;
                            if (s2 - s1 == i) {
                                sum = sum + i;
                                correct = true;
                         break;
                            }
                        }
                }
            }
        }
       sum = sum + 60;  //this is because for some reason it doesn't include #5 and #55
       System.out.println(sum);
        }
}

let
   fun evenlyDivisibleBy(n, divisor) = n mod divisor = 0
   fun evenlyDivisibleByAllInRange(n, s, e) =
      if s >= e then true
      else if n mod s <> 0 then false
      else evenlyDivisibleByAllInRange(n, s + 1, e)
   fun evenlyDivisibleByAllUpto20() =
      let
         fun aux n =
            if evenlyDivisibleByAllInRange(n, 11, 20) then n
            else aux (n + 1260)
      in
         aux 1260
      end
in
   evenlyDivisibleByAllUpto20()
end

%based on someone's algorithm, I think MysticVegeta's
var n := 1000000
var prime : array 1 .. n of boolean

for i : 1 .. n
    prime (i) := true
end for

for i : 2 .. ceil (sqrt (n))
    for j : i * 2 .. n by i
        prime (j) := false
    end for
end for

var sum, RealSum, realsum := 0
for i : 1 .. 1000000
    if prime (i) then
        sum += i
        if sum > 1000000000 then    %because 10 digits is the maximum that Turing can handle!
            realsum += sum - 1000000000 %only goes to 8 decimal places, so we can add all of these up
            RealSum += 1            %since we're subtracting 10 ** 9 each time, add 1 to the 10 ** 9 total
            sum := 0                %restart the sum
        end if
    end if
end for
put RealSum, " times 10 to the nine, ", realsum - 1 %because 1 is not a prime, but was included

boolean pally = true;    // flag set to false if not a pallindrome
String temp = "";         // Holds number in string form
int i = 1331;                // the number your testing (would be for loop)

temp = ""+i; // pass the current number into string
for (int c = 0; c <= temp.length()/2; c ++){
    // This for loop goes through the first half of the string

    // If the value at position 0 != value at end-0, if value at 1 != end-1, etc
    if (temp.substring(c,c+1).equals(temp.substring(temp.length()-c-1,temp.length()-c) false){
        pally = false;
    }

    if (pally == true){
        // Do something. you have a pallindrome
    }
    pally = true;
}

for (int n = 1; n < 10000; n ++){
    flip = "";
    temp = ""+n;

    // Flip the digits eg, 450  -> 054
    for (int d = 0; d < temp.length(); d ++){
        flip = flip + temp.substring(temp.length()-1-d,temp.length()-0-d);
    }
    num1 = Long.parseLong(temp+flip);
   
    // and for odd pallys ( check both on same for loop itteration )
    num2 = Long.parseLong(temp+flip.substring(1); // Chop off 1 digit from flip (eg: 450 + _54 -> 45054 instead of 450054)
}

(n2(n2+1)(2*n2+1) - n1(n1+1)(2*n1+1)) / 6

String digits = (new BigInteger("2").pow(1000)).toString();

digits = str(2 ** 1000)

real num = 5.5
int num2 = round_down (num)
put remainder (num/num2)

largestPrime = 0
num = 317584931803
while num > 2:
        num -= 2
        i = 2
        if 317584931803 % num == 0:
                while i < num:
                        if num % i == 0:
                                break
                       
                        if i == num - 1:
                                largestPrime = num
                               
                        i += 1
        print num
        if largestPrime != 0:
                break      
                       
print "The largest prime is: ", largestPrime

      while i < num:
         if num % i == 0:
            break
         
         if i == num - 1:
            largestPrime = num
           
         i += 1

      while i < num and num % i != 0:
         if i == num - 1:
            largestPrime = num
           
         i += 1

import java.math.*;

public class Problem125 {
        public static void main (String[] args) {
                String ii = "";  //stores the string of the number
                String reversed;        //stores the reversed number
                int consecutive;        //stores the sum of the consecutive square numbers
                int sum = 0;        //stores the sum of all the palindroms - where the sum of consecutive square numbers adds up to the palindrom
                int cnt = 0;        //stores the number of consecutive integers to make sure its greater than one
                int s1 = 0;
                double s2;
                double a = 2;
                double b = 3;
                double c = 1;
                double f, g, h = 0;
                double r, s, t, iii, j, k, l, m, n, p, u = 0;
                double x1, x2, x3 = 0;
                double xx1, xx2, xx3 = 0;
               
                for (int i = 2; i < 100000000; i++) {   
                        boolean correct = false;
                        ii = Integer.toString(i);       //converts the number to a string to reverse it using substring
                        reversed = "";
                       
                        //reverses the number to see if its a palindrom
            for (int jj=0; jj <ii.length(); jj++) {
               reversed = ii.substring(jj, jj+1) + reversed;
            }
           
            //converts the string reversed number to integer so we can compare if its a palindrom
            int ireversed = Integer.parseInt(reversed);
           
            if (ireversed == i) {       //checks if its a palindrom
                                for (int n2 = 1; n2 < i; n2++) {
                    s1 = (n2*(n2+1)*(2*n2+1))  / 6;
                    s2 = i - s1;
                    double d = -1 * s2;
                   
                    //solving the cubic
                    f = ((3 * c / a) - (Math.pow(b, 2) / Math.pow(a, 2))) / 3;
                    g = ((2 * Math.pow(b, 3) / Math.pow(a, 3)) - (9 * b * c / Math.pow(a, 2) + (27 * d / a))) / 27;
                    h = ((Math.pow(g, 2) / 4) + (Math.pow(f, 3) / 27));
                   
                    iii = Math.pow(((Math.pow(g, 2) / 4) - h), (1/2));
                    //checking how many roots h has:
                    //1 root real
                    if (h > 0) {
                        r = -1 * (g / 2) + Math.pow(h, (1/2));
                        s = Math.pow (r, (1/3));
                        t = -1 * (g / 2) - Math.pow(h, (1/2));
                        u = Math.pow(t, (1/3));
                       
                        x1 = (s + u) - (b/3 * a);
                        x2 = -1 * (s + u) / 2 - (b / 3 * a) + iii * (s - u) * Math.pow(3, (1/2)) / 2;
                        x3 = -1 * (s + u) / 2 - (b / 3 * a) - iii * (s - u) * Math.pow(3, (1/2)) / 2;
                       
                        xx1 = Math.floor (x1);
                        xx2 = Math.floor (x2);
                        xx3 = Math.floor (x3);
                       
                        //if all roots (n's) are whole numbers than its consecutive and add them
                        if (x1 / xx1 == 1 && x2 / xx2 == 1 && x3 / xx3 == 1) {
                                System.out.println(i);
                                sum = sum + i;
                            }
                    }
                   
                    //all 3 roots real
                    if (h <= 0) {
                        j = Math.pow(iii, (1/3));
                        k = Math.acos(-1 * (g/2*iii));
                        l = j * -1;
                        m = Math.cos(k/3);  
                        n = Math.sqrt(3) * Math.sin(k/3);
                        p = (b / 3 * a) * - 1;
                        x1 = 2 * j * Math.cos(k/3) - (b/3 * a);
                        x2 =  l * (m + n) + p;
                        x3 =  l * (m - n) + p;
                        xx1 = Math.floor (x1);
                        xx2 = Math.floor (x2);
                        xx3 = Math.floor (x3);
                       
                        //if all roots (n's) are whole numbers than its consecutive and add them
                        if (x1 / xx1 == 1 && x2 / xx2 == 1 && x3 / xx3 == 1) {
                                System.out.println(i);
                                sum = sum + i;
                            }
                    }
                   
                    //all 3 roots real and equal
                    if (f == 0 && g == 0 && h == 0) {
                        x1 = Math.pow (d/a, (1/3)) * -1;
                        x2 = x1;
                        x3 = x1;
                        xx1 = Math.floor (x1);
                        xx2 = Math.floor (x2);
                        xx3 = Math.floor (x3);
                        //if all roots (n's) are whole numbers than its consecutive and add them
                        if (x1 / xx1 == 1 && x2 / xx2 == 1 && x3 / xx3 == 1) {
                            System.out.println(i);
                                sum = sum + i;
                        }
                    }
                   
                }
                }
        }

       sum = sum + 60;  //this is because for some reason it doesn't include #5 and #55
       System.out.println(sum);
        }
}

abundantInts = []
sum1 = 0
sum2 = 0
isSum = False

for i in range(10, 28123, 2):
        sum1 = 0
        for k in range(1, i / 2):
                if i % k == 0:
                        sum1 += k
        if sum1 > i:
                abundantInts.append(i)
                print i
               
for i in range(1, 28123):
        isSum = False
        for num in abundantInts:
                if abundantInts.__contains__(i - num):
                        isSum = True
                        break
                if num > i:
                        break
        if not isSum:
                sum2 += i
        print i
       
print 'Answer is: ', sum2

        for k in range(1, i / 2):
                if i % k == 0:
                        sum1 += k

sum(k for k in range(1, i / 2) if i % k == 0)

abundantInts = []
sum1 = 0
sum2 = 0
isSum = False

for i in range(10, 28123, 2):
        sum1 = sum(k for k in range(1, i / 2) if i % k == 0)
        if sum1 > i:
                abundantInts.append(i)
                print i
               
for i in range(1, 28123):
        isSum = False
        for num in abundantInts:
                if abundantInts.__contains__(i - num):
                        isSum = True
                        break
                if num > i:
                        break
        if not isSum:
                sum2 += i
        print i
       
print 'Answer is: ', sum2

abundantInts = []
sum1 = 0
sum2 = 0
isSum = False

abundantInts = list(i for i in range(10, 28123, 2)
                      if sum(k for k in range(1, i / 2) if i % k == 0) > i)

for i in abundantInts: print i
               
for i in range(1, 28123):
        isSum = False
        for num in abundantInts:
                if abundantInts.__contains__(i - num):
                        isSum = True
                        break
                if num > i:
                        break
        if not isSum:
                sum2 += i
        print i
       
print 'Answer is: ', sum2