Question

我有一个函数返回我的int值列表取决于值的一部分：

private List<int> GetColumn(int total, int column)
{
    List<int> retList = new List<int>();

    if (total <= 0)
    {
        return retList;
    }

    if (column < 0 || column > 2)
    {
        column = 0;
    }

    int pageSize = total / 3;

    int startIndex = column * pageSize;
    int endIndex = column * pageSize + pageSize;

    if (endIndex > total)
    {
        endIndex = total;
    }

    for (int i = startIndex; i < endIndex; i++)
    {
        retList.Add(i);
    }

    return retList;

}

但它的工作原理有误，因为： GetColumn（17,1）

返回[0,1,2,3,4]，但应返回[0,1,2,3,4,5] for GetColumn（17,1） - [6,7,8,9,10,11]
for GetColumn（17,2） - [12,13,14,15,16]

为16它应该返回： for GetColumn（16,0） - [0,1,2,3,4,5]
for GetColumn（16,1） - [6,7,8,9,10]
for GetColumn（16,2） - [11,12,13,14,15]

我的功能应该怎样改变？谢谢！

Answer 1

如果这是你需要的（数字按列增加，但行需要先填充）：

您需要定义哪个列获取余数：

int remainder = total % 3;

如果余数为1，则只有第一列是6个元素。如果余数为2，则为＆amp;第二列是6个元素。您需要根据此计算startIndex和endIndex。

因此;

int pageSize = total / 3;
int remainder = total % 3;

int startIndex = column * pageSize + min(column, remainder);
int endIndex = startIndex + pageSize + (remainder > column ? 1 : 0);

应该有效。我只测试了它，它适用于不同于3的行数。

以下是我如何得到公式，绘图表是整理这些算法的好方法：

r：剩余，c：列，ps：pagesize（如上所述）

StartingIndex:
.  |r:0 |r:1   |r:2
----------------------
c:0|0   |0     |0
----------------------
c:1|ps  |ps+1  |ps+1
----------------------
c:2|ps*2|ps*2+1|ps*2+2

如果扩展rowsize 4的表格，你可以看到一个模式：

StartingIndex:
.  |r:0 |r:1   |r:2   |r:3
------------------------------
c:0|0   |0     |0     |0
------------------------------
c:1|ps  |ps+1  |ps+1  |ps+1
------------------------------
c:2|ps*2|ps*2+1|ps*2+2|ps*2+2
------------------------------
c:3|ps*3|ps*3+1|ps*3+2|ps*3+3

您要添加的值是相关列和余数的最小值

对于endIndex，当您为给定的余数vs列构建表时，可以看到所需的列长度。我现在不会写这个，因为这里花了太多时间来绘制表格，我相信你已经有了这个想法。

Answer 2

整数除法向零舍入。所以17/3 = 5和-17/3 = -5
我想你想要的是如下所示舍入到下一个整数

int pageSize = (int)Math.Ceiling(total / 3d);

Answer 3

如果我理解正确，则要求是：

If the number is 3n,   divide it in 3 groups of n,   n   and n   elements.
If the number is 3n+1, divide it in 3 groups of n+1, n   and n   elements.
If the number is 3n+2, divide it in 3 groups of n+1, n+1 and n   elements.

最好的办法是在代码中明确表达，避免任何“聪明”的逻辑。直接分裂归结为：

If the number is 3n, the divisions are:
     0 ..  n-1
     n .. 2n-1
    2n .. 3n-1
If the number is 3n+1, the divisions are:
     0 .. n
   n+1 .. 2n
  2n+1 .. 3n
If the number is 3n+2, the divisions are:
     0 .. n
   n+1 .. 2n+1
  2n+2 .. 3n+1

在c＃中可能是这样的：

public static List<int> Divide3Columns(int total, int column)
{
  int startIndex = 0;
  int endIndex = 0;
  int pageSize = total / 3;

  if (total % 3 == 0)
  {
    startIndex = column * pageSize;
    endIndex = (column + 1) * pageSize - 1;
  }

  if (total % 3 == 1)
  {
    if (column == 0)
    {
      startIndex = 0;
      endIndex = pageSize; //pageSize + 1 elements;
    }
    else
    {
      startIndex = column * pageSize + 1;
      endIndex = (column + 1) * pageSize;
    }
  }

  if (total % 3 == 2)
  {
    if (column == 2)
    {
      startIndex = 2 * pageSize + 2;
      endIndex = 3 * pageSize + 1; //same as total - 1;
    }
    else
    {
      startIndex = column * (pageSize + 1);
      endIndex = (column + 1) * pageSize + column;
    }
  }

  List<int> result = new List<int>();
  for (int i = startIndex; i <= endIndex; i++)
  {
    result.Add(i);
  }
  return result;
}

答案假设我们将始终divide in 3, and only 3 columns。如果数字是可变的，则可以推广确定列的逻辑。

除以3，在C＃中起作用

3 个答案: