I have a discontinuous list of numbers

`N`

(e.g.

`{ 1, 2, 3, 6, 8, 10}`

) and i need to progressively create random pairs of numbers in

`N`

and store them in a list in which there can't be twice the same pair.

For example for a list of 3 different of numbers there is 6 possible pair (not counting same number pair):

example for the list

`{ 4, 8, 9 }`

, the possible pairs are:

>

`(4,8) (4,9) (8,4) (8,9) (9,4) (9,8)`

When we arrive to a number list size of 30 for example, we get 870 possible pairs and with my current method I get less and less efficient the more possible pairs there are.

**What I have tried:**
For now my strategy with a number list of size 30 for example is :

N = { 3, 8, 10, 15, 16, ... } // size = 30
// Lets say I have already a list with 200 different pairs
my_pairs = { (8,16), (23, 32), (16,10), ... }
// Get two random numbers in the list
rn1 = random(N)
rn2 = random(N)
Loop through my_pairs to see if the pair (rn1,rn2) has already been generated
If there is one, we pick two new numbers rn1 & rn2 at random and retry adding them to my_pairs
If not then we add it to the list

The issue is that the more pairs we have in my_pairs, the less likely it is for a pair to not be in that list. So we have to check multiple random pairs multiple times and go through the list every time.

I could try to generate all possible pairs at the start, shuffle the list and pop one element each time I need to add a random pair to my list.

But it will take a lot of space to store all possible pairs when my Numbers list size is increasing (like 9900 possible pairs for 100 different numbers).

And I add numbers in N during my process so I can't afford to recalculate all possible pairs every time.

Is there an algorithm for generating random unique pairs ?

Maybe it would be faster using matrices or storing my pairs in some sort of a tree graph ?