Problem #75 says:

It turns out that 12 cm is the smallest length of wire that can be bent to form an integer
sided right angle triangle in exactly one way, but there are many more examples.

12 cm: (3,4,5)
24 cm: (6,8,10)
30 cm: (5,12,13)
36 cm: (9,12,15)
40 cm: (8,15,17)
48 cm: (12,16,20)

In contrast, some lengths of wire, like 20 cm, cannot be bent to form an integer sided right
angle triangle, and other lengths allow more than one solution to be found; for example,
using 120 cm it is possible to form exactly three different integer sided right angle triangles.

120 cm: (30,40,50), (20,48,52), (24,45,51)

Given that L is the length of the wire, for how many values of L ≤ 1,500,000 can exactly
one integer sided right angle triangle be formed?

Another counting problem but here we have to avoid duplicate entries that can come from a variety
of places. This solution uses the 2 number approach for generating Pythagorean triples, which it then finds
the lengths of the triple and catalogs it in an array to track duplicates, Then counts all the values of the
array that equal 1 for the final answer.

Solution is provided in c#/mono. Runs in under one second.

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

namespace Problem75
{
	class MainClass
	{
		public static void Main (string[] args)
		{
			Stopwatch sw = new Stopwatch();
			sw.Start();
			int limit = 1500000;
			int adjlimit = (int)(Math.Sqrt((float)limit));
			ArrayList tri = new ArrayList(limit);

			for (int st = 0; st < limit+1; st++)
				tri.Add(0);

			for (int i = 1; i <= adjlimit; i=i+2)
			{
				for (int j = 2; j<= adjlimit; j=j+2)
				{
					if (GCD(i,j) == 1)
					{
						int sum = Math.Abs((j*j) - (i*i)) + (2*j*i) + ((i*i) + (j*j));
						for (int s = sum; s < limit; s=s+sum)
						{

							tri[s] = (int)tri[s]+1;
						}
					}
				}
			}
			Console.WriteLine(TallyResults(tri));
			sw.Stop();
			Console.WriteLine(sw.Elapsed);
			Console.ReadLine();
		}
		public static int TallyResults(ArrayList a)
		{
			int RetVal = 0;
			foreach (int i in a)
			{
				if (i == 1)
					RetVal= RetVal+1;
			}
			return RetVal;
		}
		public static int GCD (int a, int b)
		{
			if (b == 0)
				return a;
			else
				return GCD(b,(a%b));
		}
	}
}

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());
		}

	}
}

(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;
        }
    }
}

So in my recent works with Gtk I’ve come across (and written) some useful snippets so I thought I’d post a few of them.

The first comes from this site (its in Spanish), this snippet allows you to take a System.Drawing.Image to a Gdk.Pixbuf and it looks like this (slightly modified to fix an ambiguous reference in my project).

static Gdk.Pixbuf ImageToPixbuf( System.Drawing.Image image )
{
  using ( MemoryStream stream = new MemoryStream() )
  {
    image.Save( stream, System.Drawing.Imaging.ImageFormat.Png );
    stream.Position = 0;
    return new Gdk.Pixbuf( stream );
  }
}

So, we can take this first function and we can use it in this second snippet which takes an list of images and makes a single pixbuf that contains all of the images. This allows us to take a group of icon files and string them into a single image to be used in a gtk nodeview so that it only requires one column to show a variety of status icons, which is what I’m using it for maybe you can find something more interesting for it to do. Any ways the second snippet I share with you today looks like this.

public Gdk.Pixbuf GenerateIconImage(List<System.Drawing.Image> images)
{

	if(images != null && images.Count> 0)
	{
		Gdk.Pixbuf Composite = ImageToPixbuf(images[0]).Clone() as Gdk.Pixbuf;
		images.RemoveAt(0);

		foreach (System.Drawing.Image i in images)
		{
			Composite = CreateComposite(Composite,ImageToPixbuf(i).Clone() as Gdk.Pixbuf);
		}
		return Composite;
	}
	else
	{
		Gdk.Pixbuf Composite = new Gdk.Pixbuf(Gdk.Colorspace.Rgb,true,8,16,16);
		Composite.Fill(0);
		return Composite;
	}

}

public Gdk.Pixbuf CreateComposite(Gdk.Pixbuf p1, Gdk.Pixbuf p2)
{
	Gdk.Pixbuf composite = new Gdk.Pixbuf(Gdk.Colorspace.Rgb,true,8,p1.Width+ p2.Width,p1.Height);
	p1.Composite(composite,0,0,p1.Width,p1.Height,0,0,1,1,Gdk.InterpType.Hyper,255);
	p2.Composite(composite,p1.Width,0,p2.Width,p2.Height,p1.Width,0,1,1,Gdk.InterpType.Hyper,255);
	return composite;
}