Shuffle chaîne de c#

Je veux savoir shuffle chaîne

Exemple chaîne

string word;

//I want to shuffle it
word = "hello"

Je voudrais être en mesure d'obtenir:

rand == "ohlel"
rand == "lleho"
etc.

OriginalL'auteur ksmakkapawee | 2011-01-19

  1. 13

    Cette solution (dans une forme de méthode d'extension) est agréable:

        public static string  Shuffle(this 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);
    }
    Ce n'est pas un uniforme shufflw

    OriginalL'auteur nan

  2. 6

    C#:

    string str = "hello";

//The random number sequence
Random num = new Random();

//Create new string from the reordered char array
string rand = new string(str.ToCharArray().
                OrderBy(s => (num.Next(2) % 2) == 0).ToArray());
    Cela ne donnera pas un bon résultat aléatoire. Selon MSDN OrderBy va utiliser un tri stable et de préserver l'ordre pour ces personnages qui ont la même valeur. Pour le "h" dans "bonjour" à mettre en dernier, " h "doit rouler" faux "et le reste "vrai". Cependant, le résultat sera "elloh", ce qui n'est pas très excitant. msdn.microsoft.com/en-us/library/bb534966.aspx

    OriginalL'auteur BvdVen

  3. 5

    Vous êtes à la recherche de quelque chose comme la Shuffle de Fisher–Yates. Il y a effectivement un Python exemple sur cette page:

    import random

