Auslosung mit Gruppen

[Zayju]

Hat sich schon geklärt. Sobald ich weiß wie man einen Eintrag lösche werde ich das tun

[nezzcarth]

Wenn du die Codetags im Forum verwendest, sehen die Einrückungen auch richtig aus Dein Code ist für mich leider nicht gut verständlich und wirkt zu kompliziert. Möchtest du einfach nur 16 Personen in vier 4er Teams einteilen, oder was ist das Ziel? Was hat es mit dem Leader auf sich?

[__blackjack__]

@Zayju: Also falls Du die 16 `members` auf vier gleich grosse Gruppen aufteilen willst, ist das da alles sehr viel und sehr komischer Code. Denn dafür würde man einfach die `members` mischen = eine Zeile Code mit der passenden Funktion aus dem `random`-Modul. Und dann die gemischte Liste mittels Slicing-Syntax + „list comprehension“ in vier gleich grosse Liste aufteilen = eine weitere Zeile Code.

Man nummeriert keine Namen durch – statt Nummern dafür Buchstaben zu nehmen macht das es vom Prinzip her nicht besser. Die vier Gruppen sollten in einer Datenstruktur stecken. Beispielsweise in einer Liste.

[Zayju]

Wenn du die Codetags im Forum verwendest, sehen die Einrückungen auch richtig aus Dein Code ist für mich leider nicht gut verständlich und wirkt zu kompliziert. Möchtest du einfach nur 16 Personen in vier 4er Teams einteilen, oder was ist das Ziel? Was hat es mit dem Leader auf sich?

Hier habe ich den Code neu geschrieben habe den Fehler schon entdeckt. Aber danke trotzdem. Ich mochte diesen Code auch überahupt nicht

[Zayju]

Wenn du die Codetags im Forum verwendest, sehen die Einrückungen auch richtig aus Dein Code ist für mich leider nicht gut verständlich und wirkt zu kompliziert. Möchtest du einfach nur 16 Personen in vier 4er Teams einteilen, oder was ist das Ziel? Was hat es mit dem Leader auf sich?

Hier habe ich den Code neu geschrieben habe den Fehler schon entdeckt. Aber danke trotzdem. Ich mochte diesen Code auch überahupt nicht

[einfachTobi]

Anstatt deinen ursprünglichen Beitrag zu löschen, wäre es hilfreich diesen stehen zu lassen und deine jetzige Lösung zu posten. So können Leute, die ein gleiches oder ähnliches Problem haben ebenfalls davon profitieren und müssen nicht die selbe Frage noch mal stellen.

[DeaD_EyE]

Das hab ich 10 Jahre lang ständig erlebt. Entweder man muss den Leuten förmlich die Information aus der Nase ziehen oder sie finden dann eine Lösung und sind dann für immer weg ohne die Lösung zu posten. Der nächste, der dann eine Frage hat, den Thread findet, wird enttäuscht und das tritt leider sehr häufig auf.

Es geht hier nicht darum das Gesicht zu verlieren, sondern zu lernen.
Wer niemals Fehler macht, der lernt auch nichts.

Jemand, der viele Fehler macht, kann aus diesen auch lernen und andere natürlich auch, was Sinn und Zweck eines Forums ist.

[__deets__]

Genau aus dem Grund kann man hier Beitraege nur einen beschraenkten Zeitraum lang bearbeiten, und nicht loeschen. @Zayju bitte in Zukunft nicht mehr so vorgehen.

[__blackjack__]

@Zayju: Mit Code-Tags bleibt die Einrückung erhalten und Dein Code sähe dann so aus:

Code: Alles auswählen

import random

Group_A = 4
Group_B = 4
Group_C = 4
Group_D = 4


#Gruppen
groups = ["Group A", "Group B", "Group C", "Group D"]


Gruppe_A = []

Gruppe_B = []

Gruppe_C = []

Gruppe_D = []

