C#

copy /y NUL YourFileName.txt > NUL

for (int row = 0; row < MAXROWS; ++row)
{
    for (int column = 0; column < MAXCOLUMNS; ++column)
    {
        // square[row][column] is the logical location of each square in the board.
        // You can calculate screen position by multiplying each index by the
        // appropriate number of pixels in the side of a square
    }
}

Quote:

the trick to getting it to work is dividing the square numbers in even rows by 6 and the remainder is the column number of that square number, then for the odd row's you just get the remainder of them but depending on what the remainder is, will determine what column they are, like if(squarenum % 6 == 0) then column is 5
and to find the row numbers you just use division by 6 aswell, like each 6 times you go through the loop go up(or down) a row

/// <summary>
       /// For a given square number, tells you the corresponding row and column numbers.
       /// Pre:  none.
       /// Post: returns the row and column numbers, via "out" parameters.
       /// </summary>
       /// <param name="squareNumber">The input square number.</param>
       /// <param name="rowNumber">The output row number.</param>
       /// <param name="columnNumber">The output column number.</param>
       private static void MapSquareNumToScreenRowAndColumn(int squareNumber, out int rowNumber, out int columnNumber){

           // ######################## Add more code to this method and replace the next two lines by something more sensible.  ###############################
           rowNumber = 0; // Use 0 to make the compiler happy for now.
           columnNumber = 0; // Use 0 to make the compiler happy for now.

           columnNumber = squareNumber % 6;
           rowNumber = squareNumber/6;

           //switch statement for assigning column values to odd rows
           int remainder = squareNumber%6;
           switch (remainder){
               case 0:
                   columnNumber = 5;
                   break;
               case 1:
                   columnNumber = 4;
                   break;
               case 2:
                   columnNumber = 3;
                   break;
               case 3:
                   columnNumber = 2;
                   break;
               case 4:
                   columnNumber = 1;
                   break;
               case 5:
                   columnNumber = 0;
                   break;

           }

           if (squareNumber >=0 && squareNumber <= 5){
               rowNumber = 6;
               columnNumber = squareNumber%6;

           }

           if (squareNumber >=6 && squareNumber <= 11){
               rowNumber = 5;
           }

           if (squareNumber >=12 && squareNumber <= 17){
               rowNumber = 4;
               columnNumber = squareNumber%6;
           }
           if (squareNumber >=18 && squareNumber <= 23){
               rowNumber = 3;

           }
           if (squareNumber >= 24 && squareNumber <= 29){
               rowNumber = 2;
               columnNumber = squareNumber%6;

           }
           if (squareNumber >= 30 && squareNumber <= 35){
               rowNumber = 1;

           }
           if (squareNumber >= 36 && squareNumber <= 41){
               rowNumber = 0;
               columnNumber = squareNumber % 6;
           }


       }//end MapSquareNumToScreenRowAndColumn

int remainder = squareNumber % 6;
columnNumber = 5 - remainder;

for (int row = MAXROWS; row >= 0 ; --row) // going from 6 down to 0
{
    for (int column = 0; column < MAXCOLUMNS; ++column) // 0 to 5
    {
        if (row & 1)
            column = 5 - column; // right to left if odd row
    }
}

Member 11160467 wrote:

how can I find the "even rows"

Richard MacCutchan wrote:

// You can calculate screen position by multiplying each index by the
// appropriate number of pixels in the side of a square

What causes the apparently random order in which Cells are placed in the TableLayoutPanel in the first picture: your code ?

I was under the impression that you wanted the game to start with the Cells in random order: is that incorrect ?

Dictionary<Point, string> cellMap = new Dictionary<Point, string>
{
    {new Point(0,6), "Start"},
    {new Point(5,0), "Final"},
    {new Point(0,0), "36"},
    // you fill in the rest
    {new Point(1,6), "1"},
};

// reset the initial layout:
private void ResetLayout()
{
    YourTableLayoutPanel.Controls.Clear();
    
    foreach (KeyValuePair<Point, string> kvp in cellMap)
    {
        Label lbl = new Label();
        lbl.AutoSize = false;
        lbl.Margin = new Padding(8);
        lbl.Anchor = AnchorStyles.Bottom | AnchorStyles.Right;
        lbl.TextAlign = ContentAlignment.MiddleRight;
        lbl.Text = kvp.Value;

        YourTableLayoutPanel.Controls.Add(lbl, kvp.Key.X, kvp.Key.Y);
    }
}

List<Label> lblList = new List<Label>(); 

// assume you have initialized 'lblList with 42 Labels

private void orderLabels()
{
    int count = 0;

    Label cellLabel;

    for (int row = 0; row < 7; row++)
    {
        for (int col = 0; col < 6; col++)
        {
            cellLabel = lblList[count];

            if (count == 5)
            {
                cellLabel.Text = "Final";
                YourTableLayoutPanel.Controls.Add(cellLabel, 5, 0);
            }
            else if (count == 36)
            {
                cellLabel.Text = "Start";
                // for you to figure out
            }
            else
            {
                int offset;

                if (row%2 == 0)
                {
                    // ascending order
                    offset = (6 - row)*6 + col;
                }
                else
                {
                    // descending order
                    // offset = for you to figure out
                }

                cellLabel.Text = offset.ToString();
                YourTableLayoutPanel.Controls.Add(cellLabel, col, row);
            }         
            count++;
        } 
    }
}

int sumOfEvenNumbers = numbers.Sum( x => EvenOrZero( x ) );

http://stackoverflow.com/a/7748849/124386[^]

Specifically, the subtle difference is that a method group is considered to be convertible to a delegate type solely on the basis of whether the arguments match, not also on the basis of whether the return type matches.
...
The upshot of it here is that your method group is convertible to all the different delegate types that are the second arguments of every version of Sum that takes a delegate. Since no best conversion can be found, the overload resolution on method group Sum is ambiguous.