C#

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) },