C# 需要从C中给定的范围生成一对数字#_C#_Random

C# 需要从C中给定的范围生成一对数字#

c# random

C# 需要从C中给定的范围生成一对数字#,c#,random,C#,Random,我需要在（1,8）范围内生成2个数字。假设前两个数字是3和4。第二次，范围将排除3和4，这就是我想要实现的。这样，循环将持续4次我一直在尝试…但无法继续我只知道使用Random类范围是固定的任何类型的帮助都将被接受。提前感谢方法1（经典）： static List<Tuple<int, int>> GetPairs(int min, int max, Random r) { var items = new List<Tuple<int, in

我需要在（1,8）范围内生成2个数字。假设前两个数字是3和4。第二次，范围将排除3和4，这就是我想要实现的。这样，循环将持续4次

我一直在尝试…但无法继续
我只知道使用

Random

类

范围是固定的

任何类型的帮助都将被接受。提前感谢方法1（经典）：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

输出：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

具有某种随机顺序和不同执行的方法2:

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

输出：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

方法1（经典）：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

输出：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

具有某种随机顺序和不同执行的方法2:

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

输出：

static List<Tuple<int, int>> GetPairs(int min, int max, Random r)
{
    var items = new List<Tuple<int, int>>();
    var pickedItems = new HashSet<int>();
    int count = (max - min + 1);

    Func<int> randAndCheck = () =>
    {
        int? candidate = null;

        while(candidate == null || pickedItems.Contains(candidate.Value))
            candidate = r.Next(min, max + 1);

        pickedItems.Add(candidate.Value);
        return candidate.Value;
    };

    while (pickedItems.Count != count)
    {
        int firstItem = randAndCheck();
        int secondItem = randAndCheck();

        items.Add(Tuple.Create(firstItem, secondItem));
    }

    return items;
}

