示例#1
0
        public void MaxMinElementWorks()
        {
            var list = new List <TestObject>()
            {
                new TestObject()
                {
                    StringProperty = "a",
                    IntProperty    = 1
                },
                new TestObject()
                {
                    StringProperty = "a",
                    IntProperty    = 3
                },
                new TestObject()
                {
                    StringProperty = "a",
                    IntProperty    = -1
                },
                new TestObject()
                {
                    StringProperty = "b",
                    IntProperty    = 2
                }
            };

            list.MaxElement(x => x.IntProperty).Should().Be(list[1]);
            list.MinElement(x => x.IntProperty).Should().Be(list[2]);
        }
示例#2
0
        public void MinMaxElement()
        {
            List <Tuple <int, double> > data = new List <Tuple <int, double> >();

            Assert.AreEqual(null, data.MinElement());
            Assert.AreEqual(null, data.MaxElement());

            data.Add(Tuple.Create(1, 2.3));
            Assert.AreEqual(data[0], data.MinElement());
            Assert.AreEqual(data[0], data.MaxElement());

            data.Add(Tuple.Create(6, 1.3));
            Assert.AreEqual(data[0], data.MinElement());
            Assert.AreEqual(data[1], data.MaxElement());

            Assert.AreEqual(data[1], data.MinElement(p => p.Item2));
            Assert.AreEqual(data[0], data.MaxElement(p => p.Item2));
        }
        static void Main()
        {
            IEnumerable<int> list = new List<int>() { 5, 6, 7, 8, 3, 4, 6, 1 };

            int sum = list.SumOfCollection();
            int product = list.ProductOfCollection();
            int min = list.MinElement();
            int max = list.MaxElement();
            int average = list.AverageOfCollection();

            Console.WriteLine(average);
        }
示例#4
0
        public void MinElemTests()
        {
            List <int> someList = new List <int>()
            {
                3, 2, 1, 6, 5, 4
            };

            var actualMaxElem    = someList.MinElement(x => - x);
            var expecetedMaxElem = 6;

            Assert.AreEqual(expecetedMaxElem, actualMaxElem);
        }
        private static void Main()
        {
            var list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            Console.WriteLine("Sum = {0} ", list.SumElements<int>());
            Console.WriteLine("Product = {0} ", list.ProductElements<int>());
            Console.WriteLine("Min = {0} ", list.MinElement<int>());
            Console.WriteLine("Max = {0} ", list.MinElement<int>());
            Console.WriteLine("Average = {0} ", list.AverageCol<int>());

            Console.WriteLine(new string('*', 30));

            IEnumerable<double> array = new[] { 1.2, 3.4, 5.6 };

            Console.WriteLine("Sum = {0} ", array.SumElements<double>());
            Console.WriteLine("Product = {0:F2} ", array.ProductElements<double>());
            Console.WriteLine("Min = {0} ", array.MinElement<double>());
            Console.WriteLine("Max = {0} ", array.MaxElement<double>());
            Console.WriteLine("Average = {0} ", array.AverageCol<double>());
        }
        private ClusterPointProcessingResult AssignClusterPointToNearestCentroid(ClusterPoint clusterPoint)
        {
            // TODO: Try in-place modification to see the performance impact
            ClusterPoint result = new ClusterPoint(clusterPoint);

            result.CentroidID = centroids.MinElement(centroid => Point.Distance(clusterPoint, centroid)).ID;

            return(new ClusterPointProcessingResult
            {
                Point = result,
                PointWasChanged = clusterPoint.CentroidID != result.CentroidID
            });
        }
        static void Main()
        {
            IEnumerable <int> list = new List <int>()
            {
                5, 6, 7, 8, 3, 4, 6, 1
            };

            int sum     = list.SumOfCollection();
            int product = list.ProductOfCollection();
            int min     = list.MinElement();
            int max     = list.MaxElement();
            int average = list.AverageOfCollection();

            Console.WriteLine(average);
        }
