Question

有没有办法在没有强制执行的情况下选择具有负值的2d bool数组（bool [，]）中的随机位置？

Answer 1

这是一个非暴力方法，但它涉及整个表的初始扫描：

int[] negOffsets = new int[data.Length];
int dataOffset = 0, count = 0;
foreach(bool x in data)
{
    if(!x) negOffsets[count++] = dataOffset;
    dataOffset++;
}
if(count == 0) {
    // nothing to pick
} else {
    int index = negOffsets[rand.Next(0, count)];

    int x = index / data.GetLength(1),
        y = index % data.GetLength(0);
    // assertion: the following should be false
    bool b = data[x, y];
}

此外，您可能希望保留offsets并在迭代之间重复使用。

Answer 2

希望您能从代码中获得想法。显然它需要一些调整，但是概念是使用TestClass作为数组的封面。不需要任何扫描，它很容易使用;）

 public class TestClass
    {
        public bool[,] BoolArray
        {
            get;
            private set;
        }
        private List<Tuple<int, int>> negativeValues;

        public TestClass(int x, int y)
        {
            this.negativeValues = new List<Tuple<int, int>>();
            this.BoolArray = new bool[x, y];
        }

        public Tuple<int, int> GetPosition()
        {
            if (this.negativeValues.Count > 0)
            {
                Random rand = new Random();
                return this.negativeValues[rand.Next(this.negativeValues.Count - 1)];
            }
            else
                return null;
        }



        public bool this[int x, int y]
        {
            get
            {
                return this.BoolArray[x, y];
            }

            set
            {
                if (!value)
                    negativeValues.Add(new Tuple<int, int>(x, y));

                this.BoolArray[x][y] = value;
            }
        }
    }

Answer 3

是的，完全有可能：

var random = new Random();
int xBound = 100;
int yBound = 100;
var values = new bool[xBound, yBound];

// Fill the values array
for (int y = 0; y < yBound; y++)
{
    for (int x = 0; x < xBound; x++)
    {
        values[x, y] = random.Next(0, 2) == 1;
    }
}

// Find the value at a random position that's false
bool foundFalse = false;
int probeX, probeY;

while (!foundFalse)
{
    probeX = random.Next(0, xBound);
    probeY = random.Next(0, yBound);

    if (values[probeX, probeY] == false)
    {
        // Do something with your probeX, probeY values perhaps
        foundFalse = true;
    }
}

Hoewever，问这是否有用可能是明智之举。为什么要在多维数组中随机探测，直到找到某个值？是不是存在一些可以以不同方式解决的潜在问题，更重要的是，更有效率？

请注意，例如，使用此方法，while()循环完全有可能永远不会完成。

您可以尝试事先遍历数组，找到false所在的[x，y]索引，并将这些坐标存储在单独的列表中，例如{{1} （或使用@MarcGravell发布的更优雅的解决方案）。

然后，您可以从该列表中选择一个随机项，然后您将Tuple<int,int>随机[x,y] values[x,y]。

选择数组中的随机位置

3 个答案: