Problem #51 says:

By replacing the 1st digit of *3, it turns out that six of the nine possible values: 13, 23, 43, 53, 73, and 83, are all prime.

By replacing the 3rd and 4th digits of 56**3 with the same digit, this 5-digit number is the first example having seven primes among the ten generated numbers, yielding the family: 56003, 56113, 56333, 56443, 56663, 56773, and 56993. Consequently 56003, being the first member of this family, is the smallest prime with this property.

Find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an eight prime value family.

For this problem what we need to look for are prime numbers that have repeating digits. We replace all of the similar digits with a new value. This means that the digits we replace cannot include the last digit because this will make the number non-prime for almost every replacement. The simplest way to do this is to pre-compute the digit that we are going to replace before going through all of the numbers and swapping digits out. So we have a class called CheckSet which does this for us allowing us to focus on swapping the digits and checking to see if the result is prime.

Solution below is in c#/mono and runs in about 18 seconds.

using System;
using System.Collections;
using System.Diagnostics;

namespace ProjectEuler
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Stopwatch sw = new Stopwatch();
			sw.Start();
			ArrayList p = GeneratePrimes(999999);
			ArrayList sub_p = new ArrayList();
			foreach (long l in p)
			{
				if (l > 100000)
				{
					CheckSet c = new CheckSet(l);
					if (c.DigitCount >= 1)
					{
						sub_p.Add(c);
					}
				}
			}

			foreach (CheckSet c in sub_p)
			{
				int size = FamilySize(ref p,c);
				if (size >=8)
				{
					Console.WriteLine(c.ToString());
					sw.Stop();
					Console.WriteLine(sw.Elapsed);
					Console.ReadLine();
					break;
				}
			}

		}
		static bool IsPrime(ref ArrayList primes, long num)
		{
			bool RetVal = true;
			long check = Convert.ToInt64(Math.Ceiling(Math.Sqrt(Convert.ToDouble(num))));
			foreach (long l in primes)
			{
				if (l > check)
					break;
				if (num % l == 0)
					RetVal = false;
			}
			return RetVal;
		}
        static ArrayList GeneratePrimes(long num)
        {
            ArrayList RetValue = new ArrayList();
            RetValue.Add((long)2);
            RetValue.Add((long)3);
            long Stepper = 5;
            long Check = 1;
            while (Stepper <= num)
            {
                foreach (long i in RetValue)
                {
                    if (Stepper % i == 0)
                    {
                        Check = 0;
                        break;
                    }
                    if (Math.Sqrt(Stepper) < i)
                    {
                        break;
                    }
                }
                if (Check == 1)
                {
                    //Console.WriteLine(((float)Stepper / (float)num) * 100);
                    RetValue.Add(Stepper);
                }
                Check = 1;
                Stepper++;
                Stepper++;
            }
            return RetValue;
        }
		static int FamilySize (ref ArrayList primes, CheckSet c)
		{
			int RetVal = 0;
			int[] digits = new int[10] {0,1,2,3,4,5,6,7,8,9};
			string num = c.Number.ToString();
			string cha = c.Digit;

			for (int i = 0; i<10;i++)
			{
				if (primes.Contains(long.Parse(num.Replace(cha,digits[i].ToString())))
                    && long.Parse(num.Replace(cha,digits[i].ToString())).ToString().Length == 6)
				{
					RetVal++;
				}
			}

			return RetVal;
		}
	}
	class CheckSet
	{
		public long Number;
		public string Digit;
		public int DigitCount;
		public CheckSet(long number)
		{
			Number = number;
			string s = number.ToString();
			string lastc = s[s.Length-1].ToString();
			int lengthcheck = s.Length;
			int[] digits = new int[10] {0,0,0,0,0,0,0,0,0,0};
			if (lastc != "0")
			{
				s = s.Replace("0","");
				digits[0] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "1")
			{
				s = s.Replace("1","");
				digits[1] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "2")
			{
				s = s.Replace("2","");
				digits[2] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "3")
			{
				s = s.Replace("3","");
				digits[3] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "4")
			{
				s = s.Replace("4","");
				digits[4] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "5")
			{
				s = s.Replace("5","");
				digits[5] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "6")
			{
				s = s.Replace("6","");
				digits[6] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "7")
			{
				s = s.Replace("7","");
				digits[7] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "8")
			{
				s = s.Replace("8","");
				digits[8] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			if (lastc != "9")
			{
				s = s.Replace("9","");
				digits[9] = lengthcheck - s.Length;
				lengthcheck = s.Length;
			}
			int MostCommonDigit = 0;
			int MostCommonDigitCount = 0;

			for (int i = 0;i<10;i++)
			{
				if (digits[i] > MostCommonDigitCount)
				{
					MostCommonDigit = i;
					MostCommonDigitCount = digits[i];
				}
			}

			Digit = MostCommonDigit.ToString();
			DigitCount = MostCommonDigitCount;
		}
		public override string ToString ()
		{
			return string.Format(Number.ToString() + " :: " + Digit+ " :: " + DigitCount.ToString());
		}

	}
}

Problem #60 says:

