💻 Программирование и оценка качества

Задача: Сортировка объектов по цвету
Входные данные: Цвет объекта (красный/синий/зеленый)
Выходные данные: Направление движения объекта
Ограничения: Время сортировки < 5 секунд

Алгоритм:
1. Захватить объект
2. Определить цвет объекта
3. ЕСЛИ цвет = красный, ТО переместить в контейнер А
4. ЕСЛИ цвет = синий, ТО переместить в контейнер Б  
5. ЕСЛИ цвет = зеленый, ТО переместить в контейнер В
6. Освободить захват
7. Вернуться к началу

Задача: Исследование неизвестной территории
Входные данные: Показания датчиков расстояния
Выходные данные: Карта местности, найденные объекты
Ограничения: Не выходить за границы поля

Алгоритм:
1. Начать движение прямо
2. ПОКА расстояние > 20 см, ДЕЛАТЬ: двигаться вперед
3. ЕСЛИ препятствие, ТО:
   - Записать координаты препятствия
   - Повернуть на 90° вправо
   - Продолжить движение
4. ЕСЛИ границы поля, ТО: развернуться
5. Повторять до полного исследования

        [СТАРТ]
           │
    [Инициализация]
           │
      [Основной цикл]◄──────┐
           │                │
    [Чтение датчиков]       │
           │                │
    [Принятие решения]      │
           │                │
    [Выполнение действия]   │
           │                │
    [Проверка условий]──────┘
           │
        [СТОП]

[СТАРТ]
   │
[Калибровка датчиков]
   │
[Ожидание объекта]◄─────────────────┐
   │                                │
[Объект есть?]──НЕТ─────────────────┘
   │ДА
[Захватить объект]
   │
[Определить цвет]
   │
[Красный?]──ДА──[Переместить в А]──┐
   │НЕТ                             │
[Синий?]──ДА──[Переместить в Б]────┤
   │НЕТ                             │
[Зеленый?]──ДА──[Переместить в В]──┤
   │НЕТ                             │
[Неизвестный цвет]─────────────────┤
                                   │
[Освободить захват]◄───────────────┘
   │
[Вернуться в исходную позицию]
   │
[Увеличить счетчик объектов]
   │
└──────────────────────────────────┘

# Псевдокод инициализации
def initialize_robot():
    # Настройка портов
    motor_left = Motor(PORT_B)
    motor_right = Motor(PORT_C)
    color_sensor = ColorSensor(PORT_1)
    ultrasonic_sensor = UltrasonicSensor(PORT_4)
    
    # Калибровка датчиков
    color_sensor.calibrate()
    
    # Установка начальных параметров
    speed = 50
    turn_angle = 90
    
    print("Робот инициализирован!")

def move_forward(distance_cm):
    # Расчет времени движения
    # Скорость: 20 см/сек при мощности 50%
    time_sec = distance_cm / 20
    
    motor_left.run(speed=50, time=time_sec)
    motor_right.run(speed=50, time=time_sec)

def turn_right(angle_degrees):
    # Поворот на месте
    # 90° = 1 секунда при разности скоростей
    time_sec = angle_degrees / 90
    
    motor_left.run(speed=50, time=time_sec)
    motor_right.run(speed=-50, time=time_sec)

def stop_robot():
    motor_left.stop()
    motor_right.stop()

def process_color_detection():
    color = color_sensor.get_color()
    
    if color == "RED":
        move_to_container_A()
        objects_red += 1
    elif color == "BLUE":
        move_to_container_B()
        objects_blue += 1
    elif color == "GREEN":
        move_to_container_C()
        objects_green += 1
    else:
        # Неопознанный цвет
        move_to_unknown_container()
        objects_unknown += 1
    
    update_statistics()