示例#8
0
        public static IUser ParseUser(string userText, IEnumerable <IUser> possibleUsers = null)
        {
            try
            {
                if (userText.Contains('@') && !userText.Contains('<') && !userText.Contains('>'))
                {
                    TwitterUser user = Program.twitterService.GetUserProfileFor(new GetUserProfileForOptions()
                    {
                        ScreenName = userText.Trim(' ', '@')
                    });
                    return(new TwitterDiscordUser(user));
                }
                else if (userText.Contains('@'))
                {
                    return(Program.GetUserFromId(Convert.ToUInt64(userText.Trim(new char[] { ' ', '<', '>', '@', '!' }))));
                }
                else if (userText.Contains('#'))
                {
                    return(possibleUsers.First(x => x.ToString() == userText));
                }
                else if (userText.All(x => char.IsDigit(x)))
                {
                    return(Program.GetUserFromId(ulong.Parse(userText)));
                }
                else
                {
                    List <Tuple <string, IUser> > users = new List <Tuple <string, IUser> >();

                    foreach (var user in possibleUsers)
                    {
                        if (user is SocketGuildUser)
                        {
                            users.Add(new Tuple <string, IUser>((user as SocketGuildUser).Nickname, user));
                        }
                        users.Add(new Tuple <string, IUser>(user.Username, user));
                    }

                    return(users.MinElement(x => userText.ModifiedLevenshteinDistance(x.Item1)).Item2);
                }
            }
            catch
            {
                return(null);
            }
        }
示例#9
0
        public void MinMaxElement()
        {
            List <KeyValuePair <int, int> > list = new List <KeyValuePair <int, int> >
            {
                new KeyValuePair <int, int>(2, 3),
                new KeyValuePair <int, int>(5, 7),
                new KeyValuePair <int, int>(4, 6),
                new KeyValuePair <int, int>(-5, 4)
            };

            KeyValuePair <int, int> min = list.MinElement((kv) => kv.Value);

            Assert.AreEqual(2, min.Key);
            Assert.AreEqual(3, min.Value);

            KeyValuePair <int, int> max = list.MaxElement((kv) => kv.Key);

            Assert.AreEqual(5, max.Key);
            Assert.AreEqual(7, max.Value);
        }
示例#10
0
    protected override void Update()
    {
        base.Update();

        if (Program == null)
        {
            return;
        }

        List <OperationTile>    operation_tiles = OperationTiles;
        IEnumerable <Operation> operations      = operation_tiles.Select(operation_tile => operation_tile.Operation);

        foreach (Operation operation in Program)
        {
            if (!operations.Contains(operation))
            {
                base.Add(OperationTile.Create(operation));
            }
        }

        foreach (OperationTile operation_tile in operation_tiles)
        {
            if (!Program.Contains(operation_tile.Operation))
            {
                base.Remove(operation_tile);
                GameObject.Destroy(operation_tile.gameObject);
            }
        }


        operation_tiles = OperationTiles;
        if (operation_tiles.Count == 0)
        {
            return;
        }

        foreach (Operation operation in Program)
        {
            operation_tiles.Find(operation_tile => operation_tile.Operation == operation)
            .transform.SetAsFirstSibling();
        }

        if (Unit.Program.Next != null)
        {
            OperationTile operation_tile = operation_tiles.Find(operation_tile_ =>
                                                                operation_tile_.Operation == Unit.Program.Next);
            if (operation_tile.IsBeingDragged)
            {
                return;
            }

            Vector3 target_position = arrow.transform.position
                                      .YChangedTo(operation_tile.transform.position.y);

            if (arrow.gameObject.activeSelf)
            {
                arrow.transform.position = Vector3.Lerp(arrow.transform.position,
                                                        target_position,
                                                        4 * Time.deltaTime);
            }
            else
            {
                arrow.transform.position = target_position;
            }

            arrow.gameObject.SetActive(true);
        }
        else
        {
            arrow.gameObject.SetActive(false);
        }


        OperationTile nearest_to_mouse = operation_tiles
                                         .MinElement(operation_tile => operation_tile.MouseDistance);
        bool highlight_nearest = nearest_to_mouse.MouseDistance < Screen.height / 20;

        foreach (OperationTile operation_tile in operation_tiles)
        {
            operation_tile.IsHighlighted = IsOpen &&
                                           highlight_nearest &&
                                           operation_tile == nearest_to_mouse;
        }
    }
