Add more solutions

Added solution for problems 102 and 124 in C, for problem 104
in python and for problem 145 in both C and python.

.gitignore

@@ -1,4 +1,4 @@
 Python/__pycache__
 ProblemsOverviews/*
-C/p[1,2,3,4,5,6]*.c
-Python/p[1,2,3,4,5,6]*.py
+C/p[2,3,4,5,6]*.c
+Python/p[2,3,4,5,6]*.py

C/p102.c

@@ -0,0 +1,69 @@
+/* Three distinct points are plotted at random on a Cartesian plane, for which -1000 ≤ x, y ≤ 1000, such that a triangle is formed.
+ *
+ * Consider the following two triangles:
+ *
+ * A(-340,495), B(-153,-910), C(835,-947)
+ * X(-175,41), Y(-421,-714), Z(574,-645)
+ *
+ * It can be verified that triangle ABC contains the origin, whereas triangle XYZ does not.
+ *
+ * Using triangles.txt, a 27K text file containing the co-ordinates of one thousand "random" triangles, find the number of triangles
+ * for which the interior contains the origin.
+ *
+ * NOTE: The first two examples in the file represent the triangles in the example given above.*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+
+typedef struct point
+{
+   int x;
+   int y;
+}point;
+
+int main(int argc, char **argv)
+{
+   int count = 0;
+   FILE *fp;
+   point p1, p2, p3;
+   double a, b, c, elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   if((fp = fopen("triangles.txt", "r")) == NULL)
+   {
+      fprintf(stderr, "Error while opening file %s\n", "triangles.txt");
+      return 1;
+   }
+
+   /* Using the barycentric coordinates method to determine if (0, 0) is inside the triangles.*/
+   while(fscanf(fp, "%d,%d,%d,%d,%d,%d", &p1.x, &p1.y, &p2.x, &p2.y, &p3.x, &p3.y) != EOF)
+   {
+      a = (double)((p2.y - p3.y) * (-p3.x) + (p3.x - p2.x) * (-p3.y)) /
+         ((p2.y - p3.y) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.y - p3.y));
+      b = (double)((p3.y - p1.y) * (-p3.x) + (p1.x - p3.x) * (-p3.y)) /
+         ((p2.y - p3.y) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.y - p3.y));
+      c = 1 - a - b;
+
+      if(a >= 0 && a <= 1 && b >= 0 && b <= 1 && c >= 0 && c <= 1)
+      {
+         count++;
+      }
+   }
+
+   fclose(fp);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 102\n");
+   printf("Answer: %d\n", count);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}

C/p124.c

