示例#1
0
        /// <summary>生成随机的银行卡卡号
        /// </summary>
        /// <param name="prefix"> </param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string GetFixNumberString(int prefix = 0, int length = 16)
        {
            if (length < 1)
            {
                throw new ArgumentException("卡号长度不能小于1");
            }
            var prefixLength = UtilityMath.GetLength(prefix);
            var sb           = new StringBuilder(length);

            if (prefix > 0)
            {
                if (prefixLength > length)
                {
                    sb.Append(prefix.ToString().Substring(0, length));
                }
                else
                {
                    sb.Append(prefix);
                }
            }
            for (int i = 0; i < length - prefixLength; i++)
            {
                sb.Append(Random.Next(0, 9));
            }
            return(sb.ToString());
        }
示例#2
0
        public static Result LargeSum(Problem arguments)
        {
            string m;
            string sequence = arguments.Sequence;
            int    digits   = Convert.ToInt32(arguments.LongNumber);

            string[] numbers = sequence.Split(',').ToArray <string>();
            int      height  = numbers.Length;
            int      width   = numbers[0].Length;

            int[,] matrix = UtilityMath.LoadMatrix(numbers, height, width);
            string sum = UtilityMath.AddMatrix(matrix);

            if (digits < sum.Length)
            {
                m = string.Format("The first {0} digits of the large sum are {1}.", digits, sum.Substring(0, digits));
            }
            else
            {
                m = "Error: not enough digits specified.";
            }
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#3
0
        public PrimeSet(int c)
        {
            Count    = c;
            Primes   = UtilityMath.ErathostenesSieve(3, 20000);
            Minimums = Enumerable.Repeat(int.MaxValue, 5).ToArray();
            Pairs    = new HashSet <int> [Primes.Length];
            Set      = new int[Count];

            var IsPrime = UtilityMath.IsPrimeUsingSquares.Memoize();

            for (int a = 0; a < Primes.Length; a++)
            {
                Pairs[a] = new HashSet <int>();
                int x = Primes[a];

                for (int b = 0; b < Primes.Length; b++)
                {
                    if (a == b)
                    {
                        continue;
                    }
                    int y = Primes[b];
                    if (IsPrime(UtilityMath.NumericConcat(x, y)) &&
                        IsPrime(UtilityMath.NumericConcat(y, x)))
                    {
                        Pairs[a].Add(y);
                    }
                }
            }
        }
示例#4
0
        public static Result LargestProductInGrid(Problem arguments)
        {
            string   sequence = arguments.Sequence;
            int      adjacent = Convert.ToInt32(arguments.LongNumber);
            int      maxProduct = int.MinValue, product = 0;
            CellList VisitedCellBlocks = new CellList(); //so we don't calculate on repeated blocks of adjcent cells

            //initialize grid from string sequence
            string[][] grid = sequence.Split(':').Select(row => row.Split(',')).ToArray();
            int        size = grid.Length;

            //get highest adajacent product of adjacents to every grid cell
            for (int i = 0; i < size; i++)
            {
                for (int j = 0; j < size; j++)
                {
                    product = UtilityMath.GetAdjacentMaxproduct(i, j, adjacent, size, grid, VisitedCellBlocks);

                    if (product > maxProduct)
                    {
                        maxProduct = product;
                    }
                }
            }

            var m = string.Format("The greatest product of {0} adjacent numbers in the same direction (up, down, left, right, or diagonally) in the {1}×{1} grid is {2}.", adjacent, size, maxProduct);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#5
0
        /// <summary>
        /// https://projecteuler.net/problem=53
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result CombinatoricSelections(Problem arguments)
        {
            var limit = arguments.IntNumber;
            var count = 0;


            //todo: use factaorial in loop and cache it in array

            for (int n = 1; n <= 100; n++)
            {
                for (int r = 1; r < n; r++)
                {
                    if (UtilityMath.BinomialCoefficients(n, r) >= limit)
                    {
                        count++;
                    }
                }
            }
            var answer  = count.ToString();
            var message = string.Format("{0} not necessarily distinct, values of  nCr, for 1 ≤ n ≤ 100, are greater than {1}.", answer, limit);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var result = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(result);
        }
示例#6
0
        public static Result LargestProductInSeries(Problem arguments)
        {
            string sequence = arguments.Sequence;
            int    digits = Convert.ToInt32(arguments.LongNumber);
            string segment = string.Empty, digit = string.Empty;
            int    start   = 0;
            long   product = long.MinValue;

            while (start + digits < sequence.Length)
            {
                segment = sequence.Substring(start, digits);
                start++;
                long p = UtilityMath.GetProduct(segment);

                if (p > product)
                {
                    product = p;
                    digit   = segment;
                }
            }

            var m = string.Format("the adjacent digits [{0}] in the 1000-digit number that have the greatest product which is {1}.", string.Join("x", digit.ToArray()), product);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#7
0
        /// <summary>
        /// https://projecteuler.net/problem=56
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result PowerfulDigitSum(Problem arguments)
        {
            var  limit = arguments.IntNumber;
            long max   = 100; // include all 100 * 1^b to begin with

            for (int a = 2; a < limit; a++)
            {
                for (int b = 1; b < limit; b++)
                {
                    var ab  = BigInteger.Pow(a, b);
                    var sum = UtilityMath.DigitsSum(ab.ToString());
                    if (sum > max)
                    {
                        max = sum;
                    }
                }
            }

            var answer  = max.ToString();
            var message = string.Format("The maximum digital sum of natural numbers of the form, a^b, where a, b < {0}, is {1}.", limit, answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#8
0
        static Result LargestPrimeFactor(Problem arguments)
        {
            //n=600851475143;143;8462696833;
            long        number  = arguments.LongNumber;
            Tree <long> factors = new Tree <long>();
            string      m;

            UtilityMath.GetPrimeFactors(number, factors);

            bool isPrime = factors.Size == 0;
            long max     = (long)factors.Max();

            if (isPrime)
            {
                m = string.Format("The prime factors of {0} are [{1}], maximum is {2}", number, factors.ToString(), max);
            }
            else
            {
                m = string.Format("{0} is not a prime, but its prime factors are [{1}] with maximum {2}", number, factors.ToString(), max);
            }

            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#9
0
        /// <summary>
        /// https://projecteuler.net/problem=61
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result CyclicalFigurateNumbers(Problem arguments)
        {
            var numbers = UtilityMath.GetPolygonalNumbers <int>(1009, 9999).ToArray();

            var count = numbers.Length;

            var types          = Enumerable.Range(0, count).ToArray <int>();      // array of polygonal number types used
            var setNumberOrder = UtilityString.GeneratePermutations <int>(types); // permutation of the types indicat1ing all combinations of these in a sequence of numbers

            var s = UtilityMath.GetNumericalCyclicalSet(setNumberOrder, numbers);

            var answer = s.set.Sum().ToString();

            var message = string.Format("The sum of the only ordered set of six cyclic 4-digit numbers for which each polygonal type: triangle, square, pentagonal, hexagonal, heptagonal, and octagonal, is represented by a different number in the set is {0}.", answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#10
0
        /// <summary>
        /// https://projecteuler.net/problem=64
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result OddPeriodSquareRoots(Problem arguments)
        {
            var count      = 0;
            var upperBound = arguments.IntNumber;

            for (int n = 2; n <= upperBound; n++)
            {
                if (UtilityMath.IsPerferctSquare(n))
                {
                    continue;
                }

                var p = UtilityMath.GetContinuedFractionExpansionPeriodicLengthForNonPerfectSquare(n);
                if (p % 2 == 1) //only if odd
                {
                    count++;
                }
            }
            var answer = count.ToString();

            var message = string.Format("The number of continued fractions for N ≤ {0} have an odd period is {1}.", upperBound, answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#11
0
        /// <summary>
        /// https://projecteuler.net/problem=75
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result SingularIntegerRightTriangles(Problem arguments)
        {
            var perimeter = arguments.IntNumber;
            var values    = 0;

            var a = UtilityMath.GetPythagoreanTriples_Pitagoras(120, false);

            for (int L = 12; L < perimeter; L++)
            {
                if (GetSingularPythagoreanTriples(L) == 1)
                {
                    values++;
                }
            }

            var answer = values.ToString();

            var message = string.Format("Given that L is the length of the wire, {0} values of L ≤ {1} can form exactly one integer sided right angle triangle.", answer, perimeter);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#12
0
        static void Problem5(ProblemArguments arguments)
        {
            long maximum = arguments.Number;

            int[] multiples = new int[maximum];
            bool  found     = false;
            long  number    = 0;

            for (int i = 1; i <= maximum; i++)
            {
                multiples[i - 1] = i;
            }


            while (!found && number < long.MaxValue)
            {
                if (!found)
                {
                    number += maximum;
                }
                found = UtilityMath.IsMultiple(multiples, number);
            }

            if (found)
            {
                Console.WriteLine("{0} is the smallest positive number that is evenly divisible by {1}", number, string.Join(",", multiples));
            }
            else
            {
                Console.WriteLine("No evenly positive multiple number found.");
            }
        }
示例#13
0
        static void Problem4_1(ProblemArguments arguments)
        {
            long number = 993 * 913;

            if (UtilityMath.IsPalindrome(number))
            {
                Console.WriteLine("x. {0} is palipndrome", number);
            }
        }
示例#14
0
            //Override
            public void updateAIPosition()
            { //get delta x and y for rotating coordinates
                Point position = target.getAbsolutePositionOf(UtilityMath.dividePoint(this.targetPosition, zoomFactor));

                MovingCamera.this.setDX((position.x - MovingCamera.this.getX()) / 30.0);
                MovingCamera.this.setDY((position.y - MovingCamera.this.getY()) / 30.0);

                getAngularComposite().setAngleInRadians(-target.getAngularComposite().getAngleInRadians());

                //zoomFactor = zoom;
            }
示例#15
0
        public static Result PowerDigitSum(Problem arguments)
        {
            var e = Convert.ToInt16(arguments.LongNumber);
            var b = arguments.IntNumber;
            var p = UtilityMath.PowOverflow(b, e);
            var s = UtilityMath.DigitsSum(p);

            var m = string.Format("Sum of digits of {0}^{1} is {2}.", b, e, s);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#16
0
        public static void Main(string[] args)
        {
            //UtilityHelper.Measure(() => SimpleForeach(), true, "Foreach loop:");
            //UtilityHelper.Measure(() => ParallelForeach(2), true, "Parallel Foreach loop:");
            UtilityHelper.Measure(() =>
            {
                var f = UtilityMath.GetFactors(12000).ToArray();
                Array.Sort(f);
                f[0] = 1;
            }, true, "Factor:");

            UtilityHelper.Measure(() => ProductSumNumbers(12000), true, "ProductSumNumbers answer:");
        }
示例#17
0
        private HashSet <int> MakePairs(int a)
        {
            HashSet <int> pairs = new HashSet <int>();

            for (int b = a + 1; b < Primes.Length; b++)
            {
                if (UtilityMath.IsPrimeUsingSquares(UtilityMath.NumericConcat(Primes[a], Primes[b])) &&
                    UtilityMath.IsPrimeUsingSquares(UtilityMath.NumericConcat(Primes[b], Primes[a])))
                {
                    pairs.Add(Primes[b]);
                }
            }
            return(pairs);
        }
示例#18
0
        public static void Problem10(ProblemArguments arguments)
        {
            long sum = 0, limit = arguments.Number;

            for (long i = 2; i <= limit; i++)
            {
                if (UtilityMath.IsPrime(i))
                {
                    sum += i;
                }
            }

            Console.WriteLine("The sum of all the primes below {0} is {1}.", limit, sum);
        }
示例#19
0
        /// <summary>
        /// https://projecteuler.net/problem=59
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result XorDecryption(Problem arguments)
        {
            const char FirstChar = 'a';
            const char LastChar  = 'z';

            var sum  = 0;
            var key  = string.Empty;
            var text = string.Empty;

            var cvsinfo   = arguments.Sequence.Split('|');
            var fileName  = cvsinfo[0];
            var delimiter = Convert.ToChar(cvsinfo[1]);
            var qualifier = Convert.ToChar(cvsinfo[2]);
            var cyphers   = UtilityFile.ReadCsvToArray(fileName, delimiter, qualifier);
            var ascii     = cyphers.Select(X => Convert.ToInt32(X)).ToArray();

            var allPossiblePasswords = (from a in FirstChar.To(LastChar)
                                        from b in FirstChar.To(LastChar)
                                        from c in FirstChar.To(LastChar)
                                        select new[] { Convert.ToInt32(a), Convert.ToInt32(b), Convert.ToInt32(c) }).ToArray();

            foreach (var password in allPossiblePasswords)
            {
                var decrypted = UtilityMath.Encrypt(ascii, password);
                text = new string(decrypted.Select(x => Convert.ToChar(x)).ToArray());

                if (text.Contains(" the ")) //perform simple check: if Text contains single word 'the' it is in english
                {
                    key = new string(password.Select(x => Convert.ToChar(x)).ToArray());
                    break;
                }
            }
            sum = text.Aggregate(0, (runningTotal, next) => runningTotal += next);

            var answer  = sum.ToString();
            var message = string.Format("The sum of the ASCII values in the original English text is {0}.", answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#20
0
        public static Result NumbersToLetters(Problem arguments)
        {
            long sum   = 0;
            long lower = arguments.Numbers[0];
            long upper = arguments.Numbers[1];

            for (long number = lower; number <= upper; number++)
            {
                sum += LengthWordRepresentation(UtilityMath.NumberToLetters(number));
            }

            var m = string.Format("The number of  letters used if all the numbers from {0} to {1} inclusive were written out in words is {2}.", lower, upper, sum);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#21
0
        /// <summary>
        /// For right triangles, using Euclid formula, modified function for problem75
        /// </summary>
        /// <param name="p">Triangle perimeter</param>
        /// <returns></returns>
        private static int GetSingularPythagoreanTriples(long p)
        {
            var count = 0;

            var  bound = (long)Math.Sqrt(p / 2);
            long m;

            for (m = 2; m <= bound; m++)
            {
                if ((p / 2) % m == 0)
                { // m found
                    long k;
                    if (m % 2 == 0)
                    { // ensure that we find an odd number for k
                        k = m + 1;
                    }
                    else
                    {
                        k = m + 2;
                    }
                    while (k < 2 * m && k <= p / (2 * m))
                    {
                        if (p / (2 * m) % k == 0 && UtilityMath.EuclidianGCD(k, m) == 1)
                        {
                            long d = p / 2 / (k * m);
                            long n = k - m;
                            long a = d * (m * m - n * n);
                            long b = 2 * d * n * m;
                            long c = d * (m * m + n * n);

                            if (a + b + c == p)
                            {
                                count++;
                            }

                            // only consider those which only have one combination
                            if (count > 1)
                            {
                                return(0);
                            }
                        }
                        k += 2;
                    }
                }
            }
            return(count);
        }
示例#22
0
        public static void Problem12(ProblemArguments arguments)
        {
            long count              = arguments.Number;
            long number             = (long)Math.Pow((double)count, 2);
            long number_of_divisors = 0;

            do
            {
                number++;
                if (UtilityMath.IsTriangularNumber(number))
                {
                    number_of_divisors = 0;// UtilityMath.NumberOfDivisor(number);
                }
            } while (number_of_divisors < count);

            Console.WriteLine("The value of the first triangle number to have over {0} divisors is {1}.", count, number);
        }
示例#23
0
        static Result LargestPalindromeProduct(Problem arguments)
        {
            long   digits = arguments.LongNumber;
            long   limit = (long)Math.Pow(10, digits) - 1;
            long   number = 0;
            long   i, j, pi = 0, pj = 0;
            bool   found      = false;
            long   palindrome = UtilityMath.GenericLimit <long> .MinValue;
            string m;

            i = limit;
            j = limit;

            while (i > Math.Pow(10, digits - 1))
            {
                j = limit;
                while (!found && j > Math.Pow(10, digits - 1))
                {
                    number = i * j;
                    found  = UtilityMath.IsPalindrome(number);

                    j--;
                }
                i--;
                if (found && number > palindrome)
                {
                    pi         = i + 1;
                    pj         = j + 1;
                    palindrome = number;
                    found      = false;
                }
            }

            if (palindrome == UtilityMath.GenericLimit <long> .MinValue && i == Math.Pow(10, digits - 1) && j == Math.Pow(10, digits - 1))
            {
                m = string.Format("No palindrome found");
            }
            else
            {
                m = string.Format("The largest palindrome made from the product of two 3-digit numbers is {0} = {1} x {2}", palindrome, pi, pj);
            }

            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#24
0
        public static Result SummationOfPrimes(Problem arguments)
        {
            long sum = 0, limit = arguments.LongNumber;

            for (long i = 2; i <= limit; i++)
            {
                if (UtilityMath.IsPrime(i))
                {
                    sum += i;
                }
            }

            var m = string.Format("the sum of all the primes below {0} is {1}.", limit, sum);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#25
0
        /// <summary>
        /// https://projecteuler.net/problem=68
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result Magic5GonRing(Problem arguments)
        {
            var n          = arguments.ListOfNumbers;
            var ringSize   = arguments.IntNumber;
            var sideLength = 3;

            var ring = UtilityMath.GetPentagonalRing(n, sideLength, ringSize);

            // traverse ring in circular index from smaller outer node
            // if iendex go: n, 0, 1,..., n-2, n-1

            var index = new int[ringSize];
            var v     = 0;

            index[0] = ringSize - 1;
            for (var i = 1; i < ringSize; i++)
            {
                index[i] = v;
                v++;
            }

            var builder = new StringBuilder();

            foreach (var i in index)
            {
                var side = ring[i];
                foreach (var d in side)
                {
                    builder.Append(d.ToString());
                }
            }
            string answer  = builder.ToString();
            var    message = string.Format("The maximum 16-digit string for a \"magic\" 5-gon ring is {0}.", answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#26
0
        public static Result LatticePaths(Problem arguments)
        {
            ulong gridSize = arguments.BigNumber;

            var x
                = UtilityMath.FactorialOverFlow(gridSize);
            var y = UtilityMath.FactorialOverFlow(2 * gridSize);

            BigInteger a      = BigInteger.Parse(x);
            BigInteger b      = BigInteger.Parse(y);
            BigInteger n      = BigInteger.Pow(a, 2);
            BigInteger routes = BigInteger.Divide(b, n);

            var m = string.Format("There are {0} route(s) in a {1}x{1} grid.", routes, gridSize);
            var r = new Result(arguments.Id, m);

            return(r);
        }
示例#27
0
        /// <summary>
        /// https://projecteuler.net/problem=58
        /// </summary>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public static Result SpiralPrimes(Problem arguments)
        {
            bool IsPrime(int n)
            {
                return(n != 1 && (n != 3 || n % 3 == 0) && (n != 2 || n % 2 == 0) && UtilityMath.IsPrimeUsingSquares(n));
            }

            double ratio  = 1;
            var    step   = 0;
            var    length = 1;
            var    corner = 1;
            var    count  = 0;

            while (ratio > 0.10)
            {
                length += 2;
                step   += 2;
                for (int i = 1; i < 4; i++)
                // only check primality for three corners, so just skip the southwest corner numbers
                {
                    corner += step;
                    if (IsPrime(corner))
                    {
                        count++;
                    }
                }
                corner += step;

                ratio = (double)count / (2 * length - 1);
            }
            var answer  = length.ToString();
            var message = string.Format("The side length of the square spiral for which the ratio of primes along both diagonals first falls below {0}% is {1}.", ratio * 100, answer);

            if (Answers[arguments.Id] != answer)
            {
                message += string.Format(" => INCORRECT ({0})", Answers[arguments.Id]);
            }
            var r = new Result(arguments.Id, message)
            {
                Answer = answer
            };

            return(r);
        }
示例#28
0
        static void Problem4(ProblemArguments arguments)
        {
            long digits = arguments.Number;
            long limit = (long)Math.Pow(10, digits) - 1;
            long number = 0;
            long i, j, pi = 0, pj = 0;
            bool found      = false;
            long palindrome = UtilityMath.GenericLimit <long> .MinValue;

            i = limit;
            j = limit;

            while (i > Math.Pow(10, digits - 1))
            {
                j = limit;
                while (!found && j > Math.Pow(10, digits - 1))
                {
                    number = i * j;
                    found  = UtilityMath.IsPalindrome(number);

                    j--;
                }
                i--;
                if (found && number > palindrome)
                {
                    pi         = i + 1;
                    pj         = j + 1;
                    palindrome = number;
                    found      = false;
                }
            }

            if (palindrome == UtilityMath.GenericLimit <long> .MinValue && i == Math.Pow(10, digits - 1) && j == Math.Pow(10, digits - 1))
            {
                Console.WriteLine("No palindrome found");
            }
            else
            {
                Console.WriteLine("The largest palindrome made from the product of two 3-digit numbers is {0} = {1} x {2}", palindrome, pi, pj);
            }
            //int digit = sequence[1]-48; //convert character to it's integer representation
        }
示例#29
0
        public Shape getGraphicRelativeRotationalBounds(double graphicsSizeFactorX, double graphicsSizeFactorY, double angleRadians, int areaExtender)
        {
            Rectangle box = new Rectangle();

            int scaledWidth  = (int)(this.getImage().getWidth(null) * graphicsSizeFactorX * this.getSizeFactor());
            int sclaedHeight = (int)(this.getImage().getHeight(null) * graphicsSizeFactorY * this.getSizeFactor());

            box.setSize(
                scaledWidth + areaExtender,
                sclaedHeight + areaExtender);

            box.setLocation(
                (int)((-areaExtender / 2 + this.getOffsetX()) * graphicsSizeFactorX * this.getSizeFactor()),
                (int)((-areaExtender / 2 + this.getOffsetY()) * graphicsSizeFactorY * this.getSizeFactor())
                );

            Point[] cornersArray = new Point[] {
                new Point((int)box.getMinX(), (int)box.getMinY()),
                new Point((int)box.getMaxX(), (int)box.getMinY()),
                new Point((int)box.getMaxX(), (int)box.getMaxY()),
                new Point((int)box.getMinX(), (int)box.getMaxY())
            };

            int[] newCornersX = new int[cornersArray.length];
            int[] newCornersY = new int[cornersArray.length];

            for (int i = 0; i < cornersArray.length; ++i)
            {
                Point rotatedCorner = UtilityMath.getRotationalAbsolutePositionOf(cornersArray[i], angleRadians);
                newCornersX[i] = rotatedCorner.x;
                newCornersY[i] = rotatedCorner.y;
            }

            Shape rotatedRectangle = new Polygon(newCornersX, newCornersY, newCornersX.length);


            box.setLocation(
                (int)((-areaExtender / 2 + this.getOffsetX()) * graphicsSizeFactorX * this.getSizeFactor()),
                (int)((-areaExtender / 2 + this.getOffsetY()) * graphicsSizeFactorY * this.getSizeFactor())
                );
            return(rotatedRectangle);
        }
示例#30
0
        public static Result DivisibleTriangularNumber(Problem arguments)
        {
            long count              = arguments.LongNumber;
            long number             = (long)Math.Pow((double)count, 2);
            long number_of_divisors = 0;

            do
            {
                number++;
                if (UtilityMath.IsTriangularNumber(number))
                {
                    number_of_divisors = 0;// UtilityMath.NumberOfDivisor(number);
                }
            } while (number_of_divisors < count);

            var m = string.Format("The value of the first triangle number to have over {0} divisors is {1}.", count, number);
            var r = new Result(arguments.Id, m);

            return(r);
        }