Liste mit bestimmten Bedingungen ausgeben

[simsalabim]

Hallo liebe Community,

vom User eingegeben werden, soll eine Zahlenfolge. Diese Zahlenfolge soll nun in einzelne Listen oder Arrays mit 2-4 Ziffern zerlegt werden, wobei möglichst wenige mit Null beginnen sollen, sofern die ursprüngliche Zahlenfolge nullen aufweist. Mein Problem ist nun, dass ich nicht weiß, wie ich alle Möglichkeiten abdecken kann, um die Anzahl der Nullen zu minimieren. Ich kann versuchen immer eine if-Anweisung zu schreiben, doch das ist bei hinreichend großer Zahlenfolge unpraktisch. Außerdem weiß ich bei evt. Verwendung der for-Schleife nicht, wie ich die Anzahl der max. Ziffern sinnvoll einsetzen kann. (for i in range(len(liste))(?))
Habt ihr Vorschläge, wie so ein Algorithmus aussehen könnte? Mein derzeitiger Code sieht so aus:

Code: Alles auswählen

from numpy import*

liste =[]
ziffernanzahl = int(input('Anzahl der Ziffern:'))
for i in range(ziffernanzahl):
    ziffern = int(input())
    liste.append(ziffern)

liste2= []
def zerlegung(liste):
    liste2 = liste[:3], liste[3:6], liste[6:]...
    if liste[3]==0:
        liste2 =liste[:4],liste[4:6], liste[6:]...
        ...
    return liste2

print(zerlegung(liste))

Viele Grüße simsalabim

[ThomasL]

Bei solchen Fragestellungen ist es sehr hilfreich wenn dazu Beispiele geliefert werden.
Also, wie sehen mögliche Zahlenfolgen aus, wie lang sind sie, alle Infos die es dazu geben kann.
Dann zu verschiedenen Folgen die von dir gedachten Zerlegungen, wie sollen die aussehen, welche konkreten Regeln gibt es.
So etwas nur mit Worten zu beschreiben führt in den meisten Fällen nicht direkt zum Ziel.

[__blackjack__]

Die Beispiele (und die tatsächliche Aufgabe) dürfte wohl das hier sein: viewtopic.php?f=1&t=47039#p356576

[Sirius3]

@simsalabim: solche Art Problem läßt sich am einfachsten mit Rekursion lösen. Man nimmt 2-4 Ziffern und ruft mit dem Rest die gleiche Funktion nochmal auf.

Wer die Aufgabenstellung komplett und in bunt lesen will: https://bwinf.de/fileadmin/BwInf/38/BwI ... nblatt.pdf

[simsalabim]

Ah, vielen Dank... Ja, das ist die Aufgabenstellung, die ich zufällig aufschnappte. Ich wusste nicht, dass es dazu bereits einen Thread gibt. Ich gucke es mir mal an. Danke^^

[simsalabim]

Kann man das mit Rekursion dann so schreiben? Ich denke zumindest, dass es funktioniert. Das Ergebnis sieht zwar auf dem ersten Blick etwas verwirrend aus, aber nur weil die verwendete Zahlenfolge von hinten angefangen, bearbeitet wurde.

Code: Alles auswählen

liste =[]

liste2 =[]

liste = [0,0,5,4,8,0,0,0,0,0,0,5,1,7]
def zerlegung(liste):
    if len(liste)<=4:
        return liste2.append(liste[0:4])
    if liste[-2]!=0:
        liste2.append(liste[-2:])
        geloescht=2
    elif liste[-3]!=0:
        liste2.append(liste[-3:])
        geloescht=3
    elif liste[-4]!=0:
        liste2.append(liste[-4:])
        geloescht=4
    else:
        liste2.append(liste[-4:])
        geloescht= 4
    return zerlegung(liste[:len(liste)-geloescht]), liste2

print(zerlegung(liste))

Ergebnis:

Code: Alles auswählen

(((None, [[1, 7], [0, 0, 0, 5], [8, 0, 0, 0], [0, 0, 5, 4]]), [[1, 7], [0, 0, 0, 5], [8, 0, 0, 0], [0, 0, 5, 4]]), [[1, 7], [0, 0, 0, 5], [8, 0, 0, 0], [0, 0, 5, 4]])

[__blackjack__]

@simsalabim: Wieso denkst Du das das funktioniert? Was heisst denn ”funktioniert” genau? Erklär doch mal was das Ergebnis da bedeuten soll. Wie viele Elemente hat das Ergebnis und was bedeuten die?

Edit: Und das ist keine saubere Funktion. Funktionen verändern nicht einfach irgendwelche Variablen ausserhalb. Auf Modulebene sollte es gar keine Variablen geben sondern nur Konstanten, Funktionen, und Klassen.

[simsalabim]

Das denke ich, da die Beispiele, die ich durchrechnen ließ, insbesondere der auf der Webseite vorgestellten Zahlenfolgen, mir vernünftig erscheinende Ausgaben lieferten. Damit meine ich, dass alle Blöcke zwei bis vier Ziffern beinhalten und versucht wird, die Anzahl der Nullen am Anfang zu minimieren...

Ich habe es ja versucht so zu programmieren, dass die verwendete Liste immer kürzer wird. Das None bedeutet meiner Meinung nach also, dass die verwendete Liste nun leer ist. Im Anschluss daran wird die 'liste2' ausgegeben, die die originale Zahlenfolge von hinten nach vorne in Blöcken ausgibt. Wie man das nun schafft, dass das Ganze nur einmal ausgegeben wird, weiß ich nicht, denn bei return musste ich auf jeden Fall beides aufführen, sodass ein Ergebnis ausgegeben werde konnte.

Und wie würde ich daraus eine 'saubere' Funktion machen? Die Variable kann ich ja schlecht in die Funktion reinstecken, da das Programm ja sonst nie zum Ende kommen würde.

Viele Grüße und noch einen schönen Abend!

[__blackjack__]

@simsalabim: Ähm, noch mal die Frage was das gezeigte Ergebnis ganz konkret bedeutet. Das ist doch offensichtlich sowohl von der Struktur als auch vom Inhalt kein sinnvolles Ergebnis. Das sind rekursiv verschachtelte Tupel mit einer Liste die da auf drei Ebenen drin steckt, also jedes mal die gleiche Liste, die jedes mal die gleiche Aufteilung der Ziffernfolge enthält.

Da ich nicht weiss was das ganze soll, kann ich auch nicht sagen wie Du mit `liste2` umgehen solltest, auf jeden Fall gehört das nicht auf Modulebene. ``Und return liste2.append(liste[0:4])`` macht auch keinen Sinn weil dieser Ausdruck *immer* `None` ergibt. Der Algorithmus ist auch nicht wirklich rekursiv. Den kann man leicht mit einer ``while``-Schleife ohne rekursiven Aufruf schreiben. Bleibt die Frage ob der immer das richtige Ergebnis liefert.

[__blackjack__]

Auch wenn ich nur vermuten kann was der Algorithmus eigentlich machen sollte, habe ich die Vermutung, dass er beispielsweise "42000" nicht richtig trennt.