How to keep all characters in random?

Question

I have input from textbox let´s say "abc". I want from random to randomize characters from this input. I can do that but from here I don´t know how to code to randomize only with all characters in final. So random final should be only one of these: "abc" "acb "bac" "bca" "cab" "cba". Now I have output like "abb" "ccc" "bba".

Random random = new Random();
int _length = _input.Length;
return new string(Enumerable.Repeat(_input, _length)
                 .Select(s => s[random.Next(s.Length)]).ToArray());

Possible duplicate of [Best way to randomize an array with .NET](https://stackoverflow.com/questions/108819/best-way-to-randomize-an-array-with-net) — xdtTransform, Feb 13 '19 at 10:04

vc 74 · Accepted Answer · 2019-02-13T09:47:38.800

3

Sorting the letters by random:

var random = new Random();

var randomized = new string(_input.OrderBy(letter => random.Next()).ToArray());

Should do it

Link to fiddle

edited Feb 13 '19 at 09:47

answered Feb 13 '19 at 09:41

vc 74

37,131
7
73
89

this is a fun one... it'll depend on how `OrderBy` is implemented - i.e. does it evaluate the selector exactly once per element? if it *doesn't*, then this could cause it to crash with an exception along the lines of "your comparer is broken" – Marc Gravell Feb 13 '19 at 09:42
Using OrderBy will not result in a good randomization.This method performs a stable sort https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.orderby – Soufiane Tahiri Feb 13 '19 at 09:47
@SoufianeTahiri true, but that only matters when the selector returns the same value for two elements, which - with a range of [0,2147483647) - seems unlikely for most reasonable inputs; personally I'd be far more concerned with the question of "how many times per element does it evaluate the selector?" question – Marc Gravell Feb 13 '19 at 10:07
@MarcGravell I think it does, `OrderBy` uses `EnumerableSorter` internally which has a `ComputeKeys` method invoked first in the sorting process and which sole purpose is a copy each element's key to a keys array used for the rest of the processing. It's not explicitly mentioned in the doc though and subject to change in the future. – vc 74 Feb 13 '19 at 10:29

score 2 · Answer 2 · answered Feb 13 '19 at 09:41

One way to do this would be to create a list of the input characters, and select random elements, removing them each time. Otherwise, you need to track which ones you've "used", etc.

For example:

    string s = "abc";
    var candidates = new List<char>(s); // the as-yet-unused data
    var result = new char[s.Length];
    var random = new Random();
    for(int i = 0; i < result.Length; i++)
    {
        int index = random.Next(candidates.Count); // pick an unused element
        result[i] = candidates[index];
        candidates.RemoveAt(index); // remove, so we don't repeat it
    }
    string final = new string(result);

score 1 · Answer 3 · answered Feb 13 '19 at 09:44

You seem looking for a shuffling method :

string s = "abc";
      char[] ar = s.ToCharArray();
    Random rnd = new Random();
    int n = ar.Length;
    while (n > 1)
    {
        n--;
        int k = rnd.Next(n + 1);
        var x = ar[k];
        ar[k] = ar[n];
        ar[n] = x;
    }
    string result=  new string(ar);

score 0 · Answer 4 · answered Feb 13 '19 at 10:06

Use the modern version of the Fisher-Yates shuffle

From Wikipedia: The Fisher–Yates shuffle is an algorithm for generating a random permutation of a finite sequence — in plain terms, the algorithm shuffles the sequence

The following is implemented as extension function, so you can use it in a concatenation of LINQ statements:

private static readonly Random rnd = new Random();
public static IEnumerable<TSource> Shuffle<TSource>(this IEnumerable<TSource> source)
{
    // TODO: exception if source equals null

    // copy the source items to a new List, we don't want to shuffle the input, do we?
    List<TSource> sourceItems = source.ToList();
    int lastIndex = sourceItems.Count-1;
    for (int i = 0; i < lastIndex; ++i)
    {
        // pick an index number on or after i
        // if the picked number equals i, then do not shuffle element [i]
        int j = rnd.Next(i, sourceItems.Count);
        if (i != j)
        {   // swap:
            var tmp = sourceItems[i];
            sourceItems[i] = sourceItems[j];
            sourceItems[j] = tmp;
        }
        // yield return the next element of the shuffled sequence
        yield return sourceItems[i];
    }
}

usage:

List<MyClass> input = ...
IEnumerable<MyClass> output = input.Shuffle();

Note that the input is not shuffled.

The nice thing is, that if you only want a few outputs, no more items are shuffled then necessarry. The following will only take 3 elements from your original list:

var output = Enumerable.Range(0, 10)
    .Shuffle()
    .Take(3)
    .ToList();

output is 3 distinct random numbers between 0 and 9

How to keep all characters in random?

4 Answers4