Ich möchte ein Programm schreibt, dass jede mögliche Kombination zu einer anderen Zeile einer text Datei

Ich soll ein Programm schreiben, das würde zu drucken jede Kombination von Variablen in eine text-Datei, erstellen Sie eine Wortliste. Jede Antwort, die geschrieben werden sollen, in einer separaten Zeile und schreiben Sie alle Ergebnisse zum 1 Ziffer, 2 Ziffern und 3 Ziffern zu einer einzigen text-Datei.

Gibt es eine einfache Möglichkeit, die ich können schreiben, ein python-Programm, die dies erreichen können? Hier ist ein Beispiel der Ausgabe, die ich erwarte, wenn der Druck aller die binäre Zahl-Kombinationen möglich für 1, 2, und 3 Ziffern:

zunächst ist es super einfach, wenn Sie irgendwelche Programmier-Erfahrungen überhaupt. zweitens, warum würden Sie wollen sogar, dies zu tun? Ich kann mir nicht vorstellen, dass es eine guten Grund für dies alles. Vielleicht, wenn Sie uns sagen, warum, wir können helfen, Steuern Sie besser.
Ich habe keine Programmierkenntnisse, andere als Verständnis der grundlegenden Konzepte dahinter. Dies ist vor allem wegen meiner eigenen Neugier, mir helfen zu verstehen die Programmierung besser aus theoretischer Sicht.
Dies ist definitiv nicht der Weg, um zu gewinnen besseres Verständnis der theoretischen Konzepte der Programmierung. Wenn Sie das tun wollen, Lesen Sie einige Bücher, das Internet durchsuchen und versuchen zu lösen das problem auf eigene Faust. Es scheint mir, dass Sie nur möchten, dass wir Ihre Hausaufgaben für Sie.
Hat Ihr Lehrer Ihnen erlauben, die Verwendung von python 2.6 oder 3.0? Wenn ja, wird die standard-library kommt die Rettung.

InformationsquelleAutor |

python recursion

3

Naive Lösung, die das problem löst und ist allgemein genug für jede Anwendung, die Sie haben könnten, ist diese:
```
def combinations(words, length):
    if length == 0:
        return []
    result = [[word] for word in words]
    while length > 1:
        new_result = []
        for combo in result:
            new_result.extend(combo + [word] for word in words)
        result = new_result[:]
        length -= 1
    return result
```
Grundsätzlich, das allmählich baut sich einen Baum im Speicher, der alle Kombinationen, und dann gibt Sie zurück. Es ist Speicher-intensiv, aber, und so ist unpraktisch für groß angelegte Kombinationen.

Andere Lösung für das problem ist in der Tat zu verwenden, zu zählen, aber dann transformieren die erzeugten zahlen in einer Liste von Wörtern aus der Wortliste. Dazu müssen wir zunächst eine Funktion (genannt number_to_list()):
```
def number_to_list(number, words):
    list_out = []
    while number:
        list_out = [number % len(words)] + list_out
        number = number // len(words)
    return [words[n] for n in list_out]
```
Dies ist in der Tat, ein system für die Umwandlung von dezimalen zahlen zu anderen Basen. Wir schreiben dann die Funktion zählen; das ist relativ einfach, und machen den Kern der Anwendung:
```
def combinations(words, length):
    numbers = xrange(len(words)**length)
    for number in numbers:
        combo = number_to_list(number, words)
        if len(combo) < length:
            combo = [words[0]] * (length - len(combo)) + combo
        yield combo
```
Dies ist ein Python-generator, so dass es ein generator ermöglicht die Verwendung weniger RAM. Es ist ein wenig Arbeit zu tun, nachdem Sie die Zahl in eine Liste von Wörtern; dies ist, da diese Listen müssen Polsterung, so dass Sie auf die gewünschte Länge. Es würde werden wie folgt verwendet:
```
>>> list(combinations('01', 3))
[['0', '0', '0'], ['0', '0', '1'],
['0', '1', '0'], ['0', '1', '1'],
['1', '0', '0'], ['1', '0', '1'],
['1', '1', '0'], ['1', '1', '1']]
```
Wie Sie sehen können, erhalten Sie eine Liste von Listen. Jede dieser sub-Listen enthält, eine Sequenz der ursprünglichen Worte; Sie könnten dann etwas tun, wie map(''.join, list(combinations('01', 3))) abrufen, die Folgendes Ergebnis:
```
['000', '001', '010', '011', '100', '101', '110', '111']
```
Könntest du dann schreiben Sie diese auf die Festplatte; eine bessere Idee, jedoch wäre die Nutzung der eingebauten Optimierungen, die Generatoren haben, und tun Sie etwas wie dieses:
```
fileout = open('filename.txt', 'w')
fileout.writelines(
    ''.join(combo) for combo in combinations('01', 3))
fileout.close()
```
Diese wird nur so viel RAM wie nötig (genug, um eine Kombination). Ich hoffe, das hilft.

InformationsquelleAutor
3
```
# Given two lists of strings, return a list of all ways to concatenate
# one from each.
def combos(xs, ys):
    return [x + y for x in xs for y in ys]

digits = ['0', '1']
for c in combos(digits, combos(digits, digits)):
    print c

#. 000
#. 001
#. 010
#. 011
#. 100
#. 101
#. 110
#. 111
```
- Hierdurch wird die Lagerung intensive, wenn die sets sind groß - aber wahrscheinlich können Sie effektiv argumentieren, dass die Speicherung auf die Festplatte wird teuer bei der gleichen Zeit.
- Es ist wahrscheinlich ein Weg, um Adresse, die mit einem generator Verständnis an die Stelle der Liste Verständnis, aber das würde erfordern, dass eine Kopie des input-iterator. (Sie können nur die go über einen iterator einmal. Dang Python für nicht in Haskell!)
- Also statt würde ich schreiben das offensichtliche rekursive Codes mit no-Generatoren.
InformationsquelleAutor
2

Sollte es nicht allzu schwer sein, in den meisten Sprachen. Tut der folgende pseudo-code helfen?
```
for(int i=0; i < 2^digits; i++)
{
     WriteLine(ToBinaryString(i));
}
```
- Das funktioniert für binary digit - strings-und kann wahrscheinlich gemacht werden, um die Arbeit für die meisten stellige Zeichenfolgen. Es wird nicht leicht anpassen, um mehr beliebige Dinge, wie zum Beispiel eine Menge von Wörtern.
- Wenn Sie die Behandlung jedes Wortes als Ziffer in einer n-Basis-system, dann funktioniert es.
InformationsquelleAutor

Eine basic-Funktion zu produzieren, die alle Permutationen einer Liste ist unten gegeben. In diesem Ansatz, Permutationen verzögert erstellt mithilfe von Generatoren.

def perms(seq):
    if seq == []:
        yield []
    else:
        res = []
        for index,item in enumerate(seq):
            rest = seq[:index] + seq[index+1:]
            for restperm in perms(rest):
                yield [item] + restperm

alist = [1,1,0]
for permuation in perms(alist):
    print permuation

Haben Sie verwenden möchten, [1,1,0] anstelle von nur [1,0]? Wenn ja, bitte erklären.
Die Frage scheint zu sein, über die powersets, nicht Permutationen. Dieser code erzeugt n! Ergebnisse, nicht auf 2**n ergibt.

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.