import random


class FiniteAutomaton:
    def __init__(
        self,
        transitions: dict[str, list[tuple[str, str]]],
        initial_state: str,
        final_states: set[str],
        alphabet: set[str],
    ):
        self.transitions = transitions
        self.initial_state = initial_state
        self.final_states = final_states
        self.alphabet = alphabet

    def _get_next_state(self, current_state: str, char: str) -> str | None:
        if current_state in self.transitions:
            for transition, next_state in self.transitions[current_state]:
                if char in transition:
                    return next_state
        return None

    def process_input(self, input_string: str) -> tuple[str, list[str]]:
        current_state = self.initial_state
        transitions_path = [current_state]

        for char in input_string:
            if char not in self.alphabet:
                return f"Символ '{char}' не из алфавита", transitions_path

            next_state = self._get_next_state(current_state, char)

            if next_state is None:
                return "Строка не соответствует", transitions_path

            transitions_path.append(next_state)
            current_state = next_state

        return (
            "Строка соответствует"
            if current_state in self.final_states
            else "Строка не соответствует"
        ), transitions_path

    def generate_random_string(self, stop_probability: float = 0.3) -> str:
        result = []
        current_state = self.initial_state

        while True:
            if (
                current_state in self.final_states
                and random.random() < stop_probability
            ):
                break

            transition, next_state = random.choice(self.transitions[current_state])

            char = random.choice(transition)
            result.append(char)
            current_state = next_state

        return "".join(result)