C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
					
public class Program
{
	public static void Main()
	{
		int[][] validBoard = new int[][] 
		{
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 0, 0, 0, 0, 0 }
		};
		
		int[][] validBoard2 = new int[][] 
		{
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 0, 1, 1, 1, 0 },
			new int[] { 0, 0, 1, 1, 0 },
			new int[] { 0, 0, 0, 0, 0 }
		};
		
		int[][] validBoard3 = new int[][] 
		{
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 1, 1, 1, 1, 0 },
			new int[] { 1, 0, 0, 0, 0 },
			new int[] { 0, 0, 1, 1, 1 }
		};
		
		int[][] validBoard4 = new int[][] 
		{
			new int[] { 1, 0, 0, 0, 1 },
			new int[] { 1, 0, 1, 0, 1 },
			new int[] { 1, 0, 1, 0, 1 },
			new int[] { 0, 0, 1, 0, 0 }
		};
		
		int[][] validBoard5 = new int[][] 
		{
			new int[] { 1, 0, 0, 0, 1, 0, 0 },
			new int[] { 1, 0, 1, 0, 1, 0, 0 },
			new int[] { 1, 0, 1, 0, 1, 0, 0 },
			new int[] { 0, 0, 1, 0, 0, 0, 0 }
		};
		
		int[][] invalidBoard = new int[][] 
		{
			new int[] { 1, 1, 1, 1, 1 },
			new int[] { 1, 1, 1, 1, 1 },
			new int[] { 1, 1, 1, 1, 1 },
			new int[] { 1, 1, 1, 1, 1 }
		};
		
		int[][] invalidBoard2 = new int[][] 
		{
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 1, 1, 1, 1, 0 },
			new int[] { 0, 0, 1, 1, 0 },
			new int[] { 0, 1, 0, 0, 0 }
		};
		
		int[][] invalidBoard3 = new int[][] 
		{
			new int[] { 0, 0, 0, 0, 0 },
			new int[] { 1, 1, 1, 1, 0 },
			new int[] { 1, 0, 0, 1, 0 },
			new int[] { 0, 0, 1, 0, 0 }
		};
		
		int[][] invalidBoard4 = new int[][] 
		{
			new int[] { 1, 0, 0, 1, 0 },
			new int[] { 1, 0, 0, 1, 1 },
			new int[] { 1, 0, 0, 0, 1 },
			new int[] { 0, 0, 0, 0, 0 }
		};
		
		Console.WriteLine("Should be True:  " + IsBoardValid(validBoard));
		Console.WriteLine("Should be True:  " + IsBoardValid(validBoard2));
		Console.WriteLine("Should be True:  " + IsBoardValid(validBoard3));
		Console.WriteLine("Should be True:  " + IsBoardValid(validBoard4));
		//Console.WriteLine("Should be True:  " + IsBoardValid(validBoard5));
		
		Console.WriteLine("");
		
		Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));	
		Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));	
		Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));	
		Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));	
	}
	
	public static bool IsBoardValid(int[][] board) {
		
		// Assumptions: 
		// an array of arrays of integers is passed in.
		// all the arrays within the array have the same count of elements.
		// all the values are either 0 or 1.
		// 0 = open white space
		// 1 = closed black space
		
		// Algorithm:
		// Find the top-left most sqare that is valid and begin the following process:
			// Step 1: Look at adjacent squares in this order: right, down, left, up.
			// Step 2: If a square you look at is white and hasn't been seen yet, you move to that square and start step one. Increase a counter by 1 (to keep track of all the white sqaures you see)
			// Step 3: If you can't move to a square with the criteria in step 2, you repeat step 2 with the opposite ordering without needing to worry about if the square hasn't been seen.
				// Step 3b: do not repeat the same moves over and over.... (still working on this part.)
		
		// If you get to a point where there is no white squares you can move to: AND the # of white squares seen + number of black squares == count of all elements... the board is valid. 
		// If you get to a point where there is no white squares you can move to: AND the # of white squares seen + number of black squares != count of all elements... the board is invalid. 
		
		
		int numAllElements = board.Length * board[0].Length;
		int numOfWhiteElementsForValidBoard = GetNumOfWhiteElementsForValidBoard(numAllElements, board);

		int x = 0;
		int y = 0;
		
		// Find the starting position (top-left most white square)
		while (board[y][x] != 0)
		{
			if (x < board[y].Length - 1)
				x++;
			else {
				x = 0;
				if (y < board.Length - 1)
					y++;
				else
					return false; // board is all 1's, which is invalid.
			}
		}
		
		int prev_x = x;
		int prev_y = y;
		int numOfWhiteElementsSeen = 1;
		// Start the iterative process of the algorithm.
		while (numOfWhiteElementsSeen < numOfWhiteElementsForValidBoard)
		{
			// Look right
			if (x+1 != board[y].Length && board[y][x+1] == 0)
			{
				prev_x = x;
				x++;
				board[y][x] = 2; // I will use the integer value of 2 to mean that we have a white square that we have seen.
				numOfWhiteElementsSeen++;
				continue;
			}
				
			// Look down
			if (y+1 != board.Length && board[y+1][x] == 0)
			{
				prev_y = y;
				y++;
				board[y][x] = 2;
				numOfWhiteElementsSeen++;
				continue;
			}
			
			// Look left
			if (x-1 >= 0 && board[y][x-1] == 0)
			{
				prev_x = x;
				x--;
				board[y][x] = 2; // I will use the integer value of 2 to mean that we have a white square that we have seen.
				numOfWhiteElementsSeen++;
				continue;
			}
			// Look up
			if (y-1 >= 0 && board[y-1][x] == 0)
			{
				prev_y = y;
				y--;
				board[y][x] = 2;
				numOfWhiteElementsSeen++;
				continue;
			}
			
			// Before moving to a square we've already seen, let's see if we've solved the board at this point.
			if (numOfWhiteElementsSeen == numOfWhiteElementsForValidBoard)
				return true;
			
			// If we don't see a square that we haven't seen, let's move to s sqaure that we have seen instead using the same algorithm in reverse.
			// Look up
			if (y-1 >= 0 && board[y-1][x] == 2)
			{
				prev_y = y;
				y--;
				continue;
			}
			// Look left
			if (x-1 >= 0 && board[y][x-1] == 2)
			{
				prev_x = x;
				x--;
				continue;
			}
			// Look down
			if (y+1 != board.Length && board[y+1][x] == 2)
			{
				prev_y = y;
				y++;
				continue;
			}
			// Look right
			if (x+1 != board[y].Length && board[y][x+1] == 2)
			{
				prev_x = x;
				x++;
				continue;
			}
			
			// Board is false if we reach this point.
			return false;
		}
		
		return true;
	}
	
	// To get the number of white spaces that we need to see:
	// Take the total number of elements and subtract the number of black squares.
	// This is probably not ideal as it requires a full transversal of all the elements...
	// So this could be the first point of improvement in terms of performance...
	public static int GetNumOfWhiteElementsForValidBoard(int numAllElements, int[][] board) {
		int numBlackElements = 0;
		foreach (int[] i in board){
			foreach (int j in i){
				if (j == 1)
					numBlackElements++;
			}
		}
		return (numAllElements - numBlackElements);
	}
}

