public IEnumerable <int[]> GetAdjacentIntegers(GridAdjacentIntegerWindow gridWindow)
        {
            ArgumentCheck.IsNull(gridWindow, nameof(gridWindow));

            int[] current = new int[gridWindow.WindowSize];
            for (int i = 0; i < gridWindow.WindowSize; i++)
            {
                current[i] = gridWindow.GridData[gridWindow.MinY + i][gridWindow.MaxX - i];
            }

            yield return(current);
        }
        public void Should_return_max_product_of_3_ints_When_the_max_product_is_right_down()
        {
            var gridWindow = new GridAdjacentIntegerWindow(new int[][]
            {
                new int[] { 7, 2, 3 },
                new int[] { 4, 8, 6 },
                new int[] { 1, 5, 9 },
            }, 0, 0, 3);

            var expectedCount = 504;

            productGridVisitor.VisitGridWindow(gridWindow);

            Assert.AreEqual(expectedCount, productGridVisitor.LargestProduct);
        }
Esempio n. 3
0
        public void Should_return_count_of_16_for_adjacent_ints_When_all_values_are_distinct_in_3x3()
        {
            var gridWindow = new GridAdjacentIntegerWindow(new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5, 6 },
                new int[] { 7, 8, 9 },
            }, 0, 0, 3);

            var expectedCount = 16;

            distinctAdjacentGridVisitor.VisitGridWindow(gridWindow);

            Assert.AreEqual(expectedCount, distinctAdjacentGridVisitor.GetDistinctCount());
        }
Esempio n. 4
0
        public void Should_return_count_of_one_for_adjacent_ints_When_all_values_are_same()
        {
            var gridWindow = new GridAdjacentIntegerWindow(new int[][]
            {
                new int[] { 1, 1, 1 },
                new int[] { 1, 1, 1 },
                new int[] { 1, 1, 1 },
            }, 0, 0, 3);

            var expectedCount = 1;

            distinctAdjacentGridVisitor.VisitGridWindow(gridWindow);

            Assert.AreEqual(expectedCount, distinctAdjacentGridVisitor.GetDistinctCount());
        }
Esempio n. 5
0
        public void VisitGridWindow(GridAdjacentIntegerWindow gridWindow)
        {
            ArgumentCheck.IsNull(gridWindow, nameof(gridWindow));

            var max = _upAdjacentGridIntegers.GetAdjacentIntegers(gridWindow)
                      .Concat(_rightAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                      .Concat(_rightUpAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                      .Concat(_rightDownAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                      .Select(Product)
                      .Max();

            if (max > LargestProduct)
            {
                LargestProduct = max;
            }
        }
        public void VisitGridWindow(GridAdjacentIntegerWindow gridWindow)
        {
            ArgumentCheck.IsNull(gridWindow, nameof(gridWindow));

            var distinct = _upAdjacentGridIntegers.GetAdjacentIntegers(gridWindow)
                           .Concat(_downAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_leftAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_rightAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_leftUpAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_leftDownAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_rightUpAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Concat(_rightDownAdjacentGridIntegers.GetAdjacentIntegers(gridWindow))
                           .Select(a => Tuple.Create(a[0], a[1], a[2]))
                           .Distinct();

            _distinct3Adjacent.AddRange(distinct);
        }
        public void Should_return_all_right_up_adjacent_integers_When_iterated_with_max_width()
        {
            var gridwindow = new GridAdjacentIntegerWindow(new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5, 6 },
                new int[] { 7, 8, 9 },
            }, 0, 0, 3);

            var expectedAdjacentValues = new int[][]
            {
                new int[] { 7, 5, 3 },
            };

            var actualAdjacentValues = rightUpAdjacentGridIntegers
                                       .GetAdjacentIntegers(gridwindow)
                                       .ToArray();

            AssertEx.AreEqual(expectedAdjacentValues, actualAdjacentValues);
        }
        public void Should_return_all_left_down_adjacent_integers_When_iterated()
        {
            var gridwindow = new GridAdjacentIntegerWindow(new int[][]
            {
                new int[] { 1, 2, 3 },
                new int[] { 4, 5, 6 },
                new int[] { 7, 8, 9 },
            }, 0, 0, 3);

            var expectedAdjacentValues = new int[][]
            {
                new int[] { 3, 5, 7 },
            };

            var actualAdjacentValues = leftDownAdjacentGridIntegers
                                       .GetAdjacentIntegers(gridwindow)
                                       .ToArray();

            AssertEx.AreEqual(expectedAdjacentValues, actualAdjacentValues);
        }