Shuffle string c#

Ich will wissen, shuffle string

Beispiel string

string word;

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

Ich in der Lage wäre:

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

InformationsquelleAutor ksmakkapawee | 2011-01-19

algorithm c#ironpython

Diese Lösung (in form von extension-Methode) ist schön:

    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);
    }

Dies ist nicht eine einheitliche shufflw

InformationsquelleAutor nan

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());
```
Dies wird nicht die Ausbeute eines guten zufällige Ergebnis. Laut MSDN OrderBy wird durch ein stabiles Sortieren und zu bewahren, um für die Zeichen, die gegeben werden, den gleichen Wert. Für das "h" in "Hallo" zu setzen, letzten, 'h' muss roll 'false' und der rest 'true'. Allerdings wird das Ergebnis "elloh", das ist nicht sehr spannend. msdn.microsoft.com/en-us/library/bb534966.aspx

InformationsquelleAutor BvdVen

Du suchst so etwas wie die Fisher–Yates-shuffle. Gibt es eigentlich ein Python-Beispiel auf dieser Seite:

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: Da Ihre Frage markiert sowohl ironpython und c# gibt es auch ein Java-Beispiel, die man sehr einfach in C#.

InformationsquelleAutor porges

Versuchen, 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();
    }
}

Dies hat Super geklappt, danke.
+1 für die Idee des Algorithmus ist, haben wir ein viel mehr kurze version unter: rosettacode.org/wiki/Knuth_shuffle#C.23

InformationsquelleAutor János Dani

inspiriert von tsql' order by 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 einzigartig ist nicht zufällig

InformationsquelleAutor Khurram Aziz

Der beste Weg, um shuffle ein string oder eine Liste von strings ist mit diesem Weg. Hier erhalten Sie keine Duplikate:

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 "";
        }
    }
}

Nein, das ist nicht der beste Weg. Obwohl es vermeidet, Duplikate, es ist schrecklich ineffizient. Der Fisher-Yates-shuffle an anderer Stelle erwähnt ist ein viel besserer Weg, es zu tun.

InformationsquelleAutor syd_buet

Könnten Sie versuchen, einige Sache wie diese..

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()); 
        }
    }
}

InformationsquelleAutor Murtaza zaidi

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);
    }
}

InformationsquelleAutor Noman Aftab

0

Ich dazu diese Erweiterung:
```
public static class Extensions{
    public static string Scramble(this string s){
        return new string(s.ToCharArray().OrderBy(x=>Guid.NewGuid()).ToArray());
    }
}
```
Im ernst, ich würde gerne wissen, was ist falsch mit diesem. Es ist ziemlich schnell, eine einzige Zeile, und leicht zu Lesen und es funktioniert.
GUID einzigartig ist nicht zufällig

InformationsquelleAutor Roy Ashbrook

-1

Ich versuchte, die alte Schule Weg, es zu tun, dieser funktioniert einwandfrei.

    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();
    }

warum nach unten Stimmen?

InformationsquelleAutor Rye

-1

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();
}

Funktioniert gut, außer chars.ToString() gibt immer ein literal " - System.Char[]". Die Linie return chars.ToString(); sollte return new string(chars);
Dies bedeutet nicht, dass das original gesetzt, überschreibt es die chars nicht verwendet.

InformationsquelleAutor paparazzo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.