Exemplo n.º 1
0
        public static int truncatableprimes(int n)
        {
            int count = 0;
            int sum   = 0;

            PrimeFunctions.GeneratePrimesToList(1000000);
            PrimeFunctions.ConvertToHash();
            int i = 4;

            while (count < n)
            {
                bool       isprime = true;
                List <int> trunc   = CombinatoricFunctions.truncations(PrimeFunctions.PrimeList[i]);
                foreach (int truncation in trunc)
                {
                    if (!PrimeFunctions.PrimeListHash.Contains(truncation))
                    {
                        isprime = false;
                        break;
                    }
                }
                if (isprime)
                {
                    count++;
                    sum += PrimeFunctions.PrimeList[i];
                }
                i++;
            }
            return(sum);
        }
Exemplo n.º 2
0
        public static int SmallestMultiple(int n)
        {
            PrimeFunctions.GeneratePrimesTillNToList(n);
            List <int> FactorList = new List <int>();

            //Loop until highest multiple
            for (int i = 2; i <= n; i++)
            {
                //Find all the factors of the number
                List <int> factors = PrimeFunctions.PrimeFactor(i, false);
                //If the list of factors doesn't contain the factor or as many factors, then add it to the list
                foreach (int factor in factors)
                {
                    if (MiscFunctions.ReturnDistinctCountList(factors, factor) > MiscFunctions.ReturnDistinctCountList(FactorList, factor))
                    {
                        FactorList.Add(factor);
                    }
                }
            }
            //Loop through the minimum required factors and multiply them all
            int mult = 1;

            foreach (int factor in FactorList)
            {
                mult *= factor;
            }
            return(mult);
        }
Exemplo n.º 3
0
        public static int CirculuarPrimes(int n)
        {
            PrimeFunctions.GeneratePrimesTillNToList(1000000);
            PrimeFunctions.ConvertToHash();

            int count = 0;

            for (int i = 2; i < n; i++)
            {
                List <int> rots  = CombinatoricFunctions.rotations(i);
                bool       prime = true;
                foreach (int rot in rots)
                {
                    if (!PrimeFunctions.PrimeListHash.Contains(rot))
                    {
                        prime = false;
                        break;
                    }
                }
                if (prime)
                {
                    count++;
                    //Console.WriteLine(i);
                }
            }
            return(count);
        }
Exemplo n.º 4
0
        public static long SummationOfPrimes(int n)
        {
            List <int> primes = PrimeFunctions.GeneratePrimesTillN(2 * n);
            long       k      = 0;

            for (int i = 0; primes[i] < n; i++)
            {
                k += primes[i];
            }
            return(k);
        }
Exemplo n.º 5
0
        public static int PandigitalPrime(int n)
        {
            List <int> PanPrimes = new List <int>();

            PrimeFunctions.GeneratePrimesTillNToList(n);
            for (int i = 0; i < PrimeFunctions.PrimeList.Count; i++)
            {
                if (MiscFunctions.IsPandigital(PrimeFunctions.PrimeList[i]))
                {
                    PanPrimes.Add(PrimeFunctions.PrimeList[i]);
                }
            }
            return(PanPrimes.Max());
        }
Exemplo n.º 6
0
        public static int OddComposite()
        {
            int           comp       = 0;
            List <int>    primes     = PrimeFunctions.GeneratePrimes(10000);
            HashSet <int> primeshash = MiscFunctions.ListToHash(primes);
            List <int>    squares    = SpecialSequences.squares(1000);

            HashSet <int> squareshash = MiscFunctions.ListToHash(squares);
            int           i           = 3;
            bool          found       = false;

            while (comp == 0)
            {
                found = false;
                i    += 2;
                if (primeshash.Contains(i))
                {
                    continue;
                }
                for (int j = 0; j < primes.Count; j++)
                {
                    if (primes[j] > i)
                    {
                        break;
                    }
                    for (int k = 0; k < squares.Count; k++)
                    {
                        if (squares[k] * 2 > i)
                        {
                            break;
                        }
                        if (primes[j] + (squares[k] * 2) == i)
                        {
                            found = true;
                        }
                    }
                }
                if (!found)
                {
                    comp = i;
                }
            }
            return(comp);
        }
Exemplo n.º 7
0
        public static int DistinctPrimeFactors()
        {
            PrimeFunctions.GeneratePrimesToList(100000);
            int i     = 2;
            int count = 0;

            while (count < 4)
            {
                i++;
                List <int>    primes  = PrimeFunctions.PrimeFactor(i);
                HashSet <int> factors = MiscFunctions.ListToHash(primes);
                if (factors.Count == 4)
                {
                    count++;
                }
                else
                {
                    count = 0;
                }
            }
            return(i - 3);
        }
Exemplo n.º 8
0
        public static int QuadraticPrimes(int n)
        {
            PrimeFunctions.GeneratePrimesTillNToList(n * n);
            PrimeFunctions.ConvertToHash();
            int maxi      = 0;
            int maxj      = 0;
            int maxprimes = 0;

            for (int i = (n * -1); i < n; i++)
            {
                for (int j = (n * -1); j < n; j++)
                {
                    if (numquadprimes(i, j) > maxprimes)
                    {
                        maxprimes = numquadprimes(i, j);
                        maxi      = i;
                        maxj      = j;
                    }
                }
            }
            return(maxi * maxj);
        }
Exemplo n.º 9
0
 public static int LargestPrimeFactor(long n)
 {
     //Return the largest number in the list of prime factors
     return(PrimeFunctions.PrimeFactor(n).Max());
 }
Exemplo n.º 10
0
 public static int TenthousandstPrime(int n)
 {
     return(PrimeFunctions.NthPrime(n));
 }