Example #1
0
        private void JudegeDestop(int aCard, StackT<int> destop, QueueT<int> aCards)
        {
            int count = 0;
            foreach (var card in destop)
            {
                if (card == aCard)
                {
                    count++;
                }
            }

            var newCards = new List<int>();

            if (count == 2)
            {
                var newFirstCard = destop.Pop();
                newCards.Add(newFirstCard);

                int newCard = 0;
                while ((newCard = destop.Peek()) != newFirstCard)
                {
                    newCards.Add(destop.Pop());
                }
                newCard = destop.Pop();
                newCards.Add(newCard);

                foreach (var card in newCards)
                {
                    if(card == 0) continue;
                    aCards.EnQueue(card);
                    Console.Write(string.Format("Get {0} ", card));
                }
                Console.WriteLine();
            }
        }
        public void QueueTest_CreatingQueueWith3Elements_QueueHas3Element()
        {
            QueueT <string> qeue = new QueueT <string>(new List <string> {
                "asd", "asd", "aaa"
            });

            Assert.AreEqual(3, qeue.Count());
        }
        public void QueueTest_QueueWith1ElementAndDelete2_InvalideOperationException()
        {
            QueueT <CastomForTest> queue = new QueueT <CastomForTest>(1);

            queue.Enqueue(new CastomForTest(1));
            queue.Dequeue();

            Assert.Throws <InvalidOperationException>(() => queue.Dequeue());
        }
        public void QueueTest_Adding3Elements_QueueHas3Element()
        {
            QueueT <int> qeue = new QueueT <int>(1);

            qeue.Enqueue(1);
            qeue.Enqueue(3);
            qeue.Enqueue(3);

            Assert.AreEqual(3, qeue.Count());
        }
Example #5
0
        static void Main(string[] args)
        {
            //1
            //int[] arr = {1,2,5,9,11,55,88,99,152,158,178,199};
            //int element = 152;
            //var index = BinaryGenericSearch.Exec(arr.ToList(),152);
            //System.Console.WriteLine("Элемент {0} находится после позиции {1}",element,index);
            //2
            //string fname = "10.2.SilkRoads1.txt";
            //Dictionary<string, int> result = FrequencyWords.Exec(fname);
            //foreach (var i in result) Console.WriteLine("Word: {0,-20}Freq: {1}", i.Key, i.Value);
            //3
            //int fibNumbers = 0;
            //var sum = Fibonacci.Calc(fibNumbers);
            //Console.WriteLine("Sequence of {0} Fibonacci's numbers is: ", fibNumbers);
            //foreach (var i in sum) Console.Write(i + " ");
            //Console.ReadKey();

            //4
            QueueT <int> myQueue = new QueueT <int>();

            for (int i = 1; i < 5; i++)
            {
                myQueue.Enqueue(i);
            }
            myQueue.Dequeue();
            myQueue.Enqueue(6);
            myQueue.Dequeue();

            for (int i = 0; i < 2; i++)
            {
                myQueue.Enqueue(i);
            }

            //7
            //var bst = new BST<int>();

            //bst.Add(1);
            //bst.Add(2);
            //bst.Add(3);
            //bst.Add(4);
            //bst.Add(5);
            //bst.Remove(2);
            //var result = bst.PreOrder().ToArray();
            //8

            //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            //string rpn = "5 1 2 + 4 * + 3 - ";
            //Console.WriteLine("\n{0}", rpn);
            //decimal result1 = RPMCalc.CalculateRPN(rpn);
            //Console.WriteLine("Result is {0}", result1);
            //Console.ReadKey();
        }
        public void GetQueueEnumerator_TwoStepsAhead_GetCurrentElement_CurrentElementEqual2AddingElementInQueue()
        {
            QueueT <string> queue = new QueueT <string>(new List <string> {
                "a", "ab", "abc", "abcd"
            });
            var enumerator = queue.GetEnumerator();

            enumerator.MoveNext();
            enumerator.MoveNext();

            Assert.AreEqual("ab", enumerator.Current);
        }
        public void QueueTest_Add2ElementsAndTake1_QueueHas1Element()
        {
            QueueT <CastomForTest2> queue =
                new QueueT <CastomForTest2>(new List <CastomForTest2> {
                new CastomForTest2(1),
                new CastomForTest2(2)
            });

            queue.Dequeue();

            Assert.AreEqual(1, queue.Count());
        }
Example #8
0
        public void EnumeratorTest()
        {
            //arrange
            var enumTest = new QueueT <string>();

            //act
            enumTest.Enqueue("First");
            enumTest.Enqueue("Second");
            enumTest.Enqueue("Third");

            //assert
            Assert.AreEqual("First", enumTest.Dequeue());
            Assert.AreEqual("Second", enumTest.Dequeue());
        }
Example #9
0
        public void QueueTStrTests()
        {
            //arrange
            var myqueue = new QueueT <string>();

            //act
            myqueue.Enqueue("0");
            myqueue.Enqueue("1");
            myqueue.Enqueue("2");

            //assert
            Assert.AreEqual("0", myqueue.Dequeue());
            Assert.AreEqual("1", myqueue.Dequeue());
            Assert.AreEqual("2", myqueue.Dequeue());
            Assert.AreEqual(0, myqueue.Count());
        }