static void Main(string[] args)
{
    foreach(var pair in GetPairs(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 4 Two: 2
One: 8 Two: 3
One: 5 Two: 1
One: 7 Two: 6

static IEnumerable<Tuple<int, int>> TwoAtATime(int min, int max, Random r)
{
    var enumerator = Enumerable.Range(min, max - min + 1)
                                .OrderBy(x=> r.Next()).GetEnumerator();

    while(enumerator.MoveNext())
    {
        int item1 = enumerator.Current;
        if (enumerator.MoveNext())
        {
            int item2 = enumerator.Current;
            yield return Tuple.Create(item1, item2);
        }
    }
}

static void Main(string[] args)
{
    foreach(var pair in TwoAtATime(1, 8, new Random()))
    {
        Console.WriteLine($"One: {pair.Item1} Two: {pair.Item2}");
    }
}

One: 2 Two: 5
One: 4 Two: 7
One: 1 Two: 6
One: 8 Two: 3

代码如下：

using System.Collections.Generic;
namespace TestApp
{
    class Program
    {
        static readonly Random rand = 
            new Random(DateTime.Now.Millisecond);

        static void Main(string[] args)
        {
            var pickList = new List<int> {1, 2, 3, 4, 5, 6, 7, 8};
            while (pickList.Count > 1)
            {
               Console.WriteLine(
                  "Hit any key to get Random pair of integers from List.");
               Console.ReadLine();
               var pair = GetPairFromList(pickList);
               Console.WriteLine($"Pair is: {pair.Item1}: {pair.Item2}");
            }
            Console.WriteLine("List is empty; Hit any key to exit.");
            Console.ReadLine();
        }
        private static Tuple<int, int> GetPairFromList(IList<int> picks)
        {
            return new Tuple<int, int>(
                GetIntFromList(picks), 
                GetIntFromList(picks));
        }
        private static int GetIntFromList(IList<int> picks)
        {
            // next line is where random picking happens
            var val = picks[(int)(picks.Count*rand.NextDouble())];
            // remove randomly selected item from list
            picks.Remove(val);
            return val;
        }
    }
}

使用System.Collections.Generic；
命名空间TestApp
{
班级计划
{
静态只读随机rand=
新随机（DateTime.Now.毫秒）；
静态void Main（字符串[]参数）
{
var pickList=新列表{1,2,3,4,5,6,7,8}；
while（pickList.Count>1）
{
控制台写入线(
“按任意键从列表中获取随机整数对。”）；
Console.ReadLine（）；
var pair=GetPairFromList（pickList）；
WriteLine（$”对为：{Pair.Item1}:{Pair.Item2}”）；
}
WriteLine（“列表为空；按任意键退出”）；
Console.ReadLine（）；
}
私有静态元组GetPairFromList（IList选择）
{
返回新元组(
GetIntFromList（拾取），
GetIntFromList（picks））；
}
私有静态int GetIntFromList（IList选取）
{
//下一行是随机挑选发生的地方
var val=picks[（int）（picks.Count*rand.NextDouble（））]；
//从列表中删除随机选择的项目
拾取。移除（val）；
返回val；
}
}
}

以下是代码：

using System.Collections.Generic;
namespace TestApp
{
    class Program
    {
        static readonly Random rand = 
            new Random(DateTime.Now.Millisecond);

        static void Main(string[] args)
        {
            var pickList = new List<int> {1, 2, 3, 4, 5, 6, 7, 8};
            while (pickList.Count > 1)
            {
               Console.WriteLine(
                  "Hit any key to get Random pair of integers from List.");
               Console.ReadLine();
               var pair = GetPairFromList(pickList);
               Console.WriteLine($"Pair is: {pair.Item1}: {pair.Item2}");
            }
            Console.WriteLine("List is empty; Hit any key to exit.");
            Console.ReadLine();
        }
        private static Tuple<int, int> GetPairFromList(IList<int> picks)
        {
            return new Tuple<int, int>(
                GetIntFromList(picks), 
                GetIntFromList(picks));
        }
        private static int GetIntFromList(IList<int> picks)
        {
            // next line is where random picking happens
            var val = picks[(int)(picks.Count*rand.NextDouble())];
            // remove randomly selected item from list
            picks.Remove(val);
            return val;
        }
    }
}

使用System.Collections.Generic；
命名空间TestApp
{
班级计划
{
静态只读随机rand=
新随机（DateTime.Now.毫秒）；
静态void Main（字符串[]参数）
{
var pickList=新列表{1,2,3,4,5,6,7,8}；
while（pickList.Count>1）
{
控制台写入线(
“按任意键从列表中获取随机整数对。”）；
Console.ReadLine（）；
var pair=GetPairFromList（pickList）；
WriteLine（$”对为：{Pair.Item1}:{Pair.Item2}”）；
}
WriteLine（“列表为空；按任意键退出”）；
Console.ReadLine（）；
}
私有静态元组GetPairFromList（IList选择）
{
返回新元组(
GetIntFromList（拾取），
GetIntFromList（picks））；
}
私有静态int GetIntFromList（IList选取）
{
//下一行是随机挑选发生的地方
var val=picks[（int）（picks.Count*rand.NextDouble（））]；
//从列表中删除随机选择的项目
拾取。移除（val）；
返回val；
}
}
}

可能重复：使用“随机”从列表中拾取，并在第二次拾取之前删除从列表中拾取的项目。假设3和4只是示例，

Enumerable.Range（1,8）

，将它们洗牌，放入堆栈并根据需要弹出它们。请共享代码……这将非常有用helpful@Plutonix@Charles Bretana可能重复：使用random从列表中选择，并删除从列表中拾取的项目，然后再拾取第二次。假设3和4只是示例，

Enumerable.Range（1,8）

，将它们洗牌，把它们放在一个堆栈中，根据需要弹出它们。你能分享代码吗helpful@Plutonix@Charles Bretana这是我的purpose@user3185569这符合我的要求purpose@user3185569这符合我的目的Thnks@Charles BretanaThen你能把它标记为可接受的答案吗？这符合我的目的Thnks@Charles BretanaThen你能把它标记为可接受的答案吗？