The primes 3, 7, 109, and 673, are quite remarkable. By taking any two primes and concatenating them in any order the result will always be prime. For example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four primes, 792, represents the lowest sum for a set of four primes with this property.

Find the lowest sum for a set of five primes for which any two primes concatenate to produce another prime.

At first I thought of writing a class that would generate all permutations for the possible answers. It was simpler to write a simple program that generates a list of primes and loops through it. Solution below is c#/mono and runs in 20 or so seconds.

using System;
using System.Collections;
using System.Diagnostics;

namespace ProjectEuler
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Stopwatch sw = new Stopwatch();
			sw.Start();
			ArrayList p = GeneratePrimes(10000);

			foreach (long i1 in p)
			{
				foreach (long i2 in p)
				{
					if (i2 <= i1) continue;
					if (!IsPrime(ref p, long.Parse(i1.ToString() + i2.ToString())) ||
                                            !IsPrime(ref p, long.Parse(i2.ToString() + i1.ToString())))
					{
						continue;
					}
					foreach (long i3 in p)
					{
						if (i3 <= i2) continue;
						if (!IsPrime(ref p, long.Parse(i1.ToString() + i3.ToString())) ||
                                                    !IsPrime(ref p, long.Parse(i3.ToString() + i1.ToString())) ||
						    !IsPrime(ref p, long.Parse(i2.ToString() + i3.ToString())) ||
                                                    !IsPrime(ref p, long.Parse(i3.ToString() + i2.ToString())))
						{
							continue;
						}
						foreach(long i4 in p)
						{
							if (i4 <= i3) continue;
							if (!IsPrime(ref p, long.Parse(i4.ToString() + i3.ToString())) ||
                                                            !IsPrime(ref p, long.Parse(i3.ToString() + i4.ToString())) ||
						       	    !IsPrime(ref p, long.Parse(i2.ToString() + i4.ToString())) ||
                                                            !IsPrime(ref p, long.Parse(i4.ToString() + i2.ToString())) ||
							    !IsPrime(ref p, long.Parse(i1.ToString() + i4.ToString())) ||
                                                            !IsPrime(ref p, long.Parse(i4.ToString() + i1.ToString())))
							{
								continue;
							}
							foreach(long i5 in p)
							{
								if (i5 <= i4) continue;
								if (!IsPrime(ref p, long.Parse(i5.ToString() + i3.ToString())) ||
                                                                    !IsPrime(ref p, long.Parse(i3.ToString() + i5.ToString())) ||
							    	    !IsPrime(ref p, long.Parse(i2.ToString() + i5.ToString())) ||
                                                                    !IsPrime(ref p, long.Parse(i5.ToString() + i2.ToString())) ||
								    !IsPrime(ref p, long.Parse(i1.ToString() + i5.ToString())) ||
                                                                    !IsPrime(ref p, long.Parse(i5.ToString() + i1.ToString())) ||
								    !IsPrime(ref p, long.Parse(i4.ToString() + i5.ToString())) ||
                                                                    !IsPrime(ref p, long.Parse(i5.ToString() + i4.ToString())))
								{
									continue;
								}
								else
								{
									Console.WriteLine(i1+i2+i3+i4+i5);
									sw.Stop();
									Console.WriteLine(sw.Elapsed);
									Console.ReadLine();
								}
							}
						}
					}
				}
			}

			sw.Stop();
			Console.WriteLine(sw.Elapsed);
			Console.ReadLine();
		}
		static bool IsPrime(ref ArrayList primes, long num)
		{
			bool RetVal = true;
			long check = Convert.ToInt64(Math.Ceiling(Math.Sqrt(Convert.ToDouble(num))));
			foreach (long l in primes)
			{
				if (l > check)
					break;
				if (num % l == 0)
					RetVal = false;
			}
			return RetVal;
		}
        static ArrayList GeneratePrimes(long num)
        {
            ArrayList RetValue = new ArrayList();
            RetValue.Add((long)2);
            RetValue.Add((long)3);
            long Stepper = 5;
            long Check = 1;
            while (Stepper <= num)
            {
                foreach (long i in RetValue)
                {
                    if (Stepper % i == 0)
                    {
                        Check = 0;
                        break;
                    }
                    if (Math.Sqrt(Stepper) < i)
                    {
                        break;
                    }
                }
                if (Check == 1)
                {
                    //Console.WriteLine(((float)Stepper / (float)num) * 100);
                    RetValue.Add(Stepper);
                }
                Check = 1;
                Stepper++;
                Stepper++;
            }
            return RetValue;
        }

	}
}

Problem #142 say:

Find the smallest x + y + z with integers x > y > z > 0 such that x + y, x − y, x + z, x − z, y + z, y − z are all perfect squares.

Now one can brute force this by looping over x, y and z. That takes around 4 hours on a modern computer. However there are a few relationships we can take advantage of:

x+y=a
x-y=b
x+z=c
x-z=d
y+z=e
y-z=f

e=a-d
f=a-c
b=c-e

(x+z) = (x+y)-(x-z)
(y-z) = (x+y)-(x+z)
(x-y) = (x+z)-(y+z)

x=(a+b)/2
y=(e+f)/2
z=(c-d)/2