def shuffle(x):
    for i in reversed(range(1, len(x))):
        # pick an element in x[:i+1] with which to exchange x[i]
        j = random.randrange(i+1)
        x[i], x[j] = x[j], x[i]

    Edit: étant donné que votre question est marqué à la fois ironpython et c#, il y a aussi un exemple Java qui est très facilement converti en C#.

    OriginalL'auteur porges

  4. 4

    Essayer De Fisher-Yates Shuffle:

    class Shuffle
{
static System.Random rnd = new System.Random();
static void Fisher_Yates(int[] array)
{
int arraysize = array.Length;
int random;
int temp;
for (int i = 0; i < arraysize; i++)
{
random = i + (int)(rnd.NextDouble() * (arraysize - i));
temp = array[random];
array[random] = array[i];
array[i] = temp;
}
}
public static string StringMixer(string s)
{
string output = "";
int arraysize = s.Length;
int[] randomArray = new int[arraysize];
for (int i = 0; i < arraysize; i++)
{
randomArray[i] = i;
}
Fisher_Yates(randomArray);
for (int i = 0; i < arraysize; i++)
{
output += s[randomArray[i]];
}
return output;
}
}
class Program
{
static void Main()
{
string original = "Hello World!";
string mixedOriginal = Shuffle.StringMixer(original);
System.Console.WriteLine("The original string: {0}", original);
System.Console.WriteLine("A mix of characters from the original string: {0}", mixedOriginal);
System.Console.ReadKey();
}
}
    Cela fonctionnait très bien, merci.
    +1 pour l'idée de l'algorithme, nous avons un beaucoup plus courte version: rosettacode.org/wiki/Knuth_shuffle#C.23

    OriginalL'auteur János Dani

  5. 1

    inspiré de tsql' ordre par newid()

    static string shuffle(string input)
{
var q = from c in input.ToCharArray()
orderby Guid.NewGuid()
select c;
string s = string.Empty;
foreach (var r in q)
s += r;
return s;
}
    newid est unique, non pas aléatoire

    OriginalL'auteur Khurram Aziz

  6. 1

    La meilleure façon de mélanger une chaîne ou une liste de chaînes à l'aide de cette façon. Ici vous n'aurez pas de doublons:

    class CardsDeck
{
public static Random r = new Random();
private static List<string> cards = new List<string>{ "♣ King", "♣ Queen", "♣ Jack", " ♣", "♣ 7", "♣ 8", "♣ 9", "♣ 10",
"♦ King", "♦ Queen", "♦ Jack", " ♦", "♦ 7", "♦ 8", "♦ 9", "♦ 10",
"♥ King", "♥ Queen", "♥ Jack", " ♥", "♥ 7", "♥ 8", "♥ 9", "♥ 10",
"♠ King", "♠ Queen", "♠ Jack", " ♠", "♠ 7", "♠ 8", "♠ 9", "♠ 10" };
public string ReceiveCards()
{
if (cards.Count > 0)
{
int index = r.Next(cards.Count);
var card = cards[index];
cards.RemoveAt(index);
return card;
}
else
{
return "";
}
}
}
    Non, ce n'est pas la meilleure façon. Bien qu'il évite les doublons, c'est horriblement inefficace. Le shuffle de Fisher-Yates mentionné ailleurs est une bien meilleure façon de le faire.

    OriginalL'auteur syd_buet

  7. 0

    Vous pouvez essayer quelque chose comme ça..

    class Program
{
static bool IsPositionfilled(int Position, List<int> WordPositions)
{
return WordPositions.Exists(a => a == Position);
}
public static string shufflestring(string word)
{
List<int> WordPositions = new List<int>();
Random r = new Random();
string shuffledstring = null;
foreach (char c in word)
{
while (true)
{
int position = r.Next(word.Length);
if (!IsPositionfilled(position, WordPositions))
{
shuffledstring += word[position];
WordPositions.Add(position);
break;
}
}
}
return shuffledstring;
}
static void Main(string[] args)
{
string word = "Hel";
Hashtable h = new Hashtable();
for (int count = 0; count < 1000; count++)
{
Thread.Sleep(1);
string shuffledstring = shufflestring(word);
if (h.Contains(shuffledstring))
h[shuffledstring] = ((int)h[shuffledstring]) + 1;
else
h.Add(shuffledstring,1);
}
Console.WriteLine(word);
foreach (DictionaryEntry e in h)
{
Console.WriteLine(e.Key.ToString() + " , " + e.Value.ToString()); 
}
}
}

    OriginalL'auteur Murtaza zaidi

  8. 0
    class Program
{
static void Main(string[] args)
{
string word = "hello";
string temp = word;
string result = string.Empty;
Random rand = new Random();
for (int a = 0; a < word.Length; a++)
{
//multiplied by a number to get a better result, it was less likely for the last index to be picked
int temp1 = rand.Next(0, (temp.Length - 1) * 3);
result += temp[temp1 % temp.Length];
temp = temp.Remove(temp1 % temp.Length, 1);
}
Console.WriteLine(result);
}
}

    OriginalL'auteur Noman Aftab

  9. 0

    - Je y arriver avec cette extension:

    public static class Extensions{
public static string Scramble(this string s){
return new string(s.ToCharArray().OrderBy(x=>Guid.NewGuid()).ToArray());
}
}
    Sérieusement, j'aimerais savoir quel est le problème avec cela. Il est assez rapide, une ligne simple et facile à lire, et ça fonctionne.
    GUID est unique, non pas aléatoire

    OriginalL'auteur Roy Ashbrook

  10. -1

    J'ai essayé l'ancienne manière de le faire, celui-ci fonctionne très bien.

        static void Main()
{        
string input = "hello";
string output = "";
int ranIndex = 0;
List<int> indexes = new List<int>();
char[] split = input.ToCharArray();
Random ran = new Random();
for (int i = 0; i < input.Length; i++) 
{
ranIndex = ran.Next(0, input.Length);
if (!indexes.Contains(ranIndex))
{
indexes.Add(ranIndex);
}
else 
{
i--;
}
}
foreach (int value in indexes) 
{
output += split[value];
}
Console.WriteLine(output);
Console.ReadLine();
}
    pourquoi la baisse de vote?

    OriginalL'auteur Rye

  11. -1

    De Fisher-Yates

    static Random rand = new Random();
public static string ShuffleString(string s)
{
if (string.IsNullOrEmpty(s))
return s;
char[] chars = s.ToCharArray();
char c;
int j;
for(int i = chars.Length - 1; i > 0; i--)
{
j = rand.Next(i + 1);  //Next max is exclusive
if (j == i)
continue;
c = chars[j];
chars[j] = chars[i];
chars[i] = c;
}
return chars.ToString();
}
    Fonctionne bien sauf chars.ToString() retourne toujours un littéral "Système".Char[]". La ligne return chars.ToString(); devrait être return new string(chars);
    Cela n'empêche pas le jeu d'origine, il remplace les caractères ne sont pas utilisés.

    OriginalL'auteur paparazzo