def main_work_cycle():
    while True:  # Бесконечный рабочий цикл
        
        # Ожидание объекта
        while not object_detected():
            wait(0.1)  # Пауза 100 мс
        
        # Обработка объекта
        grab_object()
        process_color_detection()
        release_object()
        return_to_start()
        
        # Проверка условий завершения
        if total_objects >= 50:
            break
        if battery_level < 20:
            break
            
    print("Работа завершена!")

def collect_statistics():
    total_time = get_elapsed_time()
    total_objects = objects_red + objects_blue + objects_green
    
    if total_objects > 0:
        average_time = total_time / total_objects
        accuracy = (total_objects - objects_unknown) / total_objects * 100
        
        print(f"Обработано объектов: {total_objects}")
        print(f"Среднее время на объект: {average_time:.2f} сек")
        print(f"Точность распознавания: {accuracy:.1f}%")

# ОШИБКА: Неправильный синтаксис
if color = "RED":  # Должно быть ==, а не =
    move_forward(10)

# ОШИБКА: Незакрытые скобки
def move_robot(distance:
    motor.run(speed=50)  # Нет закрывающей скобки

# ОШИБКА: Неправильные отступы
if distance > 20:
move_forward(10)  # Нужен отступ

# ПРАВИЛЬНО:
if color == "RED":
    move_forward(10)

def move_robot(distance):
    motor.run(speed=50)

if distance > 20:
    move_forward(10)

# ОШИБКА: Бесконечный цикл
while distance > 10:
    print("Двигаемся вперед")  # distance не изменяется!

# ОШИБКА: Неправильное условие
if battery_level > 20:  # Должно быть <
    print("Батарея разряжена!")

# ОШИБКА: Неучтенные граничные случаи
speed = distance / time  # Что если time = 0?

# ПРАВИЛЬНО:
while distance > 10:
    move_forward(1)
    distance = ultrasonic.get_distance()

if battery_level < 20:
    print("Батарея разряжена!")

if time > 0:
    speed = distance / time
else:
    speed = 0

def debug_move_to_target(target_x, target_y):
    print(f"DEBUG: Начинаем движение к ({target_x}, {target_y})")
    
    current_x = get_position_x()
    current_y = get_position_y()
    print(f"DEBUG: Текущая позиция ({current_x}, {current_y})")
    
    distance = calculate_distance(current_x, current_y, target_x, target_y)
    print(f"DEBUG: Расстояние до цели: {distance} см")
    
    angle = calculate_angle(current_x, current_y, target_x, target_y)
    print(f"DEBUG: Угол поворота: {angle}°")
    
    turn_to_angle(angle)
    print("DEBUG: Поворот выполнен")
    
    move_forward(distance)
    print("DEBUG: Движение завершено")
    
    # Проверка результата
    final_x = get_position_x()
    final_y = get_position_y()
    error = calculate_distance(final_x, final_y, target_x, target_y)
    print(f"DEBUG: Погрешность позиционирования: {error} см")

def monitor_sensors():
    print("=== МОНИТОРИНГ ДАТЧИКОВ ===")
    
    for i in range(10):  # 10 измерений
        distance = ultrasonic.get_distance()
        color = color_sensor.get_color()
        light = light_sensor.get_intensity()
        battery = get_battery_level()
        
        print(f"Измерение {i+1}:")
        print(f"  Расстояние: {distance} см")
        print(f"  Цвет: {color}")
        print(f"  Освещенность: {light}")
        print(f"  Батарея: {battery}%")
        
        wait(1)  # Пауза 1 секунда

def test_basic_functions():
    print("=== ТЕСТ БАЗОВЫХ ФУНКЦИЙ ===")
    
    # Тест 1: Движение вперед
    print("Тест 1: Движение вперед на 20 см")
    start_pos = get_position()
    move_forward(20)
    end_pos = get_position()
    actual_distance = calculate_distance(start_pos, end_pos)
    error = abs(actual_distance - 20)
    print(f"Ожидалось: 20 см, Фактически: {actual_distance:.1f} см")
    print(f"Погрешность: {error:.1f} см")
    
    # Тест 2: Поворот на 90°
    print("\nТест 2: Поворот на 90°")
    start_angle = get_heading()
    turn_right(90)
    end_angle = get_heading()
    actual_turn = abs(end_angle - start_angle)
    error = abs(actual_turn - 90)
    print(f"Ожидалось: 90°, Фактически: {actual_turn:.1f}°")
    print(f"Погрешность: {error:.1f}°")
    
    # Тест 3: Распознавание цвета
    print("\nТест 3: Распознавание цвета")
    test_colors = ["RED", "BLUE", "GREEN"]
    correct_detections = 0
    
    for expected_color in test_colors:
        print(f"Поместите {expected_color} объект перед датчиком")
        wait(3)  # Время на размещение объекта
        detected_color = color_sensor.get_color()
        
        if detected_color == expected_color:
            print(f"✅ Правильно: {detected_color}")
            correct_detections += 1
        else:
            print(f"❌ Ошибка: ожидался {expected_color}, получен {detected_color}")
    
    accuracy = (correct_detections / len(test_colors)) * 100
    print(f"\nТочность распознавания цвета: {accuracy:.1f}%")

def performance_test():
    print("=== ТЕСТ ПРОИЗВОДИТЕЛЬНОСТИ ===")
    
    # Тест скорости сортировки
    start_time = get_time()
    objects_processed = 0
    
    for i in range(10):  # Тест на 10 объектах
        process_one_object()
        objects_processed += 1
    
    end_time = get_time()
    total_time = end_time - start_time
    
    average_time = total_time / objects_processed
    objects_per_minute = 60 / average_time
    
    print(f"Общее время: {total_time:.1f} сек")
    print(f"Среднее время на объект: {average_time:.2f} сек")
    print(f"Производительность: {objects_per_minute:.1f} объектов/мин")
    
    # Сравнение с требованиями ТЗ
    required_time = 5.0  # секунд на объект по ТЗ
    if average_time <= required_time:
        print(f"✅ Требование выполнено (≤{required_time} сек)")
    else:
        print(f"❌ Требование не выполнено (>{required_time} сек)")
        print(f"Нужно ускорить на {average_time - required_time:.2f} сек")

def measure_speed_direct():
    distance = 100  # см
    
    print(f"Измерение скорости на дистанции {distance} см")
    print("Установите робота на стартовую линию")
    
    input("Нажмите Enter для начала измерения...")
    
    start_time = get_time()
    move_forward(distance)
    end_time = get_time()
    
    travel_time = end_time - start_time
    speed = distance / travel_time
    
    print(f"Время прохождения: {travel_time:.2f} сек")
    print(f"Скорость: {speed:.1f} см/сек = {speed*0.36:.2f} км/ч")
    
    return speed

def measure_speed_on_surfaces():
    surfaces = ["Гладкий стол", "Ковер", "Линолеум", "Картон"]
    speeds = []
    
    for surface in surfaces:
        print(f"\n=== ИЗМЕРЕНИЕ НА: {surface.upper()} ===")
        input(f"Поместите робота на {surface.lower()}, нажмите Enter...")
        
        # Три измерения для точности
        surface_speeds = []
        for i in range(3):
            print(f"Измерение {i+1}/3")
            speed = measure_speed_direct()
            surface_speeds.append(speed)
            
        avg_speed = sum(surface_speeds) / len(surface_speeds)
        speeds.append(avg_speed)
        
        print(f"Средняя скорость на {surface.lower()}: {avg_speed:.1f} см/сек")
    
    # Анализ результатов
    print("\n=== СВОДКА РЕЗУЛЬТАТОВ ===")
    for i, surface in enumerate(surfaces):
        print(f"{surface}: {speeds[i]:.1f} см/сек")
    
    max_speed = max(speeds)
    min_speed = min(speeds)
    print(f"\nМаксимальная скорость: {max_speed:.1f} см/сек")
    print(f"Минимальная скорость: {min_speed:.1f} см/сек")
    print(f"Разница: {max_speed - min_speed:.1f} см/сек ({((max_speed-min_speed)/min_speed*100):.1f}%)")

def measure_max_load():
    print("=== ТЕСТ МАКСИМАЛЬНОЙ НАГРУЗКИ ===")
    
    weights = [0, 100, 200, 300, 400, 500]  # граммы
    results = []
    
    for weight in weights:
        print(f"\nТест с грузом {weight} г")
        input(f"Установите груз {weight} г, нажмите Enter...")
        
        # Тест способности двигаться
        print("Тестируем движение...")
        start_time = get_time()
        
        try:
            move_forward(50)  # 50 см
            end_time = get_time()
            time_taken = end_time - start_time
            
            if time_taken < 10:  # Успел за 10 секунд
                print(f"✅ Справился за {time_taken:.2f} сек")
                results.append({"weight": weight, "time": time_taken, "success": True})
            else:
                print(f"❌ Слишком медленно: {time_taken:.2f} сек")
                results.append({"weight": weight, "time": time_taken, "success": False})
                
        except:
            print("❌ Не смог сдвинуться с места")
            results.append({"weight": weight, "time": None, "success": False})
            break
    
    # Анализ результатов
    print("\n=== РЕЗУЛЬТАТЫ НАГРУЗОЧНОГО ТЕСТА ===")
    max_successful_weight = 0
    
    for result in results:
        if result["success"]:
            print(f"Груз {result['weight']} г: ✅ {result['time']:.2f} сек")
            max_successful_weight = result["weight"]
        else:
            print(f"Груз {result['weight']} г: ❌ Не справился")
    
    print(f"\nМаксимальная нагрузка: {max_successful_weight} г")

def measure_battery_life():
    print("=== ТЕСТ АВТОНОМНОСТИ ===")
    
    start_battery = get_battery_level()
    start_time = get_time()
    cycles_completed = 0
    
    print(f"Начальный заряд: {start_battery}%")
    print("Начинаем циклическую работу...")
    
    while get_battery_level() > 20:  # До критического уровня
        # Один рабочий цикл
        move_forward(30)
        turn_right(90)
        wait(1)
        
        cycles_completed += 1
        
        if cycles_completed % 10 == 0:  # Каждые 10 циклов
            current_battery = get_battery_level()
            current_time = get_time()
            elapsed_time = (current_time - start_time) / 60  # минуты
            
            print(f"Цикл {cycles_completed}: {current_battery}%, время {elapsed_time:.1f} мин")
    
    end_time = get_time()
    end_battery = get_battery_level()
    
    total_time = (end_time - start_time) / 60  # минуты
    battery_used = start_battery - end_battery
    
    print(f"\n=== РЕЗУЛЬТАТЫ ТЕСТА АВТОНОМНОСТИ ===")
    print(f"Время работы: {total_time:.1f} минут")
    print(f"Использовано заряда: {battery_used}%")
    print(f"Выполнено циклов: {cycles_completed}")
    print(f"Время на цикл: {total_time/cycles_completed:.2f} мин")
    print(f"Расход батареи: {battery_used/total_time:.2f}%/мин")
    
    # Прогноз полного времени работы
    if battery_used > 0:
        full_work_time = 80 * total_time / battery_used  # 80% рабочего заряда
        print(f"Прогноз полного времени работы: {full_work_time:.1f} минут")

def measure_positioning_accuracy():
    print("=== ТЕСТ ТОЧНОСТИ ПОЗИЦИОНИРОВАНИЯ ===")
    
    target_positions = [
        (50, 0),    # 50 см вперед
        (50, 50),   # 50 см вперед, 50 см вправо
        (0, 50),    # вернуться к X=0, Y=50
        (0, 0)      # вернуться в исходную точку
    ]
    
    errors = []
    
    for i, (target_x, target_y) in enumerate(target_positions):
        print(f"\nТочка {i+1}: Движение к ({target_x}, {target_y})")
        
        # Движение к цели
        move_to_position(target_x, target_y)
        
        # Измерение фактической позиции
        print("Измерьте фактическое положение робота")
        actual_x = float(input("Фактическая X (см): "))
        actual_y = float(input("Фактическая Y (см): "))
        
        # Расчет погрешности
        error_x = abs(actual_x - target_x)
        error_y = abs(actual_y - target_y)
        total_error = (error_x**2 + error_y**2)**0.5
        
        errors.append(total_error)
        
        print(f"Целевая позиция: ({target_x}, {target_y})")
        print(f"Фактическая позиция: ({actual_x}, {actual_y})")
        print(f"Погрешность: X={error_x:.1f} см, Y={error_y:.1f} см")
        print(f"Общая погрешность: {total_error:.1f} см")
    
    # Статистический анализ
    avg_error = sum(errors) / len(errors)
    max_error = max(errors)
    min_error = min(errors)
    
    print(f"\n=== СТАТИСТИКА ТОЧНОСТИ ===")
    print(f"Средняя погрешность: {avg_error:.1f} см")
    print(f"Максимальная погрешность: {max_error:.1f} см")
    print(f"Минимальная погрешность: {min_error:.1f} см")
    
    # Оценка качества
    if avg_error <= 2:
        print("✅ Отличная точность (≤2 см)")
    elif avg_error <= 5:
        print("⚠️ Хорошая точность (≤5 см)")
    else:
        print("❌ Требуется улучшение точности (>5 см)")

def calculate_errors(expected, actual):
    """
    Расчет различных типов погрешностей
    """
    # Абсолютная погрешность
    absolute_error = abs(actual - expected)
    
    # Относительная погрешность (в %)
    if expected != 0:
        relative_error = (absolute_error / abs(expected)) * 100
    else:
        relative_error = float('inf')
    
    # Приведенная погрешность (к максимальному значению)
    max_value = 100  # Например, для батареи 100%
    reduced_error = (absolute_error / max_value) * 100
    
    return {
        'absolute': absolute_error,
        'relative': relative_error,
        'reduced': reduced_error
    }

# Пример использования
expected_distance = 50  # см
actual_distance = 48.3  # см

errors = calculate_errors(expected_distance, actual_distance)
print(f"Ожидалось: {expected_distance} см")
print(f"Получено: {actual_distance} см")
print(f"Абсолютная погрешность: {errors['absolute']:.1f} см")
print(f"Относительная погрешность: {errors['relative']:.1f}%")

def statistical_analysis(measurements, expected_value):
    """
    Полный статистический анализ измерений
    """
    import math
    
    n = len(measurements)
    
    # Основные статистики
    mean = sum(measurements) / n
    
    # Стандартное отклонение
    variance = sum((x - mean)**2 for x in measurements) / (n - 1)
    std_dev = math.sqrt(variance)
    
    # Минимум и максимум
    min_val = min(measurements)
    max_val = max(measurements)
    
    # Размах
    range_val = max_val - min_val
    
    # Медиана
    sorted_measurements = sorted(measurements)
    if n % 2 == 0:
        median = (sorted_measurements[n//2 - 1] + sorted_measurements[n//2]) / 2
    else:
        median = sorted_measurements[n//2]
    
    # Погрешности относительно ожидаемого значения
    mean_error = abs(mean - expected_value)
    mean_relative_error = (mean_error / abs(expected_value)) * 100 if expected_value != 0 else 0
    
    # Коэффициент вариации
    cv = (std_dev / mean) * 100 if mean != 0 else 0
    
    return {
        'count': n,
        'mean': mean,
        'std_dev': std_dev,
        'min': min_val,
        'max': max_val,
        'range': range_val,
        'median': median,
        'mean_error': mean_error,
        'mean_relative_error': mean_relative_error,
        'coefficient_of_variation': cv
    }

# Пример анализа измерений скорости
speed_measurements = [19.2, 20.1, 18.8, 19.7, 20.3, 19.5, 18.9, 20.0]
expected_speed = 20.0

stats = statistical_analysis(speed_measurements, expected_speed)

print("=== СТАТИСТИЧЕСКИЙ АНАЛИЗ СКОРОСТИ ===")
print(f"Количество измерений: {stats['count']}")
print(f"Среднее значение: {stats['mean']:.2f} см/сек")
print(f"Стандартное отклонение: {stats['std_dev']:.2f} см/сек")
print(f"Медиана: {stats['median']:.2f} см/сек")
print(f"Диапазон: {stats['min']:.1f} - {stats['max']:.1f} см/сек")
print(f"Размах: {stats['range']:.1f} см/сек")
print(f"Коэффициент вариации: {stats['coefficient_of_variation']:.1f}%")
print(f"Погрешность среднего: {stats['mean_error']:.2f} см/сек ({stats['mean_relative_error']:.1f}%)")

def repeatability_test(test_function, num_tests=10):
    """
    Тест повторяемости выполнения функции
    """
    print(f"=== ТЕСТ ПОВТОРЯЕМОСТИ ({num_tests} попыток) ===")
    
    results = []
    
    for i in range(num_tests):
        print(f"Попытка {i+1}/{num_tests}")
        
        try:
            result = test_function()
            results.append(result)
            print(f"Результат: {result:.2f}")
        except Exception as e:
            print(f"Ошибка: {e}")
            results.append(None)
    
    # Анализ успешных результатов
    successful_results = [r for r in results if r is not None]
    success_rate = len(successful_results) / num_tests * 100
    
    print(f"\n=== АНАЛИЗ ПОВТОРЯЕМОСТИ ===")
    print(f"Успешных тестов: {len(successful_results)}/{num_tests} ({success_rate:.1f}%)")
    
    if len(successful_results) >= 3:  # Минимум для анализа
        stats = statistical_analysis(successful_results, successful_results[0])
        
        print(f"Среднее значение: {stats['mean']:.2f}")
        print(f"Стандартное отклонение: {stats['std_dev']:.2f}")
        print(f"Коэффициент вариации: {stats['coefficient_of_variation']:.1f}%")
        
        # Оценка стабильности
        if stats['coefficient_of_variation'] <= 5:
            print("✅ Отличная стабильность (CV ≤ 5%)")
        elif stats['coefficient_of_variation'] <= 10:
            print("⚠️ Хорошая стабильность (CV ≤ 10%)")
        else:
            print("❌ Низкая стабильность (CV > 10%)")
    
    return {
        'success_rate': success_rate,
        'results': successful_results,
        'statistics': stats if len(successful_results) >= 3 else None
    }

# Пример использования
def test_positioning():
    """Тест позиционирования робота"""
    move_to_position(50, 50)
    actual_pos = measure_actual_position()
    target_pos = (50, 50)
    error = calculate_distance(actual_pos, target_pos)
    return_to_start()
    return error

repeatability_results = repeatability_test(test_positioning, 5)

def comprehensive_quality_assessment():
    """
    Комплексная оценка качества модели робота
    """
    print("=== КОМПЛЕКСНАЯ ОЦЕНКА КАЧЕСТВА ===")
    
    criteria = {
        'functionality': 0,     # Функциональность
        'reliability': 0,       # Надежность  
        'accuracy': 0,          # Точность
        'performance': 0,       # Производительность
        'efficiency': 0,        # Эффективность
        'usability': 0          # Удобство использования
    }
    
    # 1. Функциональность (0-100)
    print("\n1. ФУНКЦИОНАЛЬНОСТЬ")
    required_functions = [
        "Движение вперед/назад",
        "Повороты влево/вправо", 
        "Определение препятствий",
        "Распознавание цветов",
        "Выполнение основной задачи"
    ]
    
    working_functions = 0
    for func in required_functions:
        works = input(f"Функция '{func}' работает? (y/n): ").lower() == 'y'
        if works:
            working_functions += 1
    
    criteria['functionality'] = (working_functions / len(required_functions)) * 100
    print(f"Функциональность: {criteria['functionality']:.0f}/100")
    
    # 2. Надежность (0-100)
    print("\n2. НАДЕЖНОСТЬ")
    reliability_tests = {
        "Стабильность подключений": 0,
        "Отсутствие поломок": 0,
        "Повторяемость результатов": 0,
        "Работа при разном освещении": 0
    }
    
    for test, score in reliability_tests.items():
        score = int(input(f"{test} (0-25): "))
        reliability_tests[test] = min(score, 25)
    
    criteria['reliability'] = sum(reliability_tests.values())
    print(f"Надежность: {criteria['reliability']:.0f}/100")
    
    # 3. Точность (из ранее проведенных тестов)
    print("\n3. ТОЧНОСТЬ")
    positioning_error = float(input("Средняя погрешность позиционирования (см): "))
    if positioning_error <= 2:
        criteria['accuracy'] = 100
    elif positioning_error <= 5:
        criteria['accuracy'] = 80
    elif positioning_error <= 10:
        criteria['accuracy'] = 60
    else:
        criteria['accuracy'] = 40
    
    print(f"Точность: {criteria['accuracy']:.0f}/100")
    
    # 4. Производительность
    print("\n4. ПРОИЗВОДИТЕЛЬНОСТЬ")
    task_time = float(input("Среднее время выполнения задачи (сек): "))
    required_time = float(input("Требуемое время по ТЗ (сек): "))
    
    if task_time <= required_time:
        criteria['performance'] = 100
    else:
        ratio = required_time / task_time
        criteria['performance'] = max(0, ratio * 100)
    
    print(f"Производительность: {criteria['performance']:.0f}/100")
    
    # 5. Энергоэффективность
    print("\n5. ЭНЕРГОЭФФЕКТИВНОСТЬ")
    battery_life = float(input("Время автономной работы (мин): "))
    if battery_life >= 60:
        criteria['efficiency'] = 100
    elif battery_life >= 30:
        criteria['efficiency'] = 80
    elif battery_life >= 15:
        criteria['efficiency'] = 60
    else:
        criteria['efficiency'] = 40
    
    print(f"Энергоэффективность: {criteria['efficiency']:.0f}/100")
    
    # 6. Удобство использования
    print("\n6. УДОБСТВО ИСПОЛЬЗОВАНИЯ")
    usability_aspects = {
        "Простота программирования": 0,
        "Понятность интерфейса": 0,
        "Удобство обслуживания": 0,
        "Качество документации": 0
    }
    
    for aspect in usability_aspects:
        score = int(input(f"{aspect} (0-25): "))
        usability_aspects[aspect] = min(score, 25)
    
    criteria['usability'] = sum(usability_aspects.values())
    print(f"Удобство использования: {criteria['usability']:.0f}/100")
    
    # Общая оценка
    overall_score = sum(criteria.values()) / len(criteria)
    
    print(f"\n=== ОБЩАЯ ОЦЕНКА КАЧЕСТВА ===")
    for criterion, score in criteria.items():
        print(f"{criterion.capitalize()}: {score:.0f}/100")
    
    print(f"\nОБЩИЙ БАЛЛ: {overall_score:.1f}/100")
    
    # Классификация качества
    if overall_score >= 90:
        grade = "Отлично"
    elif overall_score >= 75:
        grade = "Хорошо"
    elif overall_score >= 60:
        grade = "Удовлетворительно"
    else:
        grade = "Требует доработки"
    
    print(f"ОЦЕНКА: {grade}")
    
    return {
        'criteria': criteria,
        'overall_score': overall_score,
        'grade': grade
    }