A circular prime, according to Project Euler, is a prime whose cyclical permutations are themselves prime:

The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.

There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.

The object of Problem 35 is to find how many there are under a million. As far as I could tell, there's no way to find out if a number is a circular prime other than testing all of its cyclical permutations, so I used a sieve of Eratosthenes to construct a list of all primes below one million and checked each rotation of each prime by converting it to a string and shuffling the characters.

My big programming challenge in this one was writing a faster sieve. The LINQ-powered one-liner I had been using (`for (int i = 0; i < eratosthenes.Count(); i++){ eratosthenes.RemoveAll(x => (x != eratosthenes[i]) && (x % eratosthenes[i] == 0)); }`) choked when I asked it to find all primes up to a million, as it required performing a modulo check on all remaining members of a list of potential primes. I replaced the list with an `bool` array in which prime indexes would hold the value of `true`. I found multiples of known primes using addition rather than modulo checks, which sped things up considerably.

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

namespace Problem035
{
class Program
{
static void Main(string[] args)
{
int ceiling = 1000000;
List<int> primesUnderCeiling = sieveOfEratosthenes(ceiling);
int circularPrimeCount = 0;

foreach (int n in primesUnderCeiling)
if (isCircularPrime(n, primesUnderCeiling))
circularPrimeCount++;

Console.WriteLine(circularPrimeCount);
}

private static bool isCircularPrime(int n, List<int> primes)
{
string prime = n.ToString();
string nextPrime = "";
bool circularPrime = true;

for (int i = 0; i < prime.Length; i++)
{
for (int j = 0; j < prime.Length; j++)
{
if (j == prime.Length - 1)
nextPrime += prime;
else
nextPrime += prime[j + 1];
}

if (!primes.Contains(Int32.Parse(nextPrime)))
{
circularPrime = false;
break;
}

prime = nextPrime;
nextPrime = "";
}

return circularPrime;
}

private static List<int> sieveOfEratosthenes(int ceil)
{
bool[] eratosthenes = new bool[ceil];

eratosthenes = true;
for (int i = 3; i < eratosthenes.Length; i += 2)
eratosthenes[i] = true;

for (int i = 0; i < eratosthenes.Length; i++)
{
if (eratosthenes[i])
{
int notPrime = i * 2;

while (notPrime < eratosthenes.Length)
{
eratosthenes[notPrime] = false;
notPrime += i;
}
}
}

List<int> primes = new List<int>();

for (int i = 2; i < eratosthenes.Length; i++)
if (eratosthenes[i])