{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Мини-проект: картинка из чисел\n",
    "\n",
    "Чёрно-белая картинка — это таблица из нулей и единиц. Нарисовать рамку и крест срезами, посчитать закрашенные точки, отразить, повернуть и обрезать изображение.\n",
    "\n",
    "Курс NumPy · урок `np-project-pixels` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/numpy/project-pixels).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "for _name, _min in {\"numpy\":\"2.0\"}.items():\n",
    "    try:\n",
    "        _have = __import__(_name).__version__\n",
    "    except ImportError:\n",
    "        print(f\"Нет пакета {_name}: выполните %pip install {_name} и перезапустите ядро\")\n",
    "        continue\n",
    "    if tuple(int(x) for x in _have.split(\".\")[:2]) < tuple(int(x) for x in _min.split(\".\")):\n",
    "        print(f\"Урок написан для {_name} {_min} и новее, у вас {_have}: выполните %pip install -U {_name} и перезапустите ядро\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Цифровая картинка — это двумерный массив: каждый элемент — точка (пиксель, pixel), а число — её цвет.\n",
    "В чёрно-белой картинке достаточно двух чисел: 0 — пусто, 1 — закрашено. В этом проекте мы будем рисовать и\n",
    "преобразовывать картинки только срезами, `.T` и итогами — всем, что было в модуле.\n",
    "\n",
    "Чтобы видеть картинку, а не столбики чисел, напишем маленькую функцию `show`: единицы она печатает\n",
    "квадратиком, нули — точкой."
   ],
   "id": "text-10"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Функция show и пустой холст\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def show(picture):\n",
    "    for row in picture:          # цикл for по таблице перебирает её строки\n",
    "        line = \"\"\n",
    "        for value in row:        # а по строке — её элементы\n",
    "            if value:\n",
    "                line += \"█\"      # 1 — закрашенная точка\n",
    "            else:\n",
    "                line += \"·\"      # 0 — пустая\n",
    "        print(line)\n",
    "\n",
    "\n",
    "show(np.zeros((3, 8), dtype=int))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "show"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 1. Рамка\n",
    "\n",
    "Присваивание в срез закрашивает сразу целую строку или столбец: `canvas[0] = 1` — верхняя строка,\n",
    "`canvas[:, -1] = 1` — правый столбец."
   ],
   "id": "text-19"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Рамка по краю\n",
    "\n",
    "Холст `frame` — нули 6 × 10. Нарисуйте на нём рамку: закрасьте первую и последнюю строки и первый и последний\n",
    "столбцы.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Строки: `frame[0] = 1` и `frame[-1] = 1`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Столбцы: `frame[:, 0] = 1` и `frame[:, -1] = 1`.\n",
    "\n",
    "</details>"
   ],
   "id": "frame-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "frame = np.zeros((6, 10), dtype=int)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "frame"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_frame():\n",
    "    \"по краям — единицы, внутри — нули\"\n",
    "    got = frame.tolist()\n",
    "    assert got[0] == [1] * 10 and got[-1] == [1] * 10, \"верхняя и нижняя строки должны быть закрашены.\"\n",
    "    assert all(r[0] == 1 and r[-1] == 1 for r in got), \"левый и правый столбцы должны быть закрашены.\"\n",
    "    assert all(v == 0 for r in got[1:-1] for v in r[1:-1]), \"внутри рамки должны остаться нули\"\n",
    "\n",
    "_check(test_frame)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "frame-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "frame = np.zeros((6, 10), dtype=int)\n",
    "frame[0] = 1\n",
    "frame[-1] = 1\n",
    "frame[:, 0] = 1\n",
    "frame[:, -1] = 1\n",
    "show(frame)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "frame-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 2. Крест"
   ],
   "id": "text-32"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Знак плюс\n",
    "\n",
    "Холст `plus` — нули 7 × 7. Нарисуйте в нём крест: закрасьте среднюю строку и средний столбец (индекс 3).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Средняя строка — `plus[3] = 1`, средний столбец — `plus[:, 3] = 1`.\n",
    "\n",
    "</details>"
   ],
   "id": "plus-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "plus = np.zeros((7, 7), dtype=int)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "plus"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_plus():\n",
    "    \"закрашены средняя строка и средний столбец\"\n",
    "    got = plus.tolist()\n",
    "    assert got[3] == [1] * 7, \"средняя строка (индекс 3) должна быть закрашена\"\n",
    "    assert all(r[3] == 1 for r in got), \"средний столбец (индекс 3) должен быть закрашен\"\n",
    "    assert sum(map(sum, got)) == 13, \"закрашено лишнее: кроме средней строки и столбца всё должно остаться нулём\"\n",
    "\n",
    "_check(test_plus)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "plus-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "plus = np.zeros((7, 7), dtype=int)\n",
    "plus[3] = 1\n",
    "plus[:, 3] = 1\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "plus-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 3. Сколько закрашено"
   ],
   "id": "text-40"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Число закрашенных точек\n",
    "\n",
    "Сохраните в `lit` число закрашенных точек креста `plus`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Закрашенные точки — единицы, пустые — нули. Что даст сумма всех элементов?\n",
    "\n",
    "</details>"
   ],
   "id": "count-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "lit = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "count"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_lit():\n",
    "    \"lit — число закрашенных точек\"\n",
    "    assert lit != 14, \"14 — это 7 + 7, но центр креста закрашен и строкой, и столбцом: точка там одна\"\n",
    "    assert lit != 49, \"49 — это все точки холста, а нужны только закрашенные: сумма единиц\"\n",
    "    assert lit == 13, f\"lit = {lit} — это не число закрашенных точек\"\n",
    "\n",
    "_check(test_lit, names=[\"lit\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "count-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "lit = plus.sum()\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "count-solution"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Крест и число закрашенных точек\n",
    "show(plus)\n",
    "print(\"закрашено:\", lit)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "count-print"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*После решения упражнения выше:*\n",
    "\n",
    "Строка и столбец креста по 7 точек, но центральную точку закрасили оба раза — это одна и та же точка: 7 + 7 − 1 = 13."
   ],
   "id": "component-51"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 4. Отражения\n",
    "\n",
    "Срез с шагом −1 разворачивает ось: `[::-1]` — строки в обратном порядке (отражение сверху вниз), `[:, ::-1]` —\n",
    "столбцы в обратном порядке (отражение слева направо). Вот стрелка вверх:"
   ],
   "id": "text-54"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Стрелка вверх\n",
    "up = np.array([\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [0, 1, 1, 1, 0],\n",
    "    [1, 0, 1, 0, 1],\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [0, 0, 1, 0, 0],\n",
    "])\n",
    "right = np.array([\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [0, 0, 0, 1, 0],\n",
    "    [1, 1, 1, 1, 1],\n",
    "    [0, 0, 0, 1, 0],\n",
    "    [0, 0, 1, 0, 0],\n",
    "])\n",
    "show(up)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "arrow"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Стрелка вниз\n",
    "\n",
    "Отразите стрелку `up` сверху вниз и сохраните результат в `down`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Переставить строки в обратном порядке — `up[::-1]`.\n",
    "\n",
    "</details>"
   ],
   "id": "flip-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "down = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "flip"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def test_down():\n",
    "    \"down — стрелка вниз\"\n",
    "    assert isinstance(down, np.ndarray) and down.shape == (5, 5), \"down — это должна быть картинка 5 × 5\"\n",
    "    got = down.tolist()\n",
    "    assert got != up.tolist(), \"картинка не изменилась: строки нужно переставить в обратном порядке\"\n",
    "    assert got == [[0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [1, 0, 1, 0, 1], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0]], \"это не отражение сверху вниз\"\n",
    "\n",
    "_check(test_down, names=[\"down\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "flip-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "down = up[::-1]\n",
    "show(down)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "flip-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 5. Стрелка влево\n",
    "\n",
    "Стрелка `right` смотрит вправо. Отразите её слева направо и сохраните в `left`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Все строки, столбцы — в обратном порядке: `right[:, ::-1]`.\n",
    "\n",
    "</details>"
   ],
   "id": "mirror-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "left = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "mirror"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 5 — выполните после своего решения\n",
    "def test_left():\n",
    "    \"left — стрелка влево\"\n",
    "    assert isinstance(left, np.ndarray) and left.shape == (5, 5), \"left — это должна быть картинка 5 × 5\"\n",
    "    got = left.tolist()\n",
    "    assert got != right.tolist(), \"картинка не изменилась: столбцы нужно переставить в обратном порядке\"\n",
    "    assert got == [[0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 1, 1, 1, 1], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0]], \"это не отражение слева направо\"\n",
    "\n",
    "_check(test_left, names=[\"left\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "mirror-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "left = right[:, ::-1]\n",
    "show(left)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "mirror-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 5. Поворот\n",
    "\n",
    "Поворот на 90° по часовой стрелке складывается из двух шагов: транспонировать (`.T`), а потом отразить слева\n",
    "направо. Попробуйте на бумажке с углом «Г» — и убедитесь."
   ],
   "id": "text-73"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 6. Повернуть букву Г\n",
    "\n",
    "В заготовке — картинка `letter` 4 × 3: буква «Г». Поверните её на 90° по часовой стрелке и сохраните\n",
    "в `turned`. Проверьте себя: у повёрнутой картинки 3 строки и 4 столбца, а перекладина буквы уходит вниз\n",
    "по правому краю.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Поворот — два шага из текста выше: транспонирование, а затем отражение слева направо, как у стрелки влево.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Сначала `letter.T`, потом отражение столбцов: `[:, ::-1]`.\n",
    "\n",
    "</details>"
   ],
   "id": "rotate-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "letter = np.array([\n",
    "    [1, 1, 1],\n",
    "    [1, 0, 0],\n",
    "    [1, 0, 0],\n",
    "    [1, 0, 0],\n",
    "])\n",
    "turned = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rotate"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 6 — выполните после своего решения\n",
    "def test_turned():\n",
    "    \"turned — буква Г, повёрнутая по часовой стрелке\"\n",
    "    assert isinstance(turned, np.ndarray), f\"turned — это {type(turned).__name__}, а нужна картинка — массив\"\n",
    "    assert turned.shape == (3, 4), f\"форма turned — {turned.shape}, а после поворота картинка 4 × 3 становится 3 × 4\"\n",
    "    got = turned.tolist()\n",
    "    assert got != [[1, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0]], \"это только транспонирование — отражение по диагонали, а не поворот: после него нужно ещё одно отражение\"\n",
    "    assert got != [[1, 0, 0, 0], [1, 0, 0, 0], [1, 1, 1, 1]], \"это поворот против часовой стрелки: после транспонирования отражайте столбцы, а не строки\"\n",
    "    assert got == [[1, 1, 1, 1], [0, 0, 0, 1], [0, 0, 0, 1]], \"это не поворот буквы по часовой стрелке\"\n",
    "\n",
    "_check(test_turned, names=[\"turned\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "rotate-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "letter = np.array([\n",
    "    [1, 1, 1],\n",
    "    [1, 0, 0],\n",
    "    [1, 0, 0],\n",
    "    [1, 0, 0],\n",
    "])\n",
    "turned = letter.T[:, ::-1]\n",
    "show(turned)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "rotate-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 6. Обрезка"
   ],
   "id": "text-87"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 7. Центр картинки\n",
    "\n",
    "Картинка `photo` — 8 × 8. Вырежьте из неё центральный квадрат 4 × 4 (строки и столбцы с индексами 2–5)\n",
    "и сохраните в `center`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Блок строк и столбцов с индексами 2, 3, 4, 5 — срезы `2:6` по обеим осям.\n",
    "\n",
    "</details>"
   ],
   "id": "crop-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "photo = np.arange(64).reshape(8, 8)\n",
    "center = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "crop"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 7 — выполните после своего решения\n",
    "def test_center():\n",
    "    \"center — квадрат 4 × 4 из середины\"\n",
    "    assert isinstance(center, np.ndarray), f\"center — это {type(center).__name__}, а нужен блок массива photo\"\n",
    "    assert center.shape == (4, 4), f\"форма center — {center.shape}, а нужно (4, 4)\"\n",
    "    assert center.tolist()[0] == [18, 19, 20, 21], \"квадрат должен стоять ровно посередине photo\"\n",
    "\n",
    "_check(test_center, names=[\"center\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "crop-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "photo = np.arange(64).reshape(8, 8)\n",
    "center = photo[2:6, 2:6]\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "crop-solution"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Результат\n",
    "for picture in (frame, down, left, turned):\n",
    "    show(picture)\n",
    "    print()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "final"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Настоящие фотографии устроены так же, только чисел больше: в цветной картинке у каждой точки три числа —\n",
    "красный, зелёный и синий, и массив получается трёхмерным. Обрезка, повороты и отражения в графических\n",
    "редакторах — это те же срезы."
   ],
   "id": "text-98"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Подробнее в справочнике:** [numpy/indexing-nd](https://ds-edu-trainer.vercel.app/reference/numpy/indexing-nd) · [numpy/flip-roll](https://ds-edu-trainer.vercel.app/reference/numpy/flip-roll)"
   ],
   "id": "more"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}