these relationships allow us to loop on a,c,d and get the rest of the numbers from those three, this makes the solution run in around 33 msecs. That’s around a ~436363% speedup! Solution provided in c#/mono.

using System;
using System.Collections;
using System.Diagnostics;

namespace ProjectEuler
{
    class Program
    {
        static object LockHandle = new object();
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            long a2, b2, c2, d2, e2, f2;
            bool solved = false;
            sw.Start();

            for (long a = 10;!solved;a++)
            {
                a2 = a * a;
                for (long c = 5 + (0 & a); c < a && !solved; c += 2)
                {
                    c2 = c * c;
                    f2 = a2 - c2;
                    if (f2 < 1 || !IsSquare(f2))
                        continue;
                    for (long d = 2 + (1 & c); d < c; d += 2)
                    {
                        d2 = d * d;
                        e2 = a2 - d2;
                        if (e2 < 1 || !IsSquare(e2))
                            continue;
                        b2 = c2 - e2;
                        if (b2 > 0 && IsSquare(b2))
                        {
                            long x = (a2 + b2) / 2;
                            long y = (e2 + f2) / 2;
                            long z = (c2 - d2) / 2;
                            solved = true;
                            Console.WriteLine("x= " + x.ToString() +
                                 " y = " + y.ToString() + " z = " + z.ToString()
                                 + " sum = " + (z + y + x).ToString());
                            break;
                        }
                    }

                }
            }

            Console.WriteLine(sw.Elapsed);
            Console.ReadLine();
        }
        public static bool IsSquare(long n )
        {
            double root = Math.Sqrt(n);
            return (root % 1 == 0);
        }
    }
}

Problem #206 says:

Find the unique positive integer whose square has the form 1_2_3_4_5_6_7_8_9_0,
where each “_” is a single digit.

The range of number to check can be narrowed down with a calculator and some common sense. Then its just a square and check procedure. Solution is in c# and requires the .Net 4.0 framework for its parallel extensions.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Parallel;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Numerics;
using System.Text.RegularExpressions;

namespace Net4Test
{
    class Program
    {
        static object LockHandle = new object();
        static long Answer = 0;
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            Regex Test = new Regex(
            "[1][0-9][2][0-9][3][0-9][4][0-9]" +
            "[5][0-9][6][0-9][7][0-9][8][0-9][9][0-9][0]");

            Parallel.For(1360000000, 1390000000, i =>
                {

                    BigInteger biI = i;

                    if (Test.IsMatch((biI * biI).ToString()))
                    {
                        Answer = i;
                    }
                });

            Console.WriteLine(Answer);
            sw.Stop();
            Console.WriteLine(sw.Elapsed);
            Console.ReadLine();
        }

    }
}

(updates on the site. pagerank just hit 3 on google. hopefully this will increase traffic a bit. and this post is the first post on the site done in windows 7 (took 6 hours for my pc to update )

Problem #50 says:

The prime 41, can be written as the sum of six consecutive primes:
41 = 2 + 3 + 5 + 7 + 11 + 13

This is the longest sum of consecutive primes that adds to a prime below one-hundred.
The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.
Which prime, below one-million, can be written as the sum of the most consecutive primes?

The solution below is pretty much brute force. We generate the primes and then add them together and subtract from the total items in the list of primes. then we get the total of all of the primes minus the first item in the primes list and do it over again. there’s lots of room for improvements and when I get the time I’ll post them. but for now this is what I used to get the solution. Solution provided in c#/mono.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace ProjectEuler
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            ArrayList primes = GeneratePrimes(1000000);
            primes.Remove(1);
            long result = 0;
            long maxlength = 0;
            Console.WriteLine("starting check");
            for (int start = 0;start<primes.Count;start++)
            {
                long temp = 0;
                for (int i = start; i < primes.Count; i++)
                {
                    temp = temp + (long)primes[i];
                }
                for (int k = primes.Count - 1; k > start; k--)
                {
                    if (temp < 1000000 && primes.Contains(temp) && k - start >= maxlength)
                    {
                        maxlength = k -start;
                        result = temp;
                        Console.WriteLine(result);
                        break;
                    }
                    temp = temp - (long)primes[k];
                    if (temp <= start)
                        break;
                }
            }
            Console.WriteLine(result);
            Console.WriteLine(maxlength);
            Console.WriteLine(sw.Elapsed);
            Console.ReadLine();
        }
        static ArrayList GeneratePrimes(long num)
        {
            ArrayList RetValue = new ArrayList();
            RetValue.Add((long)2);
            RetValue.Add((long)3);
            long Stepper = 5;
            long Check = 1;
            while (Stepper <= num)
            {
                foreach (long i in RetValue)
                {
                    if (Stepper % i == 0)
                    {
                        Check = 0;
                        break;
                    }
                    if (Math.Sqrt(Stepper) < i)
                    {
                        break;
                    }
                }
                if (Check == 1)
                {
                    //Console.WriteLine(((float)Stepper / (float)num) * 100);
                    RetValue.Add(Stepper);
                }
                Check = 1;
                Stepper++;
                Stepper++;
            }
            return RetValue;
        }
    }
}