Question

我有一个3x3的矩阵，看起来像

1 2 3

4 5 6

7 8 9

每个数字后面都是一个对象。所以我编写了这段代码，它将返回当前矩阵中的哪个位置。但它感觉非常重复，我很好奇是否有可能优化那段代码。如果是这样，怎么样？

public int findPos(int i, int k) {
    if (i == 0 && k == 0) {
        return 1;
    }
    if (i == 0 && k == 1) {
        return 2;
    }
    if (i == 0 && k == 2) {
        return 3;
    }
    if (i == 1 && k == 0) {
        return 4;
    }
    if (i == 1 && k == 1) {
        return 5;
    }
    if (i == 1 && k == 2) {
        return 6;
    }
    if (i == 2 && k == 0) {
        return 7;
    }
    if (i == 2 && k == 1) {
        return 8;
    }
    if (i == 2 && k == 2) {
        return 9;
    }

    return 0;
}

该方法后来以这种方式应用

if (myMatrix[i][k] == 2) {
    position = findPos(i, k);
    drawAtPos(position);
}

Answer 1

你可以把它转换成：

public int findPos(int i, int k) {
    if (0 <= i && i < COLUMN_COUNT && 0 <= k && k < row_COUNT){ // out of bounds
      return 0;
    }
    return (i * 3) + (k + 1);
}

所有这一切都是将条件简化为数学，因为每列向右返回1个偏移量，每行需要增加3。

对于更通用的解决方案，它将是：

public int findPos(int i, int k) {
    if (0 <= i && i < COLUMN_COUNT && 0 <= k && k < row_COUNT){ // out of bounds
      return 0;
    }
    return (i * COLUMN_COUNT) + (k + 1);
}

其中COLUMN_COUNT是您拥有的列数。所以它适用于：

1 2 3  4  5  6
7 8 9 10 11 12

其中COLUMN_COUNT = 6

Answer 2

您可以使用以下方式计算您的位置：

if (0 <= i && i < 3 &&
      0 <= k && k < 3) {    
   // number of rows passed * size of each row + current column + 1 for 0-to-1-based-conversion
   return (i * 3) + (k + 1);
} else {
   return 0;
}

Answer 3

这有什么关系？

var report = patients
                .GroupBy(p => p.LivingSpace)
                    .Select(g => new
                    {
                        Unit = g.Key,
                        Count = g.Count()
                    })
                .Union(patients
                    .Select(p => new
                    {
                        Unit = "Total",
                        Count = patients.Count
                    }));

为什么会这样？好吧，从你的矩阵中减去1，所以它看起来像这样：

(i*3 + k) + 1

所以它应该是显而易见的。

在矩阵中查找位置

3 个答案: