How to shuffle a substring

Question

I have a string s of size kn.

I want to shuffle each of the k n-sized blocks of s (given k and n).

Example: s = abcdabcdabcd, n = 4, k = 3.

BEGIN: abcdabcdabcd

 abcd       abcd       abcd
 └─┬─┘      └─┬─┘      └─┬─┘      
shuffle    shuffle    shuffle
   ↓          ↓          ↓
 bdac       adbc       cdba

RESULT: bdacadbccdba

Answer 1

Random rnd = new Random();
var s = "abcdabcdabcd";
var k = 3;
var n = 4;
var result = "";
for (int i = 0; i < k; i++)
{
    var current = s.Substring((i * n), n);
    var shuffled = string.Join("",current.OrderBy(x=>rnd.Next()));
    result += shuffled;
}

One Result :

"bcadabcdbcda"

Answer 2

One nasty Linq statement

Given

public static Random _rnd=new Random();

public static string WeirdShuffle(string input, int n) 
   => string.Concat(input.ToCharArray()
                         .Select((s, i) => (s, i))
                         .GroupBy(x => x.i / n)
                         .Select(g => string.Concat(g.Select(x => x.s)
                                                     .OrderBy(x => _rnd.Next()))));

Usage

Console.WriteLine(WeirdShuffle("abcdabcdabcd",4));

---

Additional Resources

• String.ToCharArray Method

  • Copies the characters in this instance to a Unicode character array.

• Enumerable.Select Method

  • Projects each element of a sequence into a new form.

• Enumerable.GroupBy Method

  • Groups the elements of a sequence.

• Enumerable.OrderBy Method

  • Sorts the elements of a sequence in ascending order.

• String.Concat Method

  • Concatenates one or more instances of String

Answer 3

Something like this should work. It's essentially a modified Fisher-Yates shuffle:

private static Random _random = new Random(); 

public static string ShuffleSubstrings(string input, int n, int k)
{
    if (input.Length != (n * k))
    {
        throw new ArgumentException("Length of input is not equal to kn");
    }

    var characters = input.ToCharArray();
    for (int g = 0; g < input.Length; g += n)
    {
        ShuffleSubarray(characters, g, n);
    }
    return new string(characters);
}

private static void ShuffleSubarray<T>(T[] array, int startPosition, int length)
{
    // For loop to handle individual group
    for (int i = startPosition; i < startPosition + length; ++i)
    {
        // shuffle taken from taken from https://www.dotnetperls.com/fisher-yates-shuffle, modified to work with groups)
        int r = i + _random.Next(length - (i % length));
        T tmp = array[r];
        array[r] = array[i];
        array[i] = tmp;
    }
}

Try it online

Answer 4

I like this one:

private static Random _rnd = new Random();

public static string ShuffleSubstrings(string input, int n, int k)
{
    if (input.Length != (n * k))
    {
        throw new ArgumentException("Length of input is not equal to kn");
    }

    return String.Join("",
        from i in Enumerable.Range(0, k)
        from x in
            from y in input.Substring(i * n, n)
            orderby _rnd.Next()
            select y
        select x);
}

Answer 5

public string Shuffle(string str, int shuffleSize)
{
    if (str.Length % shuffleSize != 0)
    {
        throw new ArgumentException();
    }
    var result = Enumerable.Range(0, str.Length / shuffleSize)
        .Select(i =>
            SmallShuffle(str.Substring(i * shuffleSize, shuffleSize))
        );

    return string.Join("", result);
}

public string SmallShuffle(string str)
{
    char[] array = str.ToCharArray();
    Random rng = new Random();
    int n = array.Length;
    while (n > 1)
    {
        n--;
        int k = rng.Next(n + 1);
        var value = array[k];
        array[k] = array[n];
        array[n] = value;
    }
    return new string(array);
}

Usage:

var s = "123456789123";
int k = 4;
var shuffled = Shuffle(s, k);

Heavily influenced by these two answers:

https://stackoverflow.com/a/1450797/4949005

https://stackoverflow.com/a/4740014/4949005

Answer 6

 static string Shffule(string str,int blockSize)
        {
            Random randomIndex= new Random();
            for (int indexInString = 0; indexInString < str.Length; indexInString+= blockSize)
            {
                for (int shufflesInBlock = 0; shufflesInBlock < blockSize; shufflesInBlock++)
                {
                    var firstRandomIndex = randomIndex.Next(indexInString, indexInString + blockSize);
                    var secondRandomIndex = randomIndex.Next(indexInString, indexInString + blockSize);
                    //str.Swap(firstRandomIndex, secondRandomIndex);
                }
            }
            return swapedString;
        }

there is a lot of ways to swap 2 chars string here so i will leave the string.Swap extension method to u

you can control how many shuffles per block from the nested loop by changing the shufflesInBlock < blockSize condition