using System;

using System.Collections.Generic;

public class Program {

    const int MINIMUM_MATCH_COUNT = 3;

    const int MAX_DIMENSION_X = 8;

    const int MAX_DIMENSION_Y = 8;

    const int MIN_BOARD_VALUE = 0;

    const int MAX_BOARD_VALUE = 7;

​

    public static void Main() {

        //int[,] board = CreateRandomFilledBoard();

        int[,] board = {

            { 1,1,1,1,2,3,4,5 },

            { 1,0,6,4,2,3,4,5 },

            { 1,1,2,3,3,4,5,6 },

            { 2,3,4,5,5,6,3,2 },

            { 2,3,4,5,5,6,3,2 },

            { 3,4,5,7,6,3,2,1 },

            { 4,5,7,6,3,2,1,0 },

            { 1,4,5,7,6,3,2,1 }

        };

​

        Console.WriteLine("Board: ");

        Console.WriteLine();

        PrintBoard(board);

​

        List<Match> matches = FindMatches(board);

​

        Console.WriteLine();

        foreach (Match match in matches)

            Console.WriteLine(match.Direction + " match at (" + match.IndexX + "," + match.IndexY + ") Length: " + match.Length);

        if (matches.Count == 0)

            Console.WriteLine("No matches.");

    }

​

    private static List<Match> FindMatches(int[,] board) {

        List<Match> matches = new List<Match>();

​

        for (int y = 0; y < board.GetLength(1); y++) {

            for (int x = 0; x < board.GetLength(0); x++) {

                Match match = FindMatchForVertical(board, x, y);

​

                if (match != null)

                    matches.Add(match);

​

                match = FindMatchForHorizontal(board, x, y);

​

                if (match != null) {

                    matches.Add(match);

                    y += match.Length - 1;

                }

            }

        }

​

        return matches;

    }

​

    // search horizontal

    private static Match FindMatchForHorizontal(int[,] board, int xIndex, int yIndex) {

        int searchValue = board[xIndex, yIndex];

        int remainingIndexCount = (board.GetLength(0) - xIndex) - 1;

        if (remainingIndexCount >= (MINIMUM_MATCH_COUNT - 1)) {

            int length = 1;

            for (int i = 0; i < remainingIndexCount; ++i) {

                if (board[xIndex + 1 + i, yIndex] == searchValue)

                    length++;

                else {

                    if (length >= MINIMUM_MATCH_COUNT)

                        return new Match(xIndex, yIndex, length, Match.MatchDirection.Horizontal);

​

                    break;

                }

            }

        }

        return null;

    }

​

    // search vertical

    private static Match FindMatchForVertical(int[,] board, int xIndex, int yIndex) {

        int searchValue = board[xIndex, yIndex];

        int remainingIndexCount = (board.GetLength(1) - yIndex) - 1;

        for (int y = yIndex; y < board.GetLength(1); y++) {

            int length = 1;

            for (int i = 0; i < remainingIndexCount; i++) {

                if (board[xIndex, yIndex + 1 + i] == searchValue)

                    length++;

                else {

                    if (length >= MINIMUM_MATCH_COUNT)

                        return new Match(xIndex, yIndex, length, Match.MatchDirection.Vertical);

​

                    break;

                }

            }

        }

​

        return null;

    }

​

    private static void PrintBoard(int[,] board) {

        Console.Write("   ");

        for (int x = 0; x < board.GetLength(0); x++)

            Console.Write(" " + x);

        Console.WriteLine();

        Console.Write(" --");

        for (int x = 0; x < board.GetLength(0); x++) 

            Console.Write("--");

        Console.WriteLine();

        for (int y = 0; y < board.GetLength(1); y++) {

            Console.Write(y + "| ");

            for (int x = 0; x < board.GetLength(0); x++)

                Console.Write(" " + board[x, y]);

​

            Console.Write(" ");

            Console.WriteLine();

        }

    }

​

    private class Match {

        public enum MatchDirection {

            Horizontal,

            Vertical

        }

        public Match(int IndexX, int IndexY, int Length, MatchDirection Direction) {

            this.IndexX = IndexX;

            this.IndexY = IndexY;

            this.Length = Length;

            this.Direction = Direction;

        }

​

        public int IndexX { get; }

​

        public int IndexY { get; }

​

        public int Length { get; }

​

        public MatchDirection Direction { get; }

​

    }

​

    private static int[,] CreateRandomFilledBoard() {

        int[,] board = new int[MAX_DIMENSION_X, MAX_DIMENSION_Y];

​

        Random random = new Random(Guid.NewGuid().GetHashCode() + Environment.TickCount);

​

        for (int i = 0; i < board.GetLength(0); i++)

            for (int j = 0; j < board.GetLength(1); j++)

                board[i, j] = random.Next(MIN_BOARD_VALUE, MAX_BOARD_VALUE + 1);

        return board;

    }

}