How to examine an Array for .Text values

Question

This is for a tic tac toe game where the grid can be sized to any number (3x3 4x4 8x8 etc)

When the form loads, a method reads the grid size and populates the form with that many buttons in a 1 dimensional Button Array. The Array is called buttonArray.

With just using the 1-dimensional buttonArray and without using LINQ, how can i compare the .Text values of buttons in buttonArray to see if they are either "X" or "O" for a CheckWinner() function.

After the button grid is created, I have an event handler for button clicks :

private void button_click(object sender, EventArgs e)
    {
        Button b = (Button)sender;
        b.Text = "X";
        b.Enabled = false;
        CheckWinner(buttonArray);
} 

I am then calling my CheckWinner function and passing in the array buttonArray.

Again, I am just looking for a primitive way to check/compare values without using LINQ. If I know the length of each side of the grid, I can say that for Horizontal win lines, I am looking for that many buttons in a row with "X" as their .Text property.

So if I have a grid of 5x5, and I have 25 buttons in buttonArray, how can i check every 5 starting at the 0 index of the grid for their .Text values being "X" and then print a message if 5 in a row are the same, or "X" in this case.

for (int z = 0; z < root; z++) //increments the column to start on
        {
            vCount = 0; //Starts the win counter at zero when moving to the next column
            for (int i = z; i < arrLength; i=i+root) //starts at the first column and increments it by root to test the next button in the column
            {
                string bText = buttonArray[i].Text;
                if (bText == "X")
                    vCount++;
                if (vCount == root)
                {
                    MessageBox.Show("Vertical row winner found !");
                    break;
                }
            }
        }//end of vertical column test

I did the vertical test like that? But I think combining them into one would def be better.

Answer 1

Assuming that you want to check if Button.Text == "X" in every element of a horizontal row. Following is a very basic way...

public void CheckWinner(Buttons[] buttonArray)
{
    int arrLength = buttonArray.Length; 
    int hCount = 0;
    //int vCount = 0;
    int root = (int)Math.Sqrt(Convert.ToDouble(arrLength));  

    for (int i = 0; i < arrLength ; i++)
    { 
        string bText = buttonArray[i].Text;

        hCount = i % root == 0? 0 : hCount;

        if(bText == "X") 
            hCount++;

        if(hCount == root) 
        {
            Console.WriteLine("Horizontal row winner found !");
            break;
        }
    }

}

To check virtical and/or horizontal winner:

public void CheckWinner(Buttons[] buttonArray)
{
    int arrLength = buttonArray.Length; 
    int hCount = 0;
    Int vCount = 0;
    int root = (int)Math.Sqrt(Convert.ToDouble(arrLength));  

    for (int i = 0;  i < root;  i++)
    {
        hCount = 0;
        vCount = 0;
        for(int j = 0;  j < root; j++)
        {
           if(buttonArray[ (i * root) + j ].Text == "X")
              hCount++;

           if(buttonArray[ i + (root * j) ].Text == "X")
              vCount++;
        }

        if( hCount + vCount == 2 * root)
        {
           Console.WriteLine("Horizontal and Virtical winner found !");
           break;
        } 
        else if ( hCount == root )
        { 
           Console.WriteLine("Horizontal winner found !");
           break;
        }
        else if ( vCount == root )
        { 
           Console.WriteLine("Virtical winner found !");
           break;
        }

    }
}

Answer 2

I'll throw my option in to the ring, though it looks like all the other answers work, as well. Mine is a basic implementation. It simply goes along each row, and checks to see if you have the same value in each row. The Vertical version of this is as simple as rearranging my two for-loops, and the diagonal isn't too much harder.

It seems to me that the main trick of this question is just to show an understanding of array row and columns, and how to imitate a 2D array given only a 1D array.

For horizontal:

string CheckWinnerHorizontal(Button[] buttonArray) {
    int N = (int)Math.Sqrt(buttonArray.Length);
    for (int row = 0; row < N; ++row)
    {
        string winner = "";
        for (int col = 0; col < N; ++col)
        {
            string value = buttonArray[row * N + col].Text;
            if (winner == "") { winner = value; }
            else if (winner != value) { winner = "none"; }
        }
        if (winner != "none" && winner != "")
        {
            return winner;
        }
    }
    return "";

Answer 3

Sure, you can give this a shot - I'll do by-rows here, by-cols should be very similar:

(edit - hah, evidently I can't read...but may remain a useful answer for others...since I've already proved I didn't pay attention to the OP, let me expand on that and fill in the vertical/diagonals...)

(LINQPad-ready)

void Main()
{
    // Quickish and very dirty way to generate the grid
    var lineLength = 3;
    var rnd = new Random();
    var gridSrc = 
        from r in Enumerable.Range(0, lineLength)
        from c in Enumerable.Range(0, lineLength)
        select new { Row = r, Col = c, Text = rnd.Next(0,2) > 0 ? "X" : "O" };
    var grid = gridSrc.ToArray();

    // ok, now for the query
    var horizontalWinners =
        // need the cell and it's index - this is one way to do that
        from cellTuple in grid.Select((cell, idx) => Tuple.Create(idx, cell))
        let idx = cellTuple.Item1
        let cell = cellTuple.Item2
        // figure out which row its in
        let row = idx / lineLength
        // figure out which column its in
        let col = idx % lineLength
        // for rows, group by row #
        group cell by row into byRow
        // only count if all cells in that row are same
        where byRow.All(rowCell => rowCell.Text == "X") 
             || byRow.All(rowCell => rowCell.Text == "O")
        // tell us what row (and who won)
        select new { byRow.Key, byRow.First().Text };

var verticalWinners =
    from cellTuple in grid.Select((cell, idx) => Tuple.Create(idx, cell))
    let idx = cellTuple.Item1
    let cell = cellTuple.Item2
    let row = idx / lineLength
    let col = idx % lineLength
    group cell by col into byCol
    where byCol.All(colCell => colCell.Text == "X") 
                 || byCol.All(colCell => colCell.Text == "O")
    select new { byCol.Key, byCol.First().Text };

var topLeftBottomRightDiagonalWinners =
    from cellTuple in grid.Select((cell, idx) => Tuple.Create(idx, cell))
    let idx = cellTuple.Item1
    let cell = cellTuple.Item2
    let row = idx / lineLength
    let col = idx % lineLength
    let fwdSlash = (row == col)
    group cell by fwdSlash into byDiag
    where byDiag.Key && byDiag.All(d => d.Text == byDiag.First().Text)
    select new { 
                 Text = byDiag.First().Text, 
                 Pos = string.Join("", byDiag.Select(c => Tuple.Create(c.Col, c.Row).ToString())) 
            };

var topRightBottomLeftDiagonalWinners =
    from cellTuple in grid.Select((cell, idx) => Tuple.Create(idx, cell))
    let idx = cellTuple.Item1
    let cell = cellTuple.Item2
    let row = idx / lineLength
    let col = idx % lineLength
    let backSlash = (row + col) == (lineLength - 1)
    group cell by backSlash into byDiag     
    where byDiag.Key && byDiag.All(d => d.Text == byDiag.First().Text)
    select new { 
               Text = byDiag.First().Text, 
               Pos = string.Join("", byDiag.Select(c => Tuple.Create(c.Col, c.Row).ToString())) 
            };

for(int r=0;r<lineLength;r++)
{
    for(int c=0;c<lineLength;c++)
    {
        Console.Write(grid[r*lineLength+c].Text + " ");
    }
    Console.WriteLine();
}
foreach(var row in horizontalWinners)
{
    Console.WriteLine("{0} wins on row {1}", row.Text, row.Key);
}
foreach(var col in verticalWinners)
{
    Console.WriteLine("{0} wins on col {1}", col.Text, col.Key);
}
foreach (var diag in topLeftBottomRightDiagonalWinners
                .Concat(topRightBottomLeftDiagonalWinners)) 
{
    Console.WriteLine("{0} wins on diagonal {1}", diag.Text, diag.Pos);     
}
}