#Teams
members = ["Na'Vi", "Virtus Pro", "Mousesports", "FaZe Clan", "Astralis", "Ninjas in Pyjamas",
           "Team Liquid", "Fnatic", "Team Vitality", "Espada", "Ence", "Cloud 9", "G2 Esports",
           "OG", "Furia", "Complexity"]



print(f"{len(members)} teams are playing!")

for i in range(int(len(members))):
    leader = random.choice(members)
    members.remove(leader)
    #Gruppen Auswahl
    gruppe = random.choice(groups)


    # Gruppenfunktion
    def func():
        a = True
        b = True
        c = True
        d = True
        if Group_A <= 0 and a == True:
            groups.remove("Group A")
            a = False
        else:
            pass
#--------------------------------------------------------------------------
        if Group_B <= 0 and b == True:
            groups.remove("Group B")
            b = False
        else:
            pass
#--------------------------------------------------------------------------
        if Group_C <= 0 and c == True:
            groups.remove(("Group C"))
            c = False
        else:
            pass
#--------------------------------------------------------------------------
        if Group_C <= 0 and d == True:
            groups.remove(("Group D"))
            d = False
        else:
            pass



    if gruppe == "Group A":
        func()
        Gruppe_A.append(leader)
        Group_A -= 1


    elif gruppe == "Group B":
        func()
        Gruppe_B.append(leader)
        Group_B -= 1


    elif gruppe == "Group C":
        func()
        Gruppe_C.append(leader)
        Group_C -= 1

    elif gruppe == "Group D":
        func()
        Gruppe_D.append(leader)
        Group_D -= 1



print(Gruppe_A)
print(Gruppe_B)
print(Gruppe_C)
print(Gruppe_D)

Auch wenn der Code nicht so sinnvoll ist, trotzdem ein paar Anmerkungen dazu:

`Group_A` bis `Group_D` sind im Grunde redundante Informationen weil das herunterzählen und testen auf ≤0 ersetzt werden kann durch einen Test ob die entsprechene Gruppe bereits vier Einträge hat. Man kann von Listen ja die Länge ermitteln.

`members` sollte laut Kommentar und Textausgabe wohl eher `teams` heissen.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase). Falls man einen Namen braucht, der aber absichtlich nirgends verwendet wird, wie bei dem `i`, gibt es die Konvention `_` als Namen dafür zu verwenden, damit der Leser weiss, dass der Name nirgends verwendet wird.

`len()` liefert bereits eine ganze Zahl. Da noch mal `int()` mit aufzurufen macht also keinen Sinn.

Wobei man aus dem ``for``-Schleifenkopf auch einfach ein ``while teams:`` machen kann, da Du ja die Teams aus der Liste entfernst.

Funktionen definiert man nicht in einer Schleife, weil dann in jedem Schleifendurchlauf eine neue Funktion definiert wird, die sich in diesem Fall aber gar nicht von den anderen unterscheidet, die vorher und nachher in der Schleife definiert werden. Das macht keinen Sinn, und man kann die Funktion auch nicht separat testen oder wiederverwenden.

Funktionsnamen beschreiben üblicherweise die Tätigkeit der Funktion, damit der Leser weiss was die macht. `func()` ist also gar kein guter Funktionsname.

Funktionen und Methoden bekommen alles was sie ausser Konstanten benötigen als Argument(e) übergeben. `func()` benötigt also `groups`, und die vier Listen wenn man sich die extra Zähler spart die aus der Länge der Listen abgeleitet werden können.

Die `remove()`-Methode auf Listen sucht das zu entfernende Element linear in der Liste. Es wäre also effizienter im ersten Schritt nicht ein zufälliges Element zu wählen und das dann zu suchen/entfernen, sondern einen zufälligen Index zu wählen und den dann der `pop()`-Methode zu übergeben um sich das suchen zu sparen.

``else``-Zweige in denen nur ein ``pass`` stehen, machen keinen Sinn.

Die lokalen Namen `a` bis `d` machen keinen Sinn. Die werden mit `True` initialisiert und dann auf `True` getestet, was ja immer wahr sein muss, weil sie mit dem Wert ja kurz zuvor initialisiert wurden. Und dann werden sie eventuell auf `False` gesetzt, aber nie wieder verwendet. Ausser ein bisschen Rechenzeit verbrauchen und den Leser zu verwirren, passiert da nichts was einen Effekt auf den Programmablauf hätte.

Überarbeitet säher der (fehlerhafte) Code dann so aus:

Code: Alles auswählen

#!/usr/bin/env python3
import random

TEAMS_PER_GROUP = 4


def gruppenfunktion(groups, gruppe_a, gruppe_b, gruppe_c, gruppe_d):
    if len(gruppe_a) == TEAMS_PER_GROUP:
        groups.remove("Group A")

    if len(gruppe_b) == TEAMS_PER_GROUP:
        groups.remove("Group B")

    if len(gruppe_c) == TEAMS_PER_GROUP:
        groups.remove("Group C")

    if len(gruppe_d) == TEAMS_PER_GROUP:
        groups.remove("Group D")


def main():
    groups = ["Group A", "Group B", "Group C", "Group D"]
    teams = [
        "Astralis",
        "Cloud 9",
        "Complexity",
        "Ence",
        "Espada",
        "FaZe Clan",
        "Fnatic",
        "Furia",
        "G2 Esports",
        "Mousesports",
        "Na'Vi",
        "Ninjas in Pyjamas",
        "OG",
        "Team Liquid",
        "Team Vitality",
        "Virtus Pro",
    ]
    print(f"{len(teams)} teams are playing!")

    gruppe_a = []
    gruppe_b = []
    gruppe_c = []
    gruppe_d = []
    while teams:
        leader = teams.pop(random.randrange(len(teams)))
        gruppe = random.choice(groups)
        if gruppe == "Group A":
            gruppenfunktion(groups, gruppe_a, gruppe_b, gruppe_c, gruppe_d)
            gruppe_a.append(leader)
        elif gruppe == "Group B":
            gruppenfunktion(groups, gruppe_a, gruppe_b, gruppe_c, gruppe_d)
            gruppe_b.append(leader)
        elif gruppe == "Group C":
            gruppenfunktion(groups, gruppe_a, gruppe_b, gruppe_c, gruppe_d)
            gruppe_c.append(leader)
        elif gruppe == "Group D":
            gruppenfunktion(groups, gruppe_a, gruppe_b, gruppe_c, gruppe_d)
            gruppe_d.append(leader)
        else:
            assert False, f"unexpexted group {gruppe!r}"

    print(gruppe_a)
    print(gruppe_b)
    print(gruppe_c)
    print(gruppe_d)


if __name__ == "__main__":
    main()

Hier wäre mein Ansatz das Problem zu lösen:

Code: Alles auswählen

#!/usr/bin/env python3
import random

GROUP_COUNT = 4


def main():
    teams = [
        "Astralis",
        "Cloud 9",
        "Complexity",
        "Ence",
        "Espada",
        "FaZe Clan",
        "Fnatic",
        "Furia",
        "G2 Esports",
        "Mousesports",
        "Na'Vi",
        "Ninjas in Pyjamas",
        "OG",
        "Team Liquid",
        "Team Vitality",
        "Virtus Pro",
    ]
    print(f"{len(teams)} teams are playing!")
    
    if len(teams) % GROUP_COUNT != 0:
        print(f"Can't evenly divide {len(teams)} into {GROUP_COUNT} groups!")
        return
    
    random.shuffle(teams)
    groups = [
        teams[i : i + GROUP_COUNT] for i in range(0, len(teams), GROUP_COUNT)
    ]
    for group in groups:
        print(group)


if __name__ == "__main__":
    main()