Blog Archives

Project Euler Problem#12 solution in C++

May 23

Posted by

The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, …

Let us list the factors of the first seven triangle numbers:

 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

Solution:


#include <cstdio>
#include <cmath>

int numDivisors(int num)
{
int divisors = 1, exp;

//handle 2 and 3 as special case
exp = 0;
while (num % 2 == 0) {
num /= 2;
exp++;
}
divisors *= (exp+1);

exp = 0;
while (num % 3 == 0) {
num /= 3;
exp++;
}
divisors *= (exp+1);

//the other primes are 6k +/- 1
int i = 5;
int root = floor(sqrt(num));
while (i <= root) {
exp = 0;
while (num % i == 0) {
num /= i;
exp++;
}
divisors *= (exp+1);

if (i % 6 == 1)
i += 4;
else
i += 2;
root = floor(sqrt(num));
}

//a single largest prime factor
if (num != 1)
divisors *= 2;

return divisors;
}

int main(void)
{
int n = 0;
int divisors = 0;

while (divisors <= 500) {
//while (n <= 10) {
n++;

//since t = n*(n+1)/2 and gcd(n,n+1)=1
if (n % 2 == 0)
divisors = numDivisors(n/2) * numDivisors(n+1);
else
divisors = numDivisors(n) * numDivisors((n+1)/2);
}

printf("%d - %ld: %d\n", n, (long)n*(n+1)/2, divisors);
}
Related articles

Posted in Project Euler

5 Comments

Tags: , , , , , , , , ,

Project Euler Problem#11 solution in C++

May 13

Posted by

In the 20×20 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 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 03 45 02 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 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 × 63 × 78 × 14 = 1788696.

What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?

Solution:

#include<iostream>

const int num = 20;

void multiply(long long&, int [][num], int [], int, int, int ,int);

int main()
{

int array[num][num] =
{
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,  3, 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
};

long long maxNum = 1;
int bArray[4];
for (int i = 0; i < num; i++)
{
for (int j = 0; j < num; j++)
{
multiply(maxNum, array, bArray, i, j, 1, 0);
multiply(maxNum, array, bArray, i, j, 0, 1);
multiply(maxNum, array, bArray, i, j, 1, 1);
multiply(maxNum, array, bArray, i, j, -1, 1);
}
}

std::cout << maxNum << " = " << bArray[0] << " * " << bArray[1] << " * " << bArray[2] << " * " << bArray[3] << std::endl;

return 0;
}

void multiply(long long& maxNum, int array[][num], int bArray[], int x, int y, int dx, int dy)
{
long long tempNum = 1;
for (int i = 0; i < 4 && x < num && x >=0 && y < num && y >= 0; i++, x += dx, y += dy)
tempNum *= array[x][y];

if (maxNum < tempNum)
{
maxNum = tempNum;
bArray[0] = array[x - dx][y - dy];
bArray[1] = array[x - dx * 2][y - dy * 2];
bArray[2] = array[x - dx * 3][y - dy * 3];
bArray[3] = array[x - dx * 4][y - dy * 4];
}
}
Related articles

Posted in Project Euler

1 Comment

Tags: , , , , , , , ,

Project Euler Problem#10 solution in C++

Apr 29

Posted by

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

Explanation:

Sieve of Eratosthenes: algorithm steps for primes below 121 (including optimization of starting from prime’s square).

In mathematics, the sieve of Eratosthenes (Greek: κόσκινον Ἐρατοσθένους), one of a number of prime number sieves, is a simple, ancient algorithm for finding all prime numbers up to any given limit. It does so by iteratively marking as composite (i.e. not prime) the multiples of each prime, starting with the multiples of 2.[1]

The multiples of a given prime are generated starting from that prime, as a sequence of numbers with the same difference, equal to that prime, between consecutive numbers.[1] This is the sieve’s key distinction from using trial division to sequentially test each candidate number for divisibility by each prime.[2]

The sieve of Eratosthenes is one of the most efficient ways to find all of the smaller primes (below 10 million or so).[3] It is named after Eratosthenes of Cyrene, a Greek mathematician; although none of his works have survived, the sieve was described and attributed to Eratosthenes in the Introduction to Arithmetic by Nicomachus.[4]

(above explanation taken from Wikipedia)

C++ solution:

//solution is written in a flexible manner that you could compute sum of n prime numbers.

#include <iostream>

using namespace std;

int find_prime (long *numArray, int maxNum)
{
long factor = 2; // we will make 2 as the starting point.
numArray[1] = 0; // rule out 1 from our logic to avoid incorrect results.

// loop condition will check, if we are in our maximum number limit.
//maxNum is the number till there we can find the prime numbers.
while ((factor * factor) < maxNum)
{
for (int i = 2; i < maxNum; i++) // we start our itration from number 2 not from 0 or 1 to get correct results.
{
if (numArray[i] != 0) //if a number on current array index is not zero, it is a prime or we havne’t yet checked it.
{
// we are putting zeros on all multiples of prime numbers, one by one.
if (numArray[i] != factor && (numArray[i]% factor) == 0)
{
numArray[i] = 0;
}
}
}
++factor;
}// after the loop, array will have zeros on all non prime locations and prime numbers.
}

int main ()
{
int prime_count = 0;
int64_t sum = 0;
int maxNum = 0;
int i = 0;

cout << “enter max number for array: “; // you need to test some upper limit values.
cin >> maxNum;

long *myArray = new long [maxNum];

//we fill up the array till the number we want to find the smallest positive number that is evenly divisible.
for (int i = 0; i < maxNum; i++)
{
myArray[i]= i;
}

// we will get prime numbers till the maxNum by calling below funtions.
find_prime(myArray, maxNum);

for (int j = 0; j< maxNum; j++)
{
sum += myArray[j];
}

cout << “Sum of first ” << maxNum <<  ” prime numbers : ” << sum << endl;

}

Related articles

Posted in C++, Project Euler

5 Comments

Tags: , , , , , , ,