Example #10
0
        public void QueueTIntTests()
        {
            //arrange
            var myqueue = new QueueT <int>();

            //act
            myqueue.Enqueue(0);
            myqueue.Enqueue(1);
            myqueue.Enqueue(2);

            //assert
            Assert.AreEqual(0, myqueue.Dequeue());
            Assert.AreEqual(1, myqueue.Dequeue());
            Assert.AreEqual(2, myqueue.Dequeue());
            Assert.AreEqual(0, myqueue.Count());
        }
Example #11
0
        private void JudegeDestop(int aCard, StackT <int> destop, QueueT <int> aCards)
        {
            int count = 0;

            foreach (var card in destop)
            {
                if (card == aCard)
                {
                    count++;
                }
            }

            var newCards = new List <int>();

            if (count == 2)
            {
                var newFirstCard = destop.Pop();
                newCards.Add(newFirstCard);

                int newCard = 0;
                while ((newCard = destop.Peek()) != newFirstCard)
                {
                    newCards.Add(destop.Pop());
                }
                newCard = destop.Pop();
                newCards.Add(newCard);

                foreach (var card in newCards)
                {
                    if (card == 0)
                    {
                        continue;
                    }
                    aCards.EnQueue(card);
                    Console.Write(string.Format("Get {0} ", card));
                }
                Console.WriteLine();
            }
        }
Example #12
0
        public void Test()
        {
            var aCards = new QueueT<int>();
            aCards.EnQueue(2);
            aCards.EnQueue(4);
            aCards.EnQueue(1);
            aCards.EnQueue(2);
            aCards.EnQueue(5);
            aCards.EnQueue(6);

            var bCards = new QueueT<int>();
            bCards.EnQueue(3);
            bCards.EnQueue(1);
            bCards.EnQueue(3);
            bCards.EnQueue(5);
            bCards.EnQueue(6);
            bCards.EnQueue(4);

            var destop = new StackT<int>();

            //Game Start
            while (aCards.Count !=0 && bCards.Count != 0)
            {
                //a pay a card
                var aCard = aCards.DeQueue();
                Console.WriteLine(string.Format("A pay {0}", aCard));
                //a win
                if (aCards.Count == 0)
                {
                    Console.Write("A win!");
                    break;
                }

                //push to destop
                destop.Push(aCard);
                Console.WriteLine(string.Format("Destop get {0}", aCard));
                //jude the destop
                JudegeDestop(aCard, destop, aCards);

                //a pay a card
                var bCard = bCards.DeQueue();
                Console.WriteLine(string.Format("B pay {0}", bCard));
                //a win
                if (bCards.Count == 0)
                {
                    Console.Write("B win!");
                    break;
                }

                //push to destop
                destop.Push(bCard);
                Console.WriteLine(string.Format("Destop get {0}", bCard));
                //jude the destop
                JudegeDestop(bCard, destop, bCards);

            }

            if (aCards.Count == 0)
            {
                Console.WriteLine("A win");
            }
            else
            {
                Console.WriteLine("B win");
            }
        }
        public void GetPeekOfEmptyQueue_InvalidOperationException()
        {
            QueueT <CastomForTest> queue = new QueueT <CastomForTest>(1);

            Assert.Throws <InvalidOperationException>(() => queue.Peek());
        }
        public void IsEmptyTest()
        {
            QueueT <CastomForTest> queue = new QueueT <CastomForTest>(1);

            Assert.IsTrue(queue.IsEmpty());
        }
Example #15
0
        public void Test()
        {
            var aCards = new QueueT <int>();

            aCards.EnQueue(2);
            aCards.EnQueue(4);
            aCards.EnQueue(1);
            aCards.EnQueue(2);
            aCards.EnQueue(5);
            aCards.EnQueue(6);

            var bCards = new QueueT <int>();

            bCards.EnQueue(3);
            bCards.EnQueue(1);
            bCards.EnQueue(3);
            bCards.EnQueue(5);
            bCards.EnQueue(6);
            bCards.EnQueue(4);

            var destop = new StackT <int>();

            //Game Start
            while (aCards.Count != 0 && bCards.Count != 0)
            {
                //a pay a card
                var aCard = aCards.DeQueue();
                Console.WriteLine(string.Format("A pay {0}", aCard));
                //a win
                if (aCards.Count == 0)
                {
                    Console.Write("A win!");
                    break;
                }

                //push to destop
                destop.Push(aCard);
                Console.WriteLine(string.Format("Destop get {0}", aCard));
                //jude the destop
                JudegeDestop(aCard, destop, aCards);

                //a pay a card
                var bCard = bCards.DeQueue();
                Console.WriteLine(string.Format("B pay {0}", bCard));
                //a win
                if (bCards.Count == 0)
                {
                    Console.Write("B win!");
                    break;
                }

                //push to destop
                destop.Push(bCard);
                Console.WriteLine(string.Format("Destop get {0}", bCard));
                //jude the destop
                JudegeDestop(bCard, destop, bCards);
            }

            if (aCards.Count == 0)
            {
                Console.WriteLine("A win");
            }
            else
            {
                Console.WriteLine("B win");
            }
        }
 public RealImplementationandUseClass()
 {
     var q = new QueueT <Car>((c) => c.HP);
 }