​x
 
using System;
                    
public class Program
{
    public static void Main()
    {
        int[][] validBoard = new int[][] 
        {
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 0, 0, 0, 0, 0 }
        };
        
        int[][] validBoard2 = new int[][] 
        {
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 0, 1, 1, 1, 0 },
            new int[] { 0, 0, 1, 1, 0 },
            new int[] { 0, 0, 0, 0, 0 }
        };
        
        int[][] validBoard3 = new int[][] 
        {
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 1, 1, 1, 1, 0 },
            new int[] { 1, 0, 0, 0, 0 },
            new int[] { 0, 0, 1, 1, 1 }
        };
        
        int[][] validBoard4 = new int[][] 
        {
            new int[] { 1, 0, 0, 0, 1 },
            new int[] { 1, 0, 1, 0, 1 },
            new int[] { 1, 0, 1, 0, 1 },
            new int[] { 0, 0, 1, 0, 0 }
        };
        
        int[][] validBoard5 = new int[][] 
        {
            new int[] { 1, 0, 0, 0, 1, 0, 0 },
            new int[] { 1, 0, 1, 0, 1, 0, 0 },
            new int[] { 1, 0, 1, 0, 1, 0, 0 },
            new int[] { 0, 0, 1, 0, 0, 0, 0 }
        };
        
        int[][] invalidBoard = new int[][] 
        {
            new int[] { 1, 1, 1, 1, 1 },
            new int[] { 1, 1, 1, 1, 1 },
            new int[] { 1, 1, 1, 1, 1 },
            new int[] { 1, 1, 1, 1, 1 }
        };
        
        int[][] invalidBoard2 = new int[][] 
        {
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 1, 1, 1, 1, 0 },
            new int[] { 0, 0, 1, 1, 0 },
            new int[] { 0, 1, 0, 0, 0 }
        };
        
        int[][] invalidBoard3 = new int[][] 
        {
            new int[] { 0, 0, 0, 0, 0 },
            new int[] { 1, 1, 1, 1, 0 },
            new int[] { 1, 0, 0, 1, 0 },
            new int[] { 0, 0, 1, 0, 0 }
        };
        
        int[][] invalidBoard4 = new int[][] 
        {
            new int[] { 1, 0, 0, 1, 0 },
            new int[] { 1, 0, 0, 1, 1 },
            new int[] { 1, 0, 0, 0, 1 },
            new int[] { 0, 0, 0, 0, 0 }
        };
        
        Console.WriteLine("Should be True:  " + IsBoardValid(validBoard));
        Console.WriteLine("Should be True:  " + IsBoardValid(validBoard2));
        Console.WriteLine("Should be True:  " + IsBoardValid(validBoard3));
        Console.WriteLine("Should be True:  " + IsBoardValid(validBoard4));
        //Console.WriteLine("Should be True:  " + IsBoardValid(validBoard5));
        
        Console.WriteLine("");
        
        Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));   
        Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));   
        Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));   
        Console.WriteLine("Should be False:  " + IsBoardValid(invalidBoard));   
    }
    
    public static bool IsBoardValid(int[][] board) {
        
        // Assumptions: 
        // an array of arrays of integers is passed in.
        // all the arrays within the array have the same count of elements.
        // all the values are either 0 or 1.
        // 0 = open white space
        // 1 = closed black space
        
        // Algorithm:
        // Find the top-left most sqare that is valid and begin the following process:
            // Step 1: Look at adjacent squares in this order: right, down, left, up.
            // Step 2: If a square you look at is white and hasn't been seen yet, you move to that square and start step one. Increase a counter by 1 (to keep track of all the white sqaures you see)
            // Step 3: If you can't move to a square with the criteria in step 2, you repeat step 2 with the opposite ordering without needing to worry about if the square hasn't been seen.
                // Step 3b: do not repeat the same moves over and over.... (still working on this part.)
        
        // If you get to a point where there is no white squares you can move to: AND the # of white squares seen + number of black squares == count of all elements... the board is valid. 
        // If you get to a point where there is no white squares you can move to: AND the # of white squares seen + number of black squares != count of all elements... the board is invalid. 
        
        
        int numAllElements = board.Length * board[0].Length;
        int numOfWhiteElementsForValidBoard = GetNumOfWhiteElementsForValidBoard(numAllElements, board);
​
        int x = 0;
        int y = 0;
        
        // Find the starting position (top-left most white square)
        while (board[y][x] != 0)
        {
            if (x < board[y].Length - 1)
                x++;
            else {
                x = 0;
                if (y < board.Length - 1)
                    y++;
                else
                    return false; // board is all 1's, which is invalid.
            }
        }
        
        int prev_x = x;
        int prev_y = y;
        int numOfWhiteElementsSeen = 1;
        // Start the iterative process of the algorithm.
        while (numOfWhiteElementsSeen < numOfWhiteElementsForValidBoard)
        {
            // Look right
            if (x+1 != board[y].Length && board[y][x+1] == 0)
            {
                prev_x = x;
                x++;
                board[y][x] = 2; // I will use the integer value of 2 to mean that we have a white square that we have seen.
                numOfWhiteElementsSeen++;
                continue;
            }
                
            // Look down
            if (y+1 != board.Length && board[y+1][x] == 0)
            {
                prev_y = y;
                y++;
                board[y][x] = 2;
                numOfWhiteElementsSeen++;
                continue;
            }
            
            // Look left
            if (x-1 >= 0 && board[y][x-1] == 0)
            {
                prev_x = x;
                x--;
                board[y][x] = 2; // I will use the integer value of 2 to mean that we have a white square that we have seen.
                numOfWhiteElementsSeen++;
                continue;
            }
            // Look up
            if (y-1 >= 0 && board[y-1][x] == 0)
            {
                prev_y = y;
                y--;
                board[y][x] = 2;
                numOfWhiteElementsSeen++;
                continue;
            }
            
            // Before moving to a square we've already seen, let's see if we've solved the board at this point.
            if (numOfWhiteElementsSeen == numOfWhiteElementsForValidBoard)
                return true;
            
            // If we don't see a square that we haven't seen, let's move to s sqaure that we have seen instead using the same algorithm in reverse.
            // Look up
            if (y-1 >= 0 && board[y-1][x] == 2)
            {
                prev_y = y;
                y--;
                continue;
            }
            // Look left
            if (x-1 >= 0 && board[y][x-1] == 2)
            {
                prev_x = x;
                x--;
                continue;
            }
            // Look down
            if (y+1 != board.Length && board[y+1][x] == 2)
            {
                prev_y = y;
                y++;
                continue;
            }
            // Look right
            if (x+1 != board[y].Length && board[y][x+1] == 2)
            {
                prev_x = x;
                x++;
                continue;
            }
            
            // Board is false if we reach this point.
            return false;
        }
        
        return true;
    }
    
    // To get the number of white spaces that we need to see:
    // Take the total number of elements and subtract the number of black squares.
    // This is probably not ideal as it requires a full transversal of all the elements...
    // So this could be the first point of improvement in terms of performance...
    public static int GetNumOfWhiteElementsForValidBoard(int numAllElements, int[][] board) {
        int numBlackElements = 0;
        foreach (int[] i in board){
            foreach (int j in i){
                if (j == 1)
                    numBlackElements++;
            }
        }
        return (numAllElements - numBlackElements);
    }
}

'abc=' -> [105, 183]
'abc==' -> [109]

Last Run:	9:05:37 am
Compile:	0.113s
Execute:	0s
Memory:	0b
CPU:	0.016s

View IL Code