c# - 如何：为列表中的每个条目分配一个唯一编号？

Question

我想要的是制作瓷砖。这些图块（大约 30 个）在游戏中应该有一个固定的位置，但每次我加载游戏时，它们都应该有随机数，这会影响它们的图形外观。

我知道如何使用该Random方法为单个图块指定一个数字以更改其外观，但Random如果我要制作一个存储多个图块位置的列表，我将如何使用该方法一无所知。如何为列表中的每个条目分配一个唯一的随机数？

我的游戏需要这个，你在一个平面 2D 地图中，生成随机类型的房间（宝藏室、竞技场房间等），你要探索。

Answer 1

看看Fisher-Yates shuffle。如果我正确地阅读了您的问题，它非常易于使用并且应该对您有用。

Answer 2

if you have something like this:

public class Tile 
{
     public int Number {get;set;} 
     ...
}

you can do it like this:

var numbers = Enumerable
  .Range(1, tilesList.Count)  // generates list of sequential numbers
  .OrderBy(x => Guid.NewGuid()) // shuffles the list
  .ToList();

for (int i = 0; i < tiles.Count; i++) 
{
    tile[i].Number = numbers[i];
}

I know, that Guid is not a Random alternative, but it should fit this scenario.

Update: As long as answer was downvoted, I've wrote simple test, to check if Guids are not usable for shuffling an array:

var larger = 0;
var smaller = 0;

var start = DateTime.Now;

var guid = Guid.NewGuid();

for (int i = 0; i < 10000000; i++)
{
    var nextGuid = Guid.NewGuid();
    if (nextGuid.CompareTo(guid) < 0)
    {
        larger++;
    }
    else
    {
        smaller++;
    }

    guid = nextGuid;
}

Console.WriteLine("larger: {0}", larger);
Console.WriteLine("smaller: {0}", smaller);

Console.WriteLine("took seconds: {0}", DateTime.Now - start);

Console.ReadKey();

What it does, it counts how many times next guid is smaller than current and how many times is larger. In perfect case, there should be equal number of larger and smaller next guids, which would indicate, that those two events (current guid and next guid) are independent. Also measured time, just to make sure, that it is not too slow.

And got following result (with 10 million guids):

larger: 5000168
smaller: 4999832
took seconds: 00:00:01.1980686

Another test is direct compare of Fisher-Yates and Guid shuffling:

static void Main(string[] args)
    {
        var numbers = Enumerable.Range(1, 7).ToArray();
        var originalNumbers = numbers.OrderBy(x => Guid.NewGuid()).ToList();

        var foundAfterListUsingGuid = new List<int>();
        var foundAfterListUsingShuffle = new List<int>();

        for (int i = 0; i < 100; i++)
        {
            var foundAfter = 0;
            while (!originalNumbers.SequenceEqual(numbers.OrderBy(x => Guid.NewGuid())))
            {
                foundAfter++;                    
            }

            foundAfterListUsingGuid.Add(foundAfter);

            foundAfter = 0;

            var shuffledNumbers = Enumerable.Range(1, 7).ToArray();
            while (!originalNumbers.SequenceEqual(shuffledNumbers))
            {
                foundAfter++;
                Shuffle(shuffledNumbers);
            }

            foundAfterListUsingShuffle.Add(foundAfter);
        }

        Console.WriteLine("Average matching order (Guid): {0}", foundAfterListUsingGuid.Average());
        Console.WriteLine("Average matching order (Shuffle): {0}", foundAfterListUsingShuffle.Average());
        Console.ReadKey();
    }

    static Random _random = new Random();

    public static void Shuffle<T>(T[] array)
    {
        var random = _random;
        for (int i = array.Length; i > 1; i--)
        {
            // Pick random element to swap.
            int j = random.Next(i); // 0 <= j <= i-1
            // Swap.
            T tmp = array[j];
            array[j] = array[i - 1];
            array[i - 1] = tmp;
        }
    }

By "direct compare" I mean, that I'm producing shuffled sequence and try to shuffle again to get same sequence, and assume, that the more tries I need to produce same sequence, the better random is (which is not necessary mathematically correct assumption, I think it is oversimplification).

So results for small set with 1000 iterations to reduce error, was:

Average matching order (Guid): 5015.097
Average matching order (Shuffle): 4969.424

So, Guid performed event better, if my metric is correct :)

with 10000 iterations they came closer:

Average matching order (Guid): 5079.9283
Average matching order (Shuffle): 4940.749

So in my opinion, for current usage (shuffle room number in game), guids are suitable solution.

Answer 3

制作一个由 30 个连续数字组成的数组，镜像您的瓷砖数组。然后从这里选择一个你喜欢的数组改组解决方案，例如：

http://forums.asp.net/t/1778021.aspx/1

那么 tile[23] 的编号将是 numberArray[23]。