C#

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.

Quote:

The second and third operands of the ?: operator control the type of the conditional expression.

Let X and Y be the types of the second and third operands. Then,

• If X and Y are the same type, then this is the type of the conditional expression.
• Otherwise, if an implicit conversion exists from X to Y, but not from Y to X, then Y is the type of the conditional expression.
• Otherwise, if an implicit conversion exists from Y to X, but not from X to Y, then X is the type of the conditional expression.
• Otherwise, no expression type can be determined, and a compile-time error occurs.

• X and Y are not the same type.
• There is no implicit conversion from null to Int32;
• There is no implicit conversion from Int32 to null;
• Therefore, a compile-time error occurs.

• X and Y are not the same type.
• There is an implicit conversion from null to Nullable<Int32>; -or-
• There is an implicit conversion from Int32 to Nullable<Int32>;
• Therefore, the type of the expression is Nullable<Int32>.

• (i2 == 0) ? (int?) null : i1 / i2
• (i2 == 0) ? default(int?) : i1/i2
• (i2 == 0) ? null : (int?)i1 / i2
• (i2 == 0) ? null : i1 / (int?)i2

• If both operands are the same type, that is the type of the result;
• If there is an implicit conversion from X to Y, but not from Y to X, then Y is the type of the result;
• If there is an implicit conversion from Y to X, but not from X to Y, then X is the type of the result;
• Otherwise, no result type can be determined, and a compile-time error occurs.

{ "/", (i1, i2) => ((i2 == 0) ?  null : ((int?)i1)/i2) },