@@ -0,0 +1,105 @@
+/* The radical of n, rad(n), is the product of the distinct prime factors of n. For example, 504 = 23 × 32 × 7, so rad(504) = 2 × 3 × 7 = 42.
+ *
+ * If we calculate rad(n) for 1 ≤ n ≤ 10, then sort them on rad(n), and sorting on n if the radical values are equal, we get:
+ *
+ *    Unsorted             Sorted         
+ *    n     rad(n)      n     rad(n)   k
+ *    1     1           1     1        1
+ *    2     2           2     2        2
+ *    3     3           4     2        3
+ *    4     2           8     2        4
+ *    5     5           3     3        5
+ *    6     6           9     3        6
+ *    7     7           5     5        7
+ *    8     2           6     6        8
+ *    9     3           7     7        9
+ *    10    10          10    10       10
+ *
+ * Let E(k) be the kth element in the sorted n column; for example, E(4) = 8 and E(6) = 9.
+ *
+ * If rad(n) is sorted for 1 ≤ n ≤ 100000, find E(10000).*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+#include "projecteuler.h"
+
+#define N 100000
+
+typedef struct n_rad
+{
+   int n;
+   int radn;
+}n_radn;
+
+int compare(void *a, void *b);
+
+int main(int argc, char **argv)
+{
+   int i, *primes;
+   n_radn **rads;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   if((primes = sieve(N)) == NULL)
+   {
+      fprintf(stderr, "Error! Sieve function returned NULL\n");
+      return 1;
+   }
+
+   if((rads = (n_radn **)malloc(N*sizeof(n_radn *))) == NULL)
+   {
+      fprintf(stderr, "Error while allocating memory\n");
+      return 1;
+   }
+
+   for(i = 0; i < N; i++)
+   {
+      if((rads[i] = (n_radn *)malloc(sizeof(n_radn))) == NULL)
+      {
+         fprintf(stderr, "Error while allocating memory\n");
+         return 1;
+      }
+   }
+
+   for(i = 0; i < N; i++)
+   {
+      rads[i]->n = i + 1;
+      rads[i]->radn = radical(i+1, primes);
+   }
+
+   free(primes);
+
+   quick_sort((void **)rads, 0, N-1, compare);
+
+   clock_gettime(CLOCK_MONOTONIC, &end);
+
+   elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
+
+   printf("Project Euler, Problem 124\n");
+   printf("Answer: %d\n", rads[9999]->n);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+int compare(void *a, void *b)
+{
+   n_radn *rad1, *rad2;
+
+   rad1 = (n_radn *)a;
+   rad2 = (n_radn *)b; 
+
+   if(rad1->radn != rad2->radn)
+   {
+      return rad1->radn - rad2->radn;
+   }
+   else
+   {
+      return rad1->n - rad2->n;
+   }
+}

C/p145.c

@@ -0,0 +1,73 @@
+/* Some positive integers n have the property that the sum [ n + reverse(n) ] consists entirely of odd (decimal) digits.
+ * For instance, 36 + 63 = 99 and 409 + 904 = 1313. We will call such numbers reversible; so 36, 63, 409, and 904 are reversible.
+ * Leading zeroes are not allowed in either n or reverse(n).
+ *
+ * There are 120 reversible numbers below one-thousand.
+ *
+ * How many reversible numbers are there below one-billion (109)?*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define N 1e9
+
+int reverse(int n);
+
+int main(int argc, char **argv)
+{
+   int i, s, count = 0;
+   double elapsed;
+   struct timespec start, end;
+
+   clock_gettime(CLOCK_MONOTONIC, &start);
+
+   /* Brute force approach, sum each number and their reverse and
+    * check if there are only odd digits.*/
+   for(i = 11; i < N; i++)
+   {
+      if(i % 10 != 0)
+      {
+         s = i + reverse(i);
+
+         while(s > 0)
+         {
+            if((s % 10) % 2 == 0)
+            {
+               break;
+            }
+            s /= 10;
+         }
+
+         if(s == 0)
+         {
+            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 145\n");
+   printf("Answer: %d\n", count);
+
+   printf("Elapsed time: %.9lf seconds\n", elapsed);
+
+   return 0;
+}
+
+int reverse(int n)
+{
+   int reverse = 0;
+
+   while(n > 0)
+   {
+      reverse *= 10;
+      reverse += n % 10;
+      n /= 10;
+   }
+
+   return reverse;
+}

C/projecteuler.c

@@ -937,3 +937,51 @@ int dijkstra(int **matrix, int **distances, int m, int n, int up, int back, int
 
    return 1;
 }
+
+/* Function that calculates the radical of n, i.e. the product
+ * of its distinct prime factors.*/
+int radical(int n, int *primes)
+{
+   int i, limit, rad = 1;
+
+   /* There can be only one prime factor of n greater than sqrt(n),
+    * if we check up to sqrt(n) and divide all the prime factors we find,
+    * at the end we will have 1 or the only prime factor larger than sqrt(n).*/
+   limit = floor(sqrt(n));
+
+   /* Check if n is divisible by two, and divide all 2s factors. Since 2
+    * is the only even prime, we can then loop only on odd numbers.*/
+   if(n % 2 == 0)
+   {
+      rad *= 2;
+
+      do
+      {
+         n /= 2;
+      }while(n % 2 == 0);
+   }
+
+   /* For each prime i, check if it's a factor of n, then divide n by i 
+    * until n % i != 0.*/
+   for(i = 3; i <= limit; i+=2)
+   {
+      if(primes[i] && n % i == 0)
+      {
+         rad *= i;
+
+         do
+         {
+            n /= i;
+         }while(n % i == 0);
+      }
+
+      /* If n is prime, all other prime factors have been found.*/
+      if(n == 1 || primes[n])
+      {
+         rad *= n;
+         break;
+      }
+   }
+
+   return rad;
+}

C/projecteuler.h

@@ -27,5 +27,6 @@ int phi(int n, int *primes);
 long int partition_fn(int n, long int *partitions, int mod);
 int partition_fn_mpz(int n, mpz_t res, mpz_t *partitions);
 int dijkstra(int **matrix, int **distances, int m, int n, int up, int back, int start);
+int radical(int n, int *primes);
 
 #endif

Python/p104.py

@@ -0,0 +1,57 @@
+# The Fibonacci sequence is defined by the recurrence relation:
+#
+# F_n = F_n−1 + F_n−2, where F_1 = 1 and F_2 = 1.
+# It turns out that F_541, which contains 113 digits, is the first Fibonacci number for which the last nine digits are 1-9 pandigital
+# (contain all the digits 1 to 9, but not necessarily in order). And F_2749, which contains 575 digits, is the first Fibonacci number
+# for which the first nine digits are 1-9 pandigital.
+#
+# Given that F_k is the first Fibonacci number for which the first nine digits AND the last nine digits are 1-9 pandigital, find k.
+
+#!/usr/bin/python
+
+from mpmath import matrix, mp
+
+from timeit import default_timer
+from projecteuler import is_pandigital
+
+def main():
+    start = default_timer()
+
+    found = 0
+    fib1 = 1
+    fib2 = 1
+    i = 2
+
+    while not found:
+#       Calculate the next Fibonacci number modulo 10^9 and check if the result is 1-9 pandigital.
+        fibn = (fib1 + fib2) % 1000000000
+        fib1 = fib2
+        fib2 = fibn
+        i = i + 1
+
+#       If the last 9 digits of fib_n are pandigital, calculate the ith Fibonacci number using
+#       the matrix representation, with sufficient precision so that the at least the first
+#       9 digits are correct (we don't need the whole number. If the first 9 digits are also
+#       pandigital, we found the solution.
+        if is_pandigital(fibn, 9):
+            fib_matrix = matrix(2)
+            fib_matrix[0, 0] = 1
+            fib_matrix[0, 1] = 1
+            fib_matrix[1, 0] = 1
+            fib_matrix[1, 1] = 0
+
+            fib = fib_matrix ** i
+            fib = int(fib[0, 1])
+
+            if is_pandigital(int(str(fib)[:9]), 9):
+                found = 1
+ 
+    end = default_timer()
+
+    print('Project Euler, Problem 104')
+    print('Answer: {}'.format(i))
+
+    print('Elapsed time: {:.9f} seconds'.format(end - start))
+
+if __name__ == '__main__':
+    main()

Python/p145.py

@@ -0,0 +1,38 @@
+#!/usr/bin/python
+
+# Some positive integers n have the property that the sum [ n + reverse(n) ] consists entirely of odd (decimal) digits.
+# For instance, 36 + 63 = 99 and 409 + 904 = 1313. We will call such numbers reversible; so 36, 63, 409, and 904 are reversible.
+# Leading zeroes are not allowed in either n or reverse(n).
+#
+# There are 120 reversible numbers below one-thousand.
+#
+# How many reversible numbers are there below one-billion (109)?
+
+from timeit import default_timer
+
+def main():
+    start = default_timer()
+
+    N = 10000000
+    
+    count = 0
+
+#   Brute force approach, sum each number and their reverse and
+#   check if there are only odd digits.
+    for i in range(11, N):
+        if i % 10 != 0:
+            s = str(i + int(''.join(reversed(str(i)))))
+
+            if not '0' in s and not '2' in s and not '4' in s and\
+                    not '6' in s and not '8' in s:
+                count = count + 1
+
+    end = default_timer()
+
+    print('Project Euler, Problem 145')
+    print('Answer: {}'.format(count))
+
+    print('Elapsed time: {:.9f} seconds'.format(end - start))
+
+if __name__ == '__main__':
+    main()