Willkommen bei dotnet-snippets.de! Snippet hinzufügen Login Registrieren
Snippets in der Datenbank: 1562 | Anzahl registrierter User: 1893 | Besucher online: 55
Hauptmenü
Home
Top Ten
Zufälliger Snippet
FAQs
.NET Community
dotnet-forum.de
dotnet-kicks.de
Social

RSS Feeds
Rss Alle Snippets
Rss C#
Rss VB.NET
Rss C++
Rss ASP.NET
Partner
Member of Microsoft Community Leader/Insider Program (CLIP)

Erzeugen von Zeichenfolgen durch Permutation


Autor: marioka
Sprache: C#
Bewertung:
2.33 (2 votes)
Anzahl der Aufrufe: 4610
  
Kick it on dotnet-kicks.de  

Beschreibung:

Diese Funktion erzeugt ein string-Array mit string-Elementen, die aus 'chars' unterschiedlichen Zeichen und 'places' Stellen bestehen. Das Array beinhaltet alle möglichen Verknüpfungsmöglichkeiten dieser Zeichen, mit gegebener Anzahl an Stellen.

Die Funktion GetPermutation() liefert ein string[] Array. (empfohlen)
Die Funktion GetPermutationPerRef() schreibt die Ergebnisse in die ebenfalls zu übergebende ArrayList.

/* Beispiel zur Generierung einer 3-stelligen Bitfolge und anschließende Ausgabe. */

string[] Variationen = GetPermutation(3, new char[] { '0', '1' });

foreach (string Variation in Variationen)
{
Console.WriteLine(Variation);
}


Abgelegt unter: Permuation, Varianten, Variationen, Möglichkeiten, generieren, rekursiv, vertauschen, Anordnung, Binärfolge, Codegenerator, Codefolge, Kombinationen, Kombinatorik, Sortierung, sortieren, Rekursion, Algorithmus, Zeichenfolge, Permutiere, .



C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// Die folgende eine Zeile gehört an den Kopf der Seite
using System.Collections;

/// <summary>
/// Generiert ein Array, aus Elementen die jeweils aus 'chars' unterschiedlichen Zeichen bestehen, mit jeweils 'places' Stellen.
/// Das Array beinhaltet alle möglichen Verknüpfungsmöglichkeiten, die durch Permutation ermittelt werden.
/// </summary>
/// <param name="places">Anzahl der Stellen jedes Elements</param>
/// <param name="chars">Array von Zeichen die benutzt werden dürfen</param>
/// <returns>Ein string-Array mit allen unterschiedlichen Verknüpfungsmöglichkeiten</returns>
public static string[] GetPermutation(int places, char[] chars)
{
    // Eine neue, leere ArrayList generieren, an die alle Möglichkeiten angehängt werden
    ArrayList output = new ArrayList();
    GetPermutationPerRef(places, chars, ref output);

    // Das Ergebnis in einen string[] umwandeln und zurückgeben
    return output.ToArray(typeof(string)) as string[];
}

/// <summary>
/// Generiert ein Array, aus Elementen die jeweils aus 'chars' unterschiedlichen Zeichen bestehen, mit jeweils 'places' Stellen.
/// Das Array beinhaltet alle möglichen Verknüpfungsmöglichkeiten, die durch Permutation ermittelt werden.
/// Das Ergebnis wird in der als Referenz übergebenen ArrayList 'output' gespeichert.
/// </summary>
/// <param name="places">Anzahl der Stellen jedes Elements</param>
/// <param name="chars">Array von Zeichen die benutzt werden dürfen</param>
/// <param name="output">ArrayList in die alle Möglichkeiten hinzugefügt werden</param>
/// <param name="outputPart">Optionaler interner Parameter, zur Weitergabe der Informationen während des rekursiven Vorgangs</param>
private static void GetPermutationPerRef(int places, char[] chars, ref ArrayList output, string outputPart = "")
{
    if (places == 0)
    {
        // Wenn die Anzahl der Stellen durchgerechnet wurde,
        // wird der sich ergebende string (Element) an die Ausgabe angehängt.
        output.Add(outputPart);
    }
    else
    {
        // Für die Stelle rechts im Element, werden alle Zeichenmöglichkeiten durchlaufen
        foreach (char c in chars)
        {
            // Danach wird für jedes dieser Zeichen, basierend auf der Anzahl der Stellen, wieder ein neuer
            // foreach-Vorgang begonnen, der alle Zeichen der nächsten Stelle hinzufügt

            GetPermutationPerRef(places - 1,   // Die Stellen Anzahl wird verwindert, bis 0
                chars,                         // Benötigte Variablen werden
                ref output,                    // mitübergeben
                outputPart + c);               // An diesen letzen string werden alle anderen Stellen angehängt
        }
    }
}
Sie haben Fragen zu diesem Snippet oder brauchen Hilfe bei der .NET Entwicklung?
Freundliche und kompetente Entwickler helfen Ihnen gern weiter im Forum für .NET Entwicklung.