示例#11
0
        // 16 - 11237747
        // 32 - 11428838
        // 48 - 11560597
        // 64 - 11629076
        // 96 - 11639283
        // 100 - 11652814
        // 128 - 11563526
        // 158 - 11367549
        static OutputStructure Solve(InputStructure inputStructure, bool metropolisHax = false)
        {
            var os = new OutputStructure();

            var vehicles = new List <Vehicle>();

            for (int i = 0; i < inputStructure.vehiclesNo; i++)
            {
                vehicles.Add(new Vehicle()
                {
                    bonusPointsIfOnTime = inputStructure.perRideBonus, vehicleNo = i
                });
            }

            var allVehiclesAtAll = vehicles.ToList();

            var ridesLeft = inputStructure.rides.ToList();

            List <Ride> ridesForTheEnd = null;

            if (metropolisHax)
            {
                ridesLeft = ridesLeft
                            .Where(x => x.rowStart > 1600)
                            .Where(x => x.rowEnd < 4000)
                            .Where(x => x.colStart > 0)
                            .Where(x => x.colEnd < 2500)
                            .ToList();

                ridesForTheEnd = inputStructure.rides.ToList();
                ridesForTheEnd.RemoveAll(x => ridesLeft.Any(y => x.rideNo == y.rideNo));
            }

            while (ridesLeft.Count > 0 && vehicles.Count > 0)
            {
                var currVehicle    = vehicles.MinElement(x => x.availableAtTime);
                var availableRides = ridesLeft.Where(ride => currVehicle.canFulfill(ride)).ToList();

                if (availableRides.Count == 0 && ridesForTheEnd != null)
                {
                    ridesLeft.AddRange(ridesForTheEnd);
                    availableRides = ridesLeft.Where(ride => currVehicle.canFulfill(ride)).ToList();  // HAX
                    ridesForTheEnd = null;
                }

                if (currVehicle.vehicleNo < 100 && metropolisHax && ridesForTheEnd != null)
                {
                    availableRides = ridesForTheEnd.Where(ride => currVehicle.canFulfill(ride)).ToList();
                }

                if (availableRides.Count == 0)
                {
                    vehicles.Remove(currVehicle);
                    continue;
                }

                var bestRide      = availableRides.MaxElement(ride => ((double)currVehicle.pointsFor(ride)) / currVehicle.timeSpent(ride));
                var pointsForRide = currVehicle.pointsFor(bestRide);
                var timeSpent     = currVehicle.timeSpent(bestRide);

                ridesLeft.Remove(bestRide);
                if (ridesForTheEnd != null)
                {
                    ridesForTheEnd.RemoveAll(x => x.rideNo == bestRide.rideNo);
                }

                if (currVehicle.pointsFor(bestRide) == 0)
                {
                    throw new ApplicationException();
                }

                currVehicle.executeRide(bestRide);
                if (!os.ridesPerVehicle.ContainsKey(currVehicle))
                {
                    os.ridesPerVehicle.Add(currVehicle, new RidesPerVehicle()
                    {
                        vehicle = currVehicle, rides = new List <Ride>()
                    });
                }
                os.ridesPerVehicle[currVehicle].rides.Add(bestRide);
            }

            return(os);
        }
