Untitled

import time

# Lista przechowująca dane wejściowe
input_data = []

winning_rooms = []  # zbiór kluczowy do wygranej - X
lista_polozen = []  # gdzie jest dziecko w danym kroku, lista ta zawiera słowniki licząc dzieci
siatka = []  # siatka polega na liście 2 wymiarowej

# Odczyt danych z pliku
with open('test3', 'r') as data_in:
    for i in data_in:
        line = []
        for element in i.split():
            line.append(
                int(element) if element.isdigit() else element)  # Konwersja elementów na liczby całkowite oprócz drzwi ABCD
        input_data.append(line)
# print(input_data)

rooms = int(input_data[0][0])  # liczba pokoi
kids = int(input_data[1][0])  # liczba dzieci
input_pattern = str(input_data[4][0])  # Cały ciąg wprowadzonego patternu, np. CAD
pattern = []  # tu przechowywane są odrębne kroki, potem zamieniane na przypisane krokom wartości

for i in range(len(input_pattern)):
    pattern.append(input_pattern[i])  # kroki drzwi np. CAD zamieniane na 'C' 'A' 'D'
    if pattern[i] == 'A':  # od tego momentu zamieniamy na wartości liczbowe
        pattern[i] = 0
    elif pattern[i] == 'B':
        pattern[i] = 1
    elif pattern[i] == 'C':
        pattern[i] = 2
    elif pattern[i] == 'D':
        pattern[i] = 3
# print(pattern)

for i in input_data[3]:  # wrzucamy do listy kluczowe pokoje zapewniające wygraną
    winning_rooms.append(int(i))

for i in range(kids):  # pętla przypisuje każdemu dziecku numer pokoju startowego
    lista_polozen.append({i: int(input_data[2][i])})

# print(lista_polozen)

# tworzenie siatki
for i in range(5, 5 + rooms):  # od piątego wiersza zaczyna się definicja siatki
    siatka.append(input_data[i])
# print(siatka)

# Używamy patternu ABCD, pokoi w związku z położeniem dzieci na siatce
step = 1
pattern_choice = 0  # śledzi i pilnuje, aby pattern był po kolei, np. C -> A -> D (i od początku)
zmiany = lista_polozen[:]  # lista przechowująca zmienione miejsca dzieci
timeout = time.time() + 120  # 10 sekund od tego momentu w programie

while True:
    output = 0  # pokazuje, czy gra się skończy sukcesem

    for kid_movement in range(kids):
        x = lista_polozen[kid_movement]  # `x` przechowuje słownik aktualnego dziecka
        current_room = x[kid_movement]  # numer pokoju, w którym aktualnie jest dziecko
        next_room = siatka[current_room - 1][pattern[pattern_choice]]  # -1 bo indeksy zaczynają się od 0, a pokój od 1
        x[kid_movement] = next_room

        # Sprawdzenie, czy dziecko dotarło do pokoju wygrywającego
        if next_room in winning_rooms:
            output += 1

    # Sprawdzenie cyklu
    if pattern_choice == len(pattern):
        pattern_choice = 0
        current_positions_sorted = sorted([x[list(x.keys())[0]] for x in lista_polozen])
        previous_positions_sorted = sorted([x[list(x.keys())[0]] for x in zmiany])

        if current_positions_sorted == previous_positions_sorted:
            print("\nNIE")
            break
        else:
            zmiany = lista_polozen[:]  # Kopiowanie aktualnych pozycji

    if output == kids or time.time() > timeout:
        break

    pattern_choice += 1
    if pattern_choice >= len(pattern):
        pattern_choice = 0
    step += 1

if output == kids:
    print("\nGra została wygrana po", step, "krokach.")
else:
    print("\nNIE")