Random 在F中生成两个不同的随机数#

我有一个F#列表，我从中选取了两个元素。
如果列表中有10个元素：

let rnd = new Random()
let elem1 = list.Item(rnd.Next(0,9))
let elem2 = list.Item(rnd.Next(0,9))

elem1和elem2有可能相等
我已经检查了一些变通方法，其中大多数都使用do-while，但我不想实现一个可能永远不会以F#结尾的函数
有没有办法在随机函数中创建限制

First random  : 0 <= x <= 9 
Second random : 0 <= y <= 9  <> x

---

First random:0实现这一点有很多方法。一个简单的例子如下：

open System
open System.Linq
let rnd = new Random()
let elem1 = list.Item(rnd.Next(0,9))
let elem2 = list.Where(fun x->x <> elem1).ElementAt(rnd.Next(0,8))

开放系统
开放系统
设rnd=new Random（）
设elem1=list.Item（rnd.Next（0,9））
让elem2=list.Where（fun x->x elem1.ElementAt（rnd.Next（0,8））
一个简单的解决方案：

let rnd = new Random()
let ndx1 = rnd.Next(9)
let ndx2 = 
    let x = rnd.Next(8)
    if x < ndx1 then x else x + 1
let elem1, elem2 = list.[ndx1], list.[ndx2]

可概括为：

let getTwoElements lst = 
    let c = List.length lst
    let x, y = Math.DivRem(Random().Next(c * (c-1)) * (c+1) / c + 1, c)
    lst.[x], lst.[y]

一种更具声明性的方法，考虑到您对图像中点的评论：

let rnd = System.Random()

/// this will build you a list of 10 pairs of indices where a <> b. 
let indices = 
    Seq.initInfinite (fun _ -> rnd.Next(0,10), rnd.Next(0,10))
    |> Seq.filter (fun (a,b) -> a <> b)
    |> Seq.take 10
    |> List.ofSeq

/// map indices into actual points.
let elems =
    let points = list |> Array.ofList
    List.map (fun (a, b) -> points.[a], points.[b]) indices

设rnd=System.Random（）
///这将为您构建一个包含10对索引的列表，其中a b。
让指数=
Seq.initInfinite（乐趣->rnd.Next（0,10），rnd.Next（0,10））
|>顺序过滤器（乐趣（a、b）->a、b）
|>序号10
|>表1.1
///将索引映射到实际点。
让elems=
让点=列表|>数组.of列表
List.map（fun（a，b）->点[a]，点[b]）索引

请注意，不要对列表使用随机访问。它们不是为这个而设计的，而且性能很差。首先将它们转换为数组。
这是实际问题的简化版本吗？我这样问是因为如果它真的这么简单，你可以创建逻辑，根据第一次调用返回的值修改第二次
rnd.Next（）
调用的范围。我有一个int*int的列表，它表示图像中的点，我需要这些坐标作为我的初始集合，集合的对象是使用两点创建的，然后我计算它们之间的角度。+1：这是一个聪明的把戏，即使我不想在野外看到它。
let rnd = System.Random()

/// this will build you a list of 10 pairs of indices where a <> b. 
let indices = 
    Seq.initInfinite (fun _ -> rnd.Next(0,10), rnd.Next(0,10))
    |> Seq.filter (fun (a,b) -> a <> b)
    |> Seq.take 10
    |> List.ofSeq

/// map indices into actual points.
let elems =
    let points = list |> Array.ofList
    List.map (fun (a, b) -> points.[a], points.[b]) indices