---

import random

# 1. Эталоны (обучающая выборка)
num4   = list('101101111001001')   # 4 обычная
num4_h = list('001001111101101')   # 4, отражение по горизонтали
num4_v = list('101101111100100')   # 4, отражение по вертикали

etalons = [num4, num4_h, num4_v]
names = [
    "4 обычная",
    "4 отражение по горизонтали",
    "4 отражение по вертикали"
]

# 2. Однослойная ИНС (обучение с учителем)
# 15 входов, 3 выхода (по одному на каждый класс)
weights_1 = [[0 for _ in range(15)] for _ in range(3)]
bias_1 = [7, 7, 7]  # пороги функции активации


def net_output_1(inputs, cls):
    """Взвешенная сумма для класса cls (однослойная сеть)"""
    s = 0
    for i in range(15):
        s += int(inputs[i]) * weights_1[cls][i]
    return s


def activate_1(s, cls):
    """Пороговая функция активации"""
    return 1 if s >= bias_1[cls] else 0


def train_one_layer(epochs=10000):
    """Обучение однослойной ИНС с учителем (правило перцептрона)"""
    for _ in range(epochs):
        cls = random.randint(0, 2)          # случайный класс
        inputs = etalons[cls]

        for c in range(3):
            target = 1 if c == cls else 0
            s = net_output_1(inputs, c)
            y = activate_1(s, c)

            if y != target:
                # Коррекция весов
                for i in range(15):
                    if int(inputs[i]) == 1:
                        if target == 1:
                            weights_1[c][i] += 1
                        else:
                            weights_1[c][i] -= 1


def predict_one_layer(inputs):
    """Предсказание однослойной ИНС (возвращает взвешенные суммы)"""
    scores = []
    for c in range(3):
        s = net_output_1(inputs, c)
        scores.append(s)
    return scores


# 3. Многослойная ИНС (обучение с учителем)
class NeuralNetwork:
    def __init__(self, layers, weights):
        self.layers = layers
        self.weights = weights

    def feed_forward(self, inputs):
        current = [int(x) for x in inputs]
        self.hidden_output = []
        self.final_output = []

        # Скрытый слой
        for j in range(self.layers[1]):
            summ = 0
            for i in range(self.layers[0]):
                summ += current[i] * self.weights[0][i][j]
            self.hidden_output.append(summ)

        # Выходной слой
        for j in range(self.layers[2]):
            summ = 0
            for i in range(self.layers[1]):
                summ += self.hidden_output[i] * self.weights[1][i][j]
            self.final_output.append(summ)

        return self.final_output


# Веса скрытого слоя: 15 входов → 3 нейрона
w1 = []
for i in range(15):
    w1.append([
        1 if num4[i]   == '1' else -1,
        1 if num4_h[i] == '1' else -1,
        1 if num4_v[i] == '1' else -1,
    ])

# Веса выходного слоя: 3 → 4
# 3 класса + "не 4"
w2 = [
    [1, 0, 0, -1],
    [0, 1, 0, -1],
    [0, 0, 1, -1]
]

net = NeuralNetwork([15, 3, 4], [w1, w2])

# 4. Функция сравнения с эталонами
def similarity(inputs, etalon):
    """Сколько бит совпало"""
    matches = 0
    for i in range(15):
        if int(inputs[i]) == int(etalon[i]):
            matches += 1
    return matches


# 5. Обучение однослойной ИНС
train_one_layer()

# 6. Основная программа (ввод и решение)
print("Введите 15 символов (0 или 1). Матрица 3x5:")
print("  4 обычная:              101101111001001")
print("  4 отражение по гориз.:  001001111101101")
print("  4 отражение по верт.:   101101111100100")

number = input("Ваш ввод: ").strip()

if len(number) != 15 or any(c not in '01' for c in number):
    print("\nОшибка: нужно ровно 15 символов, только 0 или 1!")
else:
    inputs = [int(c) for c in number]

    # Многослойная ИНС 
    final_output = net.feed_forward(inputs)

    # Однослойная ИНС 
    scores_1 = predict_one_layer(inputs)

    # Сравнение с эталонами 
    scores = []
    for et in etalons:
        scores.append(similarity(inputs, et))

    # --- Вывод матрицы 3x5 ---
    print("\nВведённая матрица 3x5:")
    for row in range(3):
        line = ""
        for col in range(5):
            idx = row * 5 + col
            line += "█" if inputs[idx] == 1 else "·"
            line += " "
        print("  " + line)

    # Результаты сравнения ---
    print("\nСовпадения с эталонами:")
    for i in range(3):
        print(f"  {names[i]}: {scores[i]} из 15")

    # --- Решение ---
    best = scores.index(max(scores))
    best_score = max(scores)

    print("\nРезультаты однослойной ИНС (взвешенные суммы):")
    for i in range(3):
        print(f"  {names[i]}: {scores_1[i]}")

    print("\nРезультаты многослойной ИНС (выходной слой):")
    for i in range(len(final_output)):
        print(f"  выход {i+1}: {final_output[i]}")

    print("\n" + "=" * 60)
    if best_score < 13:
        print("Решение: это вообще не 4")
    else:
        print(f"Решение: это {names[best]}")
    print("=" * 60)