Question

所以现在这是我的代码，我需要帮助，所以它不会重复。我需要这个在学校，所以如果你能解释一下它会有所帮助。顺便说一下，不关心它对瑞典语的评论

        int temp;

        int[] myArray = new int[20]; // Array med 20 tal
        Random random = new Random(); // Skapar metoden "Random"
        for (int i = 0; i < myArray.Length; i++) // Forloop med 20 positioner
        {

            myArray[i] = random.Next(1, 100); // Ger random värden till dessa 20 positionerna
            for (int j = 0; j < myArray.Length; j++)
            {
                if (myArray[i] > myArray[j]) // Array [i] större än Array [j]
                {
                    //temp = myArray[j];
                    //myArray[j] = myArray[i];  
                    //myArray[i] = temp;

                }
            }
            Console.Write(myArray[i] + " ");
        }

Answer 1

你可以尝试linq到.Distinct（）并将其转换为数组使用.ToArray（）

var s = { 5, 7, 7, 4, 3};
var q = s.Distinct().ToArray();

Answer 2

由于数组具有随机值范围（即20）的大小，因此您将获得每个数字一次。使用Enumerable.Range创建每个数字最简单一次，并且只更改它们出现的顺序。

可以通过OrderBy()更改订单，而此处使用随机。

这完全基于IEnumerable<T>。因此需要将其放入数组中，这可以通过调用ToArray()来完成。

public int[] RandomlyOrderedValues()
{
  Random random = new Random();
  return Enumerable.Range(1, 20).OrderBy(x => random.Next()).ToArray();
}

我不是你的老师，但希望你还是自己玩，阅读文档，最后用你自己的语言表达。

更改了问题，现在随机范围大于数组大小。

最好与IEnumerable<T>合作，在那里你可以获得最强大的工具。

// let's create inifite number of random values:
// note that the Random instance needs to be created only once,
// so it's put into a field.

private Random random = new Random();

public IEnumerable<int> InfiniteRandomValues()
{
  while (true)
  {
    yield return random.Next(1, 100);
  }
}

public int[] GetUniqueRandomValues(int numberOfValues)
{
  return InfiniteRandomValues()
    // only uninque values
    .Distinct()
    // generate the requested number of distinct values
    .Take(numberOfValues)
    // put it into an array.
    .ToArray();
}

它是如何工作的？当您创建随机值时，您不知道它会有多少，因为您无法知道它将创建多少重复项。用于无限多个值的生成器肯定有足够的值。把它想象成一个工厂。只有在迭代IEnumerable时，才会创建值。

这称为＆＃34;延迟执行＆＃34;。只有在迭代IEnumerable时，才会请求源。

Distinct就是这样的。它只返回其调用者请求的不同值。

哪个是Take。这个减少了所采取的项目数量，但仍然没有迭代。

ToArray最终迭代它的源并拉出尽可能多的值。现在向后读它：它接受来自Take的所有值，它返回20.它自己需要来自Distinct的20个值，它迭代它的源，直到它得到20个不同的值。 Distinct从InifiteRandomNumbers工厂获取其值，并且可以根据需要使用它。

当你终于明白这些东西是如何工作的时候，你可以非常直观地使用它。

另一个更经典的实施

private int[] GetRandomValues()
{
  Random random = new Random();

  int[] values = new int[20];

  for(int i = 0; i < 20; i++)
  {
    // create random values until you found a distinct oune.
    int nextValue;
    do
    {
      nextValue = random.Next(1, 100);
    } while (ContainsValue(values, i, nextValue))

    values[i] = nextValue;
  } 
  return values;
}

// When adding the values to a List instead of an array, it would be
// much easier, but need copying the vlaues to the array at the end.
// When using the array directly, you have to know which values you
// already generated, because it's initialized with zero.
// This method checks wether the value is in the array within
// the items until endIndex.
private bool ContainsValue(int[] values, int endIndex, int valueToFind)
{
  // simple linq way:
  // return values.Take(endIndex).Contains(valueToFind);

  // classic way:
  for(int i = 0; i < endIndex; i++)
  {
    if (values[i] = valueToFind) return true;
  }
  return false;
}

Answer 3

最简单的，看起来你可能想要

private static Random rng = new Random(); //class level definition

var myArray = Enumerable.Range(1, 20).OrderBy(X => rng.Next()).ToArray();

或者，如果这是为了学校，你需要证明你的代码...填充数字1到20的数组，然后使用Fisher-Yates shuffle随机化数组的顺序。

请参阅：https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

创建没有重复的数组c＃

3 个答案: