Chcę utworzyć program, w którym użytkownik może wprowadzić, jaki maksymalny rozmiar grup jest to, że chcą. Grupy te są utworzone z listy nazw z formularza zgłoszeniowego. Chodzi o to, że istnieją wiele rund, w których nazwy są sparowane w żądanej maksymalnej wielkości grupy, a każda runda nie tworzy wcześniej utworzonych grup. Ponadto, nikt nie powinien zostać pominięty, więc nie ma grup jednej osoby.

Mam dwa problemy: Po pierwsze: Jeśli mam listę 10 nazw i wprowadzam, że chcę mieć maksymalne grupy grup 3 osób, dostaję 3 grupy 3 osób i 1 z 1, ale powinno być 3, 3, 2 , 2. Użyłem dwóch różnych funkcji, które tu znajdowałem, ale oba mają ten sam problem.

Po drugie, nie mam pojęcia, jak się upewnić, że w nowej rundzie nie będzie żadnych grup z poprzedniej rundy.

Jestem dość nowy w programowaniu, więc wszelkie wskazówki są mile widziane. Jest to pierwsza funkcja, którą mam:

members = group_size()

def teams(amount, size):
    for i in range(0, len(amount), size):
        yield amount[i:i + size]

participants = Row_list_names
random.shuffle(participants)

print("These are your groups:")
print(list(teams(participants, members)))

I to jest druga:

members = group_size()
participants = Row_list_names
random.shuffle(participants)
for i in range(len(participants) // members + 1):
    print('Group {} consists of:'.format(i+1)) 
    group = participants[i*members:i*members + members]
    for participant in group:
        print(participant)

Group_size () zwraca liczbę całkowitą, ile osób powinno być w grupie.

0
Casper 13 marzec 2021, 21:01

1 odpowiedź

Najlepsza odpowiedź

Dla drugiego problemu, tasowanie jak powinieneś ładnie zrobić sztuczkę.

Z pierwszego problemu funkcje robią to, co im powiesz: pomijasz się do przodu i pokroić listę w kawałki, które zawierają dokładnie member uczestnicy. Nie zauważysz, że ostatni plasterek jest poza związany, ponieważ Python jest w tym:

>>> l = [0,1,2,3,4]
>>> l[:40]
[0, 1, 2, 3, 4]

Chodzi o to, że nie wszystkie grupy powinny mieć tego samego rozmiaru:

from math import ceil
from math import floor

def split_groups(group_size, part):
    # first compute the number of groups given the requested size
    group_num = ceil(len(part) / group_size)
    print(f"group_num {group_num}")
    # compute a fractional length of the groups
    group_size_frac = len(part) / group_num
    print(f"group_size_frac {group_size_frac}")

    total_assigned = 0

    for i in range(group_num):
        # get the start and end indexes using the fractional length
        start = floor(i * group_size_frac)
        end = floor((i + 1) * group_size_frac)
        group = part[start:end]
        print(f"start {start} end {end} -> {group}")
        print(f"number of participants in this group {len(group)}")

        total_assigned += len(group)

    # check that we assigned all of the participants
    assert total_assigned == len(part)

Nie przetestowałem żadnej skrzynki krawędziowej, ale szybką kontrolę, biegając

for group_size in range(1, 5):
    for num_participants in range(10, 50):
        part = list(range(num_participants))
        split_groups(group_size, part)

Pokazuje, że każdy uczestnik został przydzielony do grupy.

Podłącz drapieżny, który zrobiłeś wcześniej i masz losowe grupy.

Twoje zdrowie!

0
Pietro 13 marzec 2021, 18:38