Add comments

Added comments to the code of problems from 6 to 10 in C.

C/p006.c

@@ -1,3 +1,15 @@
+/* The sum of the squares of the first ten natural numbers is,
+ *
+ * 1^2 + 2^2 + ... + 10^2 = 385
+ * 
+ * The square of the sum of the first ten natural numbers is,
+ *
+ * (1 + 2 + ... + 10)^2 = 55^2 = 3025
+ * 
+ * Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
+ *
+ * Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -10,6 +22,7 @@ int main(int argc, char **argv)
 
    clock_gettime(CLOCK_MONOTONIC, &start);
 
+   /* Straightforward brute-force approach.*/
    for(i = 1; i <= 100; i++)
    {
       sum_squares += i*i;

C/p007.c

@@ -1,3 +1,7 @@
+/* By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
+ *
+ * What is the 10 001st prime number?*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -11,9 +15,13 @@ int main(int argc, char **argv)
 
    clock_gettime(CLOCK_MONOTONIC, &start);
 
+   /* Brute force approach: start with count=1 and check every odd number
+    * (2 is the only even prime), if it's prime increment count, until the
+    * target prime is reached.*/
    while(count != target)
    {
       n += 2;
+      /* Use the function in projecteuler.c to check if a number is prime.*/
       if(is_prime(n))
       {
          count++;

C/p008.c

@@ -1,3 +1,28 @@
+/* The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
+ *
+ * 73167176531330624919225119674426574742355349194934
+ * 96983520312774506326239578318016984801869478851843
+ * 85861560789112949495459501737958331952853208805511
+ * 12540698747158523863050715693290963295227443043557
+ * 66896648950445244523161731856403098711121722383113
+ * 62229893423380308135336276614282806444486645238749
+ * 30358907296290491560440772390713810515859307960866
+ * 70172427121883998797908792274921901699720888093776
+ * 65727333001053367881220235421809751254540594752243
+ * 52584907711670556013604839586446706324415722155397
+ * 53697817977846174064955149290862569321978468622482
+ * 83972241375657056057490261407972968652414535100474
+ * 82166370484403199890008895243450658541227588666881
+ * 16427171479924442928230863465674813919123162824586
+ * 17866458359124566529476545682848912883142607690042
+ * 24219022671055626321111109370544217506941658960408
+ * 07198403850962455444362981230987879927244284909188
+ * 84580156166097919133875499200524063689912560717606
+ * 05886116467109405077541002256983155200055935729725
+ * 71636269561882670428252483600823257530420752963450
+ *
+ * Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -37,6 +62,7 @@ int main(int argc, char **argv)
 
    for(i = 0; i < 1000; i++)
    {
+      /* For the first 13 digits, just multiply them.*/
       if(i < 13)
       {
          cur = string[i] - '0';
@@ -44,12 +70,15 @@ int main(int argc, char **argv)
       }
       else
       {
+         /* If the current product is greater than the maximum, save the current as maximum.*/
          if(tmp > max)
          {
             max = tmp;
          }
+         /* Check the value of the first digit of the previous sequence, which will not be part
+          * of the next sequence.*/
          out = string[i-13] - '0';
-
+         /* If the digit is zero, multiply all the 13 digits of the new sequence.*/
          if(out == 0)
          {
             tmp = 1;
@@ -59,6 +88,8 @@ int main(int argc, char **argv)
                tmp *= (long int)cur;
             }
          }
+         /* If the digit not zero, instead of multiplying all the 13 digits of the new sequence,
+          * divide the current product by the remove digit and multiply it by the new digit.*/
          else
          {
             cur = string[i] - '0';

C/p009.c

@@ -1,3 +1,13 @@
+/* A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
+ *
+ * a2 + b2 = c2
+ *
+ * For example, 32 + 42 = 9 + 16 = 25 = 52.
+ *
+ * There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+ *
+ * Find the product abc.*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -10,6 +20,8 @@ int main(int argc, char **argv)
 
    clock_gettime(CLOCK_MONOTONIC, &start);
 
+   /* Brute force approach: generate all the Pythagorean triplets using
+    * Euclid's formula, until the one where a+b+c=1000 is found.*/
    for(m = 2; found == 0; m++)
    {
       for(n = 1; n < m; n++)

C/p010.c

@@ -1,3 +1,7 @@
+/* The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+ *
+ * Find the sum of all the primes below two million.*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
@@ -15,11 +19,15 @@ int main(int argc, char **argv)
 
    clock_gettime(CLOCK_MONOTONIC, &start);
 
-   if(primes = sieve(N) == NULL)
+   /* Use the function in projecteuler.c implementing the 
+    * Sieve of Eratosthenes algorithm to generate primes.*/
+   if((primes = sieve(N)) == NULL)
    {
       fprintf(stderr, "Error! Sieve function returned NULL\n");
       return 1;
+   }
 
+   /* Sum all the primes.*/
    for(i = 0; i < N; i++)
    {
       if(primes[i])

C/projecteuler.c

@@ -113,6 +113,8 @@ long int lcmm(long int *values, int n)
    }
 }
 
+/* Function implementing the Sieve or Eratosthenes to generate
+ * primes up to a certain number.*/
 int *sieve(int n)
 {
    int i, j, limit;
@@ -123,23 +125,33 @@ int *sieve(int n)
       return NULL;
    }
 
+   /* 0 and 1 are not prime, 2 and 3 are prime.*/
    primes[0] = 0;
    primes[1] = 0;
    primes[2] = 1;
    primes[3] = 1;
 
+   /* Cross out (set to 0) all even numbers and set the odd numbers to 1 (possible prime).*/
    for(i = 4; i < n - 1; i += 2)
    {
       primes[i] = 0;
       primes[i+1] = 1;
    }
 
+   /* If i is prime, all multiples of i smaller than i*i have already been crossed out.
+    * if i=sqrt(n), all multiples of i up to n (the target) have been crossed out. So
+    * there is no need check i>sqrt(n).*/
    limit = floor(sqrt(n));
 
    for(i = 3; i < limit; i += 2)
    {
+      /* Find the next number not crossed out, which is prime.*/
       if(primes[i])
       {
+         /* Cross out all multiples of i, starting with i*i because any smaller multiple 
+          * of i has a smaller prime factor and has already been crossed out. Also, since
+          * i is odd, i*i+i is even and has already been crossed out, so multiples are 
+          * crossed out with steps of 2*i.*/
          for(j = i * i; j < n; j += 2 * i)
          {
             primes[j] = 0;