Initial commit

C/p001.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int i, sum = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 1; i < 1000; i++)
+   {
+      if (i % 3 == 0 || i % 5 == 0)
+      {
+         sum += i;
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 1\n");   
+   printf("Answer: %d\n", sum);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p002.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int fib0 = 1, fib1 = 2, fib2, sum = 2;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   fib2 = fib0 + fib1;
+
+   while(fib2 <= 4000000)
+   {
+      if(fib2 % 2 == 0)
+      {
+         sum += fib2;
+      }
+
+      fib0 = fib1;
+      fib1 = fib2;
+      fib2 = fib0 + fib1;
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 2\n");   
+   printf("Answer: %d\n", sum);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p003.c

@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+#include "projecteuler.h"
+
+int max_prime_factor(long int num);
+
+int main(int argc, char **argv)
+{
+   int res;
+   long int num = 600851475143;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   res = max_prime_factor(num);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 3\n");
+   printf("Answer: %d\n", res);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+int max_prime_factor(long int num)
+{
+   int i, limit;
+
+   if(is_prime(num))
+   {
+      return num;
+   }
+
+   if(num % 2 == 0)
+   {
+      return max_prime_factor(num/2);
+   }
+   else
+   {
+      limit = floor(sqrt(num));
+
+      for(i = 3; i <= limit; i += 2)
+      {
+         if(num % i == 0)
+         {
+            if(is_prime((long int)i))
+            {
+               return max_prime_factor(num/i);
+            }
+         }
+      }
+   }
+
+   return -1;
+}

C/p004.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int is_palindrome(int num, int base);
+
+int main(int argc, char **argv)
+{
+   int i, j, max = 0, num;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 999; i >= 100; i--)
+   {
+      for(j = i; j >= 100; j--)
+      {
+         num = i * j;
+         if(num > max && is_palindrome(num, 10))
+         {
+            max = num;
+         }
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 4\n");   
+   printf("Answer: %d \n", max);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+int is_palindrome(int num, int base)
+{
+   int reverse = 0, tmp;
+
+   tmp = num;
+
+   while(tmp > 0)
+   {
+      reverse *= base;
+      reverse += tmp % base;
+      tmp /= base;
+   }
+
+   if(num == reverse)
+   {
+      return 1;
+   }
+
+   return 0;
+}

C/p005.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "projecteuler.h"
+
+int main(int argc, char **argv)
+{
+   long int res, n[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   res = lcmm(n, 20);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 5\n");
+   printf("Answer: %ld\n", res);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p006.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int i, sum_squares = 0, square_sum = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 1; i <= 100; i++)
+   {
+      sum_squares += i*i;
+      square_sum += i;
+   }
+
+   square_sum *= square_sum;
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 6\n");   
+   printf("Answer: %d\n", square_sum-sum_squares);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p007.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "projecteuler.h"
+
+int main(int argc, char **argv)
+{
+   int count = 1, n = 1, target = 10001;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   while(count != target)
+   {
+      n += 2;
+      if(is_prime(n))
+      {
+         count++;
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 7\n");
+   printf("Answer: %d\n", n);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p008.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   char string[] = "73167176531330624919225119674426574742355349"
+                   "19493496983520312774506326239578318016984801"
+                   "86947885184385861560789112949495459501737958"
+                   "33195285320880551112540698747158523863050715"
+                   "69329096329522744304355766896648950445244523"
+                   "16173185640309871112172238311362229893423380"
+                   "30813533627661428280644448664523874930358907"
+                   "29629049156044077239071381051585930796086670"
+                   "17242712188399879790879227492190169972088809"
+                   "37766572733300105336788122023542180975125454"
+                   "05947522435258490771167055601360483958644670"
+                   "63244157221553975369781797784617406495514929"
+                   "08625693219784686224828397224137565705605749"
+                   "02614079729686524145351004748216637048440319"
+                   "98900088952434506585412275886668811642717147"
+                   "99244429282308634656748139191231628245861786"
+                   "64583591245665294765456828489128831426076900"
+                   "42242190226710556263211111093705442175069416"
+                   "58960408071984038509624554443629812309878799"
+                   "27244284909188845801561660979191338754992005"
+                   "24063689912560717606058861164671094050775410"
+                   "02256983155200055935729725716362695618826704"
+                   "28252483600823257530420752963450";
+   char cur, out;
+   long int max = 0, tmp = 1;
+   int i, j;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 0; i < 1000; i++)
+   {
+      if(i < 13)
+      {
+         cur = string[i] - '0';
+         tmp *= (long int)cur;
+      }
+      else
+      {
+         if(tmp > max)
+         {
+            max = tmp;
+         }
+         out = string[i-13] - '0';
+
+         if(out == 0)
+         {
+            tmp = 1;
+            for(j = i - 12; j <= i; j++)
+            {
+               cur = string[j] - '0';
+               tmp *= (long int)cur;
+            }
+         }
+         else
+         {
+            cur = string[i] - '0';
+            tmp /= (long int)out;
+            tmp *= (long int)cur;
+         }
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 8\n");   
+   printf("Answer: %ld\n", max);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p009.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int a, b, c, m, n, found = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(m = 2; found == 0; m++)
+   {
+      for(n = 1; n < m; n++)
+      {
+         a = m * m - n * n;
+         b = 2 * m * n;
+         c = m * m + n * n;
+
+         if(a + b + c == 1000)
+         {
+            found = 1;
+            break;
+         }
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 9\n");
+   printf("Answer: %d\n", a*b*c);
+   
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p010.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "projecteuler.h"
+
+#define N 2000000
+
+int main(int argc, char **argv)
+{
+   int i; 
+   int *primes;
+   long int sum = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+   
+   primes = sieve(N);
+
+   for(i = 0; i < N; i++)
+   {
+      if(primes[i])
+      {
+         sum += i;
+      }
+   }
+
+   free(primes);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 10\n");
+   printf("Answer: %ld\n", sum);
+   
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p011.c

@@ -0,0 +1,153 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int grid[][20] = {{8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8},      
+                    {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0},
+                    {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65},
+                    {52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91},
+                    {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80},
+                    {24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50},
+                    {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70},
+                    {67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21},
+                    {24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},
+                    {21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95},
+                    {78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92},
+                    {16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57},
+                    {86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},
+                    {19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40},
+                    {4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},
+                    {88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},
+                    {4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36},
+                    {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16},
+                    {20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54},
+                    {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48}};
+   int i, j, k, w, max = 0, prod;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 0; i < 20; i++)
+   {
+      for(j = 0; j < 20; j++)
+      {
+         prod = 1;
+         for(k = j; k < j + 4 && k < 20; k++)
+         {
+            prod *= grid[i][k];
+         }
+         if(k == j + 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = j; k > j - 4 && k >= 0; k--)
+         {
+            prod *= grid[i][k];
+         }
+         if(k == j - 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+         
+         prod = 1;
+         for(k = i; k < i + 4 && k < 20; k++)
+         {
+            prod *= grid[k][j];
+         }
+         if(k == i + 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = i; k > i - 4 && k >= 0; k--)
+         {
+            prod *= grid[k][j];
+         }
+         if(k == i - 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = i, w = j; k < i + 4 && w < j + 4 && k < 20 && w < 20; k++, w++)
+         {
+            prod *= grid[k][w];
+         }
+         if(k == i + 4 && w == j + 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = i, w = j; k < i + 4 && w > j - 4 && k < 20 && w >= 0; k++, w--)
+         {
+            prod *= grid[k][w];
+         }
+         if(k == i + 4 && w == j - 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = i, w = j; k > i - 4 && w < j + 4 && k >= 0 && w < 20; k--, w++)
+         {
+            prod *= grid[k][w];
+         }
+         if(k == i - 4 && w == j + 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+
+         prod = 1;
+         for(k = i, w = j; k > i - 4 && w > j - 4 && k >= 0 && w >= 0; k--, w--)
+         {
+            prod *= grid[k][w];
+         }
+         if(k == i - 4 && w == j - 4)
+         {
+            if(prod > max)
+            {
+               max = prod;
+            }
+         }
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 11\n");
+   printf("Answer: %d\n", max);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p012.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "projecteuler.h"
+
+int main(int argc, char **argv)
+{
+   int i = 0, finished = 0, count, triang = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   while(!finished)
+   {
+      i++;
+      triang += i;
+      count = count_divisors(triang);
+      
+      if(count > 500)
+      {
+         finished = 1;
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 12\n");   
+   printf("Answer: %d\n", triang);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p013.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <gmp.h>
+
+int main(int argc, char **argv)
+{
+   char n[100][51] = {"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"};
+   char result[100];
+   int i;
+   double elapsed;
+   struct timespec start, end;
+   mpz_t a, b;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   mpz_inits(a, b, NULL);
+   mpz_set_str(a, n[0], 10);
+
+   for(i = 1; i < 100; i++)
+   {
+      mpz_set_str(b, n[i], 10);
+      mpz_add(a, a, b);
+   }
+
+   gmp_sprintf(result, "%Zd\n", a);
+
+   mpz_clears(a, b, NULL);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec-start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 13\n");
+   printf("Answer: ");
+
+   for(i = 0; i < 10; i++)
+   {
+      printf("%c", result[i]);
+   }
+
+   printf("\n");
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p014.c

@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int collatz_length(long int n);
+
+int collatz_found[1000000] = {0};
+
+int main(int argc, char **argv)
+{
+   int i, count, max = 0, max_l = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 1; i< 1000000; i++)
+   {
+      count = collatz_length(i);
+      collatz_found[i] = count;
+      
+      if(count > max_l)
+      {
+         max_l = count;
+         max = i;
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 14\n");
+   printf("Answer: %d\n", max);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+int collatz_length(long int n)
+{
+   if(n == 1)
+      return 1;
+
+   if(n < 1000000 && collatz_found[n])
+      return collatz_found[n];
+
+   if(n % 2 == 0)
+      return 1 + collatz_length(n/2);
+   else
+      return 1 + collatz_length(3*n+1);
+}

C/p015.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <gmp.h>
+
+int main(int argc, char **argv)
+{
+   double elapsed;
+   struct timespec start, end;
+   mpz_t count, tmp;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+   
+   mpz_inits(count, tmp, NULL);
+   mpz_fac_ui(count, 40);
+   mpz_fac_ui(tmp, 20);
+   mpz_mul(tmp, tmp, tmp);
+   mpz_tdiv_q(count, count, tmp);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 15\n");
+   gmp_printf("Answer: %Zd\n", count);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+   
+   mpz_clears(count, tmp, NULL);
+
+   return 0;
+}

C/p016.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <gmp.h>
+
+int main(int argc, char **argv)
+{
+   double elapsed;
+   struct timespec start, end;
+   mpz_t p, sum, r;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   mpz_init_set_ui(p, 2);
+   mpz_init_set_ui(sum, 0);
+   mpz_init(r);
+
+   mpz_pow_ui(p, p, 1000);
+
+   while(mpz_cmp_ui(p, 0))
+   {
+      mpz_tdiv_qr_ui(p, r, p, 10);
+      mpz_add(sum, sum, r);
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 16\n");
+   gmp_printf("Answer: %Zd\n", sum);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+   
+   mpz_clears(p, sum, r, NULL);
+
+   return 0;
+}

C/p017.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+   int n1_19[19] = {3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8};
+   int n20_90[8] = {6, 6, 5, 5, 5, 7, 6, 6};
+   int n100_900[9] = {13, 13, 15, 14, 14, 13, 15, 15, 14};
+   int n1000 = 11;
+   int sum = 0, i, j;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   for(i = 0; i < 19; i++)
+   {
+      sum += n1_19[i];
+   }
+   
+   for(i = 0; i < 8; i++)
+   {
+      n20_90[i] *= 10;
+      for(j = 0; j < 9; j++)
+      {
+         n20_90[i] += n1_19[j];
+      }
+      sum += n20_90[i];
+   }
+   
+   for(i = 0; i < 9; i++)
+   {
+      n100_900[i] *= 100;
+      for(j = 0; j < 19; j++)
+      {
+         n100_900[i] += n1_19[j];
+      }
+      for(j = 0; j < 8; j++)
+      {
+         n100_900[i] += n20_90[j];
+      }
+      sum += n100_900[i] - 3;
+   }
+   
+   sum += n1000;
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 17\n");
+   printf("Answer: %d\n", sum);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p018.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void sum_triangle(int **triang, int n, int i, int j, int sum);
+
+int max = 0; 
+
+int main(int argc, char **argv)
+{
+   int i, j;
+   int **triang;
+   double elapsed;
+   FILE *fp;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   if((triang = (int **)malloc(15*sizeof(int *))) == NULL)
+   {
+      fprintf(stderr, "Error while allocating memory\n");
+      return 1;
+   }
+
+   for(i = 1; i <= 15; i++)
+   {
+      if((triang[i-1] = (int *)malloc(i*sizeof(int))) == NULL)
+      {
+         fprintf(stderr, "Error while allocating memory\n");
+         return 1;
+      }
+   }
+
+   if((fp = fopen("triang.txt", "r")) == NULL)
+   {
+      fprintf(stderr, "Error while opening file %s\n", "triang.txt");
+      return 1;
+   }
+
+   for(i = 1; i <= 15; i++)
+   {
+      for(j = 0; j < i; j++)
+      {
+         fscanf(fp, "%d", &triang[i-1][j]);
+      }
+   }
+   
+   fclose(fp);
+   
+   sum_triangle(triang, 15, 0, 0, 0);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 18\n");
+   printf("Answer: %d\n", max);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+void sum_triangle(int **triang, int n, int i, int j, int sum)
+{
+   if(i == n)
+   {
+      if(sum > max)
+      {
+         max = sum;
+      }
+      return;
+   }
+
+   sum_triangle(triang, n, i+1, j, sum+triang[i][j]);
+   sum_triangle(triang, n, i+1, j+1, sum+triang[i][j]);
+
+}

C/p019.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef enum {jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec} months;
+typedef enum {mon, tue, wed, thu, fri, sat, sun} days;
+
+int main(int argc, char **argv)
+{
+   int year, i, limit, count = 0;
+   double elapsed;
+   struct timespec start, end;
+   months month;
+   days day;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   day = mon;
+   month = jan;
+   year = 1900;
+
+   while(year < 2001)
+   {
+      if(month == feb)
+      {
+         if(i % 400 == 0 || (i % 4 == 0 && i % 100 != 0))
+         {
+            limit = 29;
+         }
+         else
+         {
+            limit = 28;
+         }
+      }
+      else if(month == apr || month == jun || month == sep || month == nov)
+      {
+         limit = 30;
+      }
+      else
+      {
+         limit = 31;
+      }
+      for(i = 1; i <= limit; i++)
+      {
+         if(year > 1900 && i == 1 && day == sun)
+         {
+            count++;
+         }
+         day = (day + 1) % 7;
+      }
+      month = (month + 1) % 12;
+      
+      if(month == jan)
+      {
+         year++;
+      }
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 19\n");
+   printf("Answer: %d\n", count);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p020.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <gmp.h>
+
+int main(int argc, char **argv)
+{
+   double elapsed;
+   struct timespec start, end;
+   mpz_t fact, r, sum;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   mpz_inits(fact, r, sum, NULL);
+
+   mpz_fac_ui(fact, 100);
+
+   mpz_set_ui(sum, 0);
+
+   while(mpz_cmp_ui(fact, 0))
+   {
+      mpz_tdiv_qr_ui(fact, r, fact, 10);
+      mpz_add(sum, sum, r);
+   }
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed=(end.tv_sec-start.tv_sec)+(double)(end.tv_nsec-start.tv_nsec)/1000000000;
+
+   printf("Project Euler, Problem 20\n");
+   gmp_printf("Answer: %Zd\n", sum);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   mpz_clears(fact, r, sum, NULL);
+
+   return 0;
+}

C/projecteuler.c

@@ -0,0 +1,130 @@
+#include <stdlib.h>
+#include <math.h>
+#include "projecteuler.h"
+
+int is_prime(long int num)
+{
+   int i, limit;
+
+   if(num <= 3)
+   {
+      return num == 2 || num == 3;
+   }
+
+   if(num % 2 == 0 || num % 3 == 0)
+   {
+      return 0;
+   }
+
+   limit = floor(sqrt(num));
+
+   for(i = 5; i <= limit; i += 6)
+   {
+      if(num % i == 0 || num % (i + 2) == 0)
+      {
+         return 0;
+      }
+   }
+
+   return 1;
+}
+
+long int gcd(long int a, long int b)
+{
+   long int tmp;
+
+   while(b != 0)
+   {
+      tmp = b;
+      b = a % b;
+      a = tmp;
+   }
+
+   return a;
+}
+
+long int lcm(long int a, long int b)
+{
+   return a * b / gcd(a, b);
+}
+
+long int lcmm(long int *values, int n)
+{
+   int i;
+   long int value;
+
+   if(n == 2)
+   {
+      return lcm(values[0], values[1]);
+   }
+   else
+   {
+      value = values[0];
+
+      for(i = 0; i < n - 1; i++)
+      {
+         values[i] = values[i+1];
+      }
+
+      return lcm(value, lcmm(values, n-1));
+   }
+}
+
+int *sieve(int n)
+{
+   int i, j, limit;
+   int *primes;
+
+   if((primes = (int *)malloc(n*sizeof(int))) == NULL)
+   {
+      return NULL;
+   }
+
+   primes[0] = 0;
+   primes[1] = 0;
+   primes[2] = 1;
+   primes[3] = 1;
+
+   for(i = 4; i < n - 1; i += 2)
+   {
+      primes[i] = 0;
+      primes[i+1] = 1;
+   }
+
+   limit = floor(sqrt(n));
+
+   for(i = 3; i < limit; i += 2)
+   {
+      if(primes[i])
+      {
+         for(j = i * i; j < n; j += 2 * i)
+         {
+            primes[j] = 0;
+         }
+      }
+   }
+
+   return primes;
+}
+
+int count_divisors(int n)
+{
+   int i, top, count = 0;
+
+   top = floor(sqrt(n));
+
+   for(i = 1; i < top; i++)
+   {
+      if(n % i == 0)
+      {
+         count += 2;
+      }
+
+      if(n == top * top)
+      {
+         count--;
+      }
+   }
+
+   return count;
+}

C/projecteuler.h

@@ -0,0 +1,11 @@
+#ifndef _PROJECTEULER_INCLUDED
+#define _PROJECTEULER_INCLUDED
+
+int is_prime(long int);
+long int lcmm(long int *values, int n);
+long int lcm(long int a, long int b);
+long int gcd(long int a, long int b);
+int *sieve(int n);
+int count_divisors(int n);
+
+#endif

C/triang.txt

@@ -0,0 +1,15 @@
+75
+95 64
+17 47 82
+18 35 87 10
+20 04 82 47 65
+19 01 23 75 03 34
+88 02 77 73 07 63 67
+99 65 04 28 06 16 70 92
+41 41 26 56 83 40 80 70 33
+41 48 72 33 47 32 37 16 94 29
+53 71 44 65 25 43 91 52 97 51 14
+70 11 33 28 77 73 17 78 39 68 17 57
+91 71 52 38 17 14 91 43 58 50 27 29 48
+63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23