Kommentare:
(Zum Schreiben von Kommentaren bitte anmelden.)

Keks1911 schrieb am:  10.01.2011 10:34:10

In der jetzigen Form (und meiner Testkonfiguration) können maximal 10-stellige Permutationen errechnet werden, bevor der Speicher ausgeht. (also für places < 10)
marioka schrieb am:  11.01.2011 19:19:50

Hmm, ja leider. Bei 10 Stellen gibt es ja schon verdammt viele Möglichkeiten, wenn man viele Zeichen verwendet.
Man könnte bei der Funktion GetPermutationPerRef(), immer dann wenn die ArrayList.Count > 1.000.000 (angenommen) ist, das ganze in eine Datei schreiben und die ArrayList wieder löschen.
So kann man das ganze wenigstens auf die Festplatte auslagern und der RAM wird nicht belastet.

        private static void GetPermutationPerRef(int places, char[] chars, ref ArrayList output, string outputPart = "")
{
if (places == 0)
{
output.Add(outputPart);

if (output.Count > 1000000)
{
System.IO.StreamWriter sw = new System.IO.StreamWriter(@"permutation.txt", true);

foreach (string s in output)
{
sw.WriteLine(s);
}

sw.Close();
output.Clear();
}
}
...
...


Diese Snippets könnten für Sie interessant sein:
[C#] Passwort generieren
[C#] T-SQL-Stored-Proc Generieren
[VB.NET] Passwortgenerator
[C#] rekursiver Verzeichnislauf
[C#] Eigenschaften aller Steuerlemente eines Formulars setzen
[C#] Treeview rekursiv durchsuchen
[VB.NET] Ordergröße rekursiv bestimmen
[C#] Dateien und Ordner rekursiv löschen
[C#] Ordnergröße ermitteln
[C#] Ordner und Dateien rekursiv durchlaufen
[C#] Ordner mit Inhalt kopieren (rekursiv)
[C#] FTP - Ordner Rekursiv erstellen
[VB.NET] Größter gemeinsamer Teiler
[VB.NET] Fibonacci-Folge iterativ erzeugen
[VB.NET] Binomialkoeffizient
[C#] Dateien mit bestimmter Extension rekursiv in Array einlesen
[C#] Verhindern das Funktion rekursiv aufgerufen wird.
[VB.NET] Größter gemeinsamer Teiler (2)
[C#] C# Ordner auslesen und in Liste speichern "rekursiv"
[C#] Sort and search an ArrayList.
[VB.NET] Bucketsort Algorithmus für VB2005
[C#] BubbleSort Verfahren / Algorithmus
[VB.NET] Sortierte Liste der seriellen Ports
[VB.NET] Dateien nach Datum sortieren
[C#] ListView Spalten sortieren
[C#] SortableBindingList
[C#] Bubblesort
[C#] Rekursion Treeview
[C#] Integers
[C#] Search Plugin-DLLs with one line
[C#] sehr einfacher Timer
[C#] BindingList mit Sortierfunktion
[C#] Datei öffnen
[C#] byte-String in byte wandeln
[C#] Excel Spalten Bezeichnung nach Integer
[C#] Prozentual Textvergleichen
[C#] Console in eigene Form einbinden
[C#] Programm am Desktop andocken
[C#] lokale User und Gruppen administrieren
[C#] SimpleDb
[C#] Primärschlüsselwerte ermitteln
[C#] Automatisches Umbenennen eines Pfades
[C#] Connection-String Dialog öffnen
[C#] URL auslesen
[C#] Silverlight Anwendung erstellen
[C#] Text codieren
[VB.NET] ''Enter'' in TextBox
[C#] Programm RUN Check
[C#] Zufälliger Eintrag aus einer Liste (Extension Method)
[C#] XAML Grundlagen in Silverlight 3
[C#] MakeNiceSize()
[C#] 22 System Pfade abfragen
[C#] Zahlensysteme (BIN, HEX, OCT, DEZ) umrechnen
[C#] Form ohne Rahmen verschieben
[C#] Byte-Array in Struktur kopieren
[C#]
[VB.NET] Treenode-Tags zur verwendung abfragen [für Anfänger]
[C#] String to char Tarnung

schlecht sehr gut
1 2 3 4 5 6 7 8 9 10
Nur angemeldete User können Snippets bewerten.