示例#12
0
        static void Main(string[] args)
        {
            /* Substring test*/
            StringBuilder str = new StringBuilder("abcdef");
            StringBuilder substringStr = str.Substring(0, 2);   // substring from 0 to 1
            Console.WriteLine(substringStr.ToString());
            Console.WriteLine("-------------------------");

            /* IEnumerable test */
            List<int> list = new List<int>
            {
                1, 3, 5, 7, 21
            };
            int sum = list.Sum<int>();
            Console.WriteLine("sum =  {0}", sum);
            int product = list.Product<int>();
            Console.WriteLine("product =  {0}", product);
            int max = list.MaxElement<int>();
            Console.WriteLine("max = {0}", max);
            int min = list.MinElement<int>();
            Console.WriteLine("min = {0}", min);    // TODO Fix min = 0
            int avg = list.Average<int>();
            Console.WriteLine("avg = {0}", avg);    // TODO Fix avg = 0
            Console.WriteLine("-------------------------");

            /* First before last test */
            Student[] arrayOfStudents = new Student[]
            {
                new Student("Pesho", "Toshev", 72),
                new Student("Pesho", "Goshev", 21),
                new Student("Pesheto", "Peshev", 19),
                new Student("Peneto", "Oshev", 17),
                new Student("Gosho", "Peshev", 32)
            };
            Student[] array = LINQMethods.FirstBeforeLastName(arrayOfStudents);
            foreach (var student in array)
            {
                Console.WriteLine(student.ToString());
            }
            Console.WriteLine("-------------------------");

            /* Age Range Test*/
            string[] students = LINQMethods.AgeRange(arrayOfStudents);
            foreach (var student in students)
            {
                Console.WriteLine(student);
            }
            Console.WriteLine("-------------------------");

            /* Order Student */
            array = LINQMethods.OrderStudents(arrayOfStudents);
            foreach (var student in array)
            {
                Console.WriteLine(student.ToString());
            }
            Console.WriteLine("-------------------------");

            /* Divisible by 7 and 3 */
            LINQMethods.PrintNumsDivisibleBy7And3(list.ToArray());
            Console.WriteLine("-------------------------");

            //  ////////////////////////////////////////  7 and 8

            /* Student groups */
            List<Student> listOfStudents = new List<Student>
            {
                new Student("Name5", "Namov", 34, "1211", "02000s", "*****@*****.**", new List<int> { 5, 6, 4 }, 2, new Group(1, "Math")),
                new Student("Name2", "Namov2", 3, "1211", "000s", "*****@*****.**", new List<int> { 5, 6, 4 }, 2, new Group(2, "Sport")),
                new Student("Name3", "Namov3", 4, "1211", "000s", "*****@*****.**", new List<int> { 5, 6, 4 }, 1, new Group(1, "Math")),
                new Student("Name4", "Namov4", 11, "1211", "02000s", "*****@*****.**", new List<int> { 5, 6, 4 }, 12, new Group(3, "Biology")),
                new Student("Name", "Namov5", 20, "1211", "000s", "*****@*****.**", new List<int> { 5, 6, 4 }, 2, new Group(1, "Math"))
            };
            Student[] newArrOfStudents = LINQMethods.StudentsGroup(listOfStudents);
            foreach (Student student in newArrOfStudents)
            {
                Console.WriteLine(student.ToStringAll());
            }
            Console.WriteLine("-------------------------");

            //// 10

            /* Extract students by email */
            newArrOfStudents = LINQMethods.ExtractStudentsByEmail(listOfStudents);
            foreach (Student student in newArrOfStudents)
            {
                Console.WriteLine(student.ToStringAll());
            }
            Console.WriteLine("-------------------------");

            /* Extract students by phone */
            newArrOfStudents = LINQMethods.ExtractStudentsByPhone(listOfStudents);
            foreach (Student student in newArrOfStudents)
            {
                Console.WriteLine(student.ToStringAll());
            }
            Console.WriteLine("-------------------------");

            //////// 14, 15

            /* Infinite Convergent Series */
            double precision = 0.001;

            Console.WriteLine("1 + 1/2 + 1/4 + 1/8 + 1/16 + ... = {0:f2}", InfiniteConvergentSeries.ConvergentSum(i => 1.0 / Math.Pow(2, i), precision));
            Console.WriteLine("1 + 1/2! + 1/3! + 1/4! + 1/5! + ... = {0:f2}", InfiniteConvergentSeries.ConvergentSum(i => 1.0 / InfiniteConvergentSeries
                                                                                                                                        .Factorial(i + 1), precision));
            Console.WriteLine("1 + 1/2 - 1/4 + 1/8 - 1/16 + ... = {0:f2}", InfiniteConvergentSeries.ConvergentSum(i => i == 0 ? 1 : -1.0 / Math.Pow(-2, i), precision));
            Console.WriteLine("-------------------------");

            /* Timer */
            TimerDelegate timerDelegate = new TimerDelegate(1, test);
            Console.WriteLine("-------------------------");
        }
示例#13
0
        private void Analyze()
        {
            _Descriptions = new Dictionary <string, Tuple <int, float> >();
            for (int ii = 0; ii < _Transactions.Count; ++ii)
            {
                var transaction = _Transactions[ii];
                if (!_Categories.Contains(transaction.Category) && transaction.Category != "Payment")
                {
                    _Categories.Add(transaction.Category);
                }

                string desc = transaction.Description.ToLower();
                //Try categorize based on keywords
                if (transaction.Category == "Unknown")
                {
                    foreach (string keyword in _Keywords.Keys)
                    {
                        if (desc.Contains(keyword.ToLower()))
                        {
                            transaction.Category = _Keywords[keyword];
                        }
                    }
                }

                //Count expenses based on equal keywords
                Tuple <int, float> descData;
                if (_Descriptions.TryGetValue(desc, out descData))
                {
                    _Descriptions[desc] = new Tuple <int, float>(descData.Item1 + 1, descData.Item2 + transaction.Amount);
                }
                else
                {
                    _Descriptions.Add(desc, new Tuple <int, float>(1, transaction.Amount));
                }
            }

            Dictionary <string, float> categoryExpense = _Categories.ToDictionary(c => c, c => 0.0f);

            foreach (Transaction t in _Transactions)
            {
                if (_Categories.Contains(t.Category))
                {
                    categoryExpense[t.Category] += t.Amount;
                }
            }

            _Chart.Series[0].Points.Clear();
            foreach (var kvp in categoryExpense)
            {
                _Chart.Series[0].Points.AddXY(string.Format("{0} ({1})", kvp.Key, kvp.Value.ToString("0.00")), kvp.Value);
            }

            tbRecurrents.Text = string.Join(Environment.NewLine,
                                            _Descriptions
                                            .OrderByDescending(kvp => kvp.Value)
                                            .Take(10)
                                            .Select(kvp => string.Format("{0} {1} {2}",
                                                                         kvp.Key.PadRight(35),
                                                                         kvp.Value.Item1.ToString().PadRight(6),
                                                                         kvp.Value.Item2.ToString("0.00"))));

            List <Transaction> expenses = _Transactions.Where(t => t.Amount > 0).ToList();

            float total   = expenses.Sum(t => t.Amount);
            float average = expenses.Average(t => t.Amount);

            Trace.Assert(Math.Abs(total / expenses.Count - average) < 0.001);

            tbAverageExpense.Text = average.ToString("0.00");

            List <float> dailyExpense = new List <float>();
            DateTime     currentDate  = _Transactions.First().Date.AddDays(-1);

            foreach (Transaction t in expenses)
            {
                if (t.Date > currentDate)
                {
                    dailyExpense.Add(t.Amount);
                    currentDate = t.Date;
                }
                else if (t.Date == currentDate)
                {
                    dailyExpense[dailyExpense.Count - 1] += t.Amount;
                }
            }

            Trace.Assert(Math.Abs(total - dailyExpense.Sum()) < 0.001);

            tbDailyAverage.Text = dailyExpense.Average().ToString("0.00");

            Transaction max = expenses.MaxElement(t => t.Amount);
            Transaction min = expenses.MinElement(t => t.Amount);

            tbMax.Text = string.Format("{0} {1}", max.Description.PadRight(20), max.Amount.ToString("0.00"));
            tbMin.Text = string.Format("{0} {1}", min.Description.PadRight(20), min.Amount.ToString("0.00"));

            _BeginDate = _Transactions.First().Date;
            _EndDate   = _Transactions.Last().Date;

            tbExpenseBegin.Tag = _BeginDate;
            tbExpenseEnd.Tag   = _EndDate;
            UpdateRangeTextBoxesFromTag();
        }