Черновики_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNtNjHFUP1/x9wQsK/zEy2+",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sinrez/pyCoursera/blob/master/%D0%A7%D0%B5%D1%80%D0%BD%D0%BE%D0%B2%D0%B8%D0%BA%D0%B8_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QvImMxQTOkRi",
        "outputId": "29b3a78a-fdc3-4831-ff74-4b857f98c18d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-3\n",
            "-2\n"
          ]
        }
      ],
      "source": [
        "x = int(input())\n",
        "print(x // 2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 1\n",
        "y = 1\n",
        "print((x - y) / 1, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zV0NYmI1PNeR",
        "outputId": "12b3e149-1e57-4650-fe8b-3fc588e54b00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = float(input())\n",
        "print(x // 2, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SiP4wOrGRQAE",
        "outputId": "baa039c3-9d8d-4924-8262-dcc2348ff6d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n",
            "4.0"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = float(input())\n",
        "print(abs(x + x), end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mw_Adj4L5qCj",
        "outputId": "a5e3e8e8-cc17-4264-f863-1500bbd98ce0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-1\n",
            "2.0"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = round(1.877, 2)\n",
        "b = round(3.145, 3)\n",
        "print(a, b, sep=' ; ', end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "riR_36ZR6BsM",
        "outputId": "4536e00a-9655-4c4a-f5b0-7b8888be3e55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.88 ; 3.145"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from math import sqrt\n",
        "# x1,y1,x2,y2,x3,y3  = int(input()),int(input()),int(input()),int(input()),int(input()),int(input())\n",
        "# x1 = 1\n",
        "# y1 = 0\n",
        "# x2 =10\n",
        "# y2 = 1\n",
        "# x3 = 2\n",
        "# y3 = 5\n",
        "x1 = int(input())\n",
        "y1 = int(input())\n",
        "x2 = int(input())\n",
        "y2 = int(input())\n",
        "x3 = int(input())\n",
        "y3 = int(input())\n",
        "\n",
        "a = round(sqrt((x1-x2)**2+(y1-y2)**2),3)\n",
        "b = round(sqrt((x1-x3)**2+(y1-y3)**2),3)\n",
        "c = round(sqrt((x2-x3)**2+(y2-y3)**2),3)\n",
        "\n",
        "print(f'a = {a}; b = {b}; c = {c};')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B4oZFbC-GtVo",
        "outputId": "a1ab9516-58ac-4603-ecb3-16722c68f7b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a = 9.055; b = 5.099; c = 8.944;\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z = complex()\n",
        "print(z)\n",
        "# результат выполнения программы:\n",
        "# 0j\n",
        "\n",
        "x = complex('01')\n",
        "print(x)\n",
        "# результат выполнения программы:\n",
        "# 1 + 0j\n",
        "\n",
        "y = complex(1.5, 2)\n",
        "print(y)\n",
        "# результат выполнения программы:\n",
        "# 1.5 + 2j"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FOv8c_y59oX6",
        "outputId": "3815e7ef-0b51-486a-da0e-c63d3cc70723"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0j\n",
            "(1+0j)\n",
            "(1.5+2j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z = 1 + 1j\n",
        "conjugated_z = z.conjugate()\n",
        "print(conjugated_z)\n",
        "# результат выполнения программы:\n",
        "# (1-1j)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MOL9U8xG_8Q6",
        "outputId": "fd5c004d-cf21-413e-cb15-e54b7b95069d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1-1j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z = complex(0.5, 1.5)\n",
        "result = z - 1j\n",
        "print(result, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1U2sZsYSAHjj",
        "outputId": "8cda9746-3cc5-450a-a659-7f2656a650e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0.5+0.5j)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = bool(0.1)\n",
        "b = bool()\n",
        "c = bool('')\n",
        "d = bool('0')\n",
        "e = bool(0)\n",
        "f = bool(1)\n",
        "print(a, b, c, d, e, f, sep='; ', end=';')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I3pj2qtRBPU1",
        "outputId": "02a71f2f-a21c-466a-fc64-cf3ca92804f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True; False; False; True; False; True;"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 11\n",
        "y = 9\n",
        "z = x & y | 10\n",
        "z"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qC21OhlVBfnq",
        "outputId": "5d30a0a1-4d38-457f-858c-9d5626ff5c69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = True\n",
        "b = False\n",
        "x = 0.1\n",
        "y = 3\n",
        "result = not a or x == y or b\n",
        "print(result, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0hhYChZBj_P",
        "outputId": "f1cf29f2-2b21-400b-eb49-e35dc7615f82"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = int(input())\n",
        "if not x % 2 == 1 or 0:\n",
        "    print('yummy', end='')\n",
        "else:\n",
        "    print('python', end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9J16zoefCZpg",
        "outputId": "6bb7e3c3-325b-4045-fab7-90cf3c0fe11b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "python"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = False\n",
        "x = 1\n",
        "if x + a == 1:\n",
        "    if not (not a and x and False):\n",
        "        print(True, a - x + 2, sep='~', end='^.^')\n",
        "else:\n",
        "    print(\"I'm sure, this is the answer!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FIU7BNjQChym",
        "outputId": "5d3a44d8-8579-4d19-beac-18437e0eed8d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True~1^.^"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 1\n",
        "y = 2\n",
        "print('odd' if (x + y) % 2 == 1 else 'even', end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yNG8Uby6CnaT",
        "outputId": "04f89968-4bd2-45bc-9ed8-638b29b6f5ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "odd"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "string = 'ok, I got it!'\n",
        "print(string[:2], string[-1], sep='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RWvdwB2kQsyR",
        "outputId": "76365670-ca97-4e58-865d-d92599cf68fc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ok!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lol = input()\n",
        "print(lol[::-1], end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q5v6swP1Q1Sc",
        "outputId": "a3e606ae-5ea1-46a7-c73c-e38d11f83544"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "kek\n",
            "kek"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str = \"you're my special friend\"\n",
        "print(f'{str[0]}{str[1]}')\n",
        "print(f'{str.split(\" \")[2]} {str.split(\" \")[3]}')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7F5570NASxH2",
        "outputId": "5ee90aee-fbfb-4da3-d951-d5afae6dc171"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yo\n",
            "special friend\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "name_1 = 'Pablo Picasso'\n",
        "name_2 = 'Chuck Norris'\n",
        "print(name_1[6:8] + 'Ka' + name_2[:3], end='⚡')"
      ],
      "metadata": {
        "id": "cm_nnXyyWQwM",
        "outputId": "bcbe9498-0590-4f96-eea6-bb277e342502",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PiKaChu⚡"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from sklearn.metrics import mean_absolute_error as mae\n",
        "\n",
        "y = np.array([1,2,3,4,5,-1,-2,-3,-4,-5])\n",
        "y_pred = np.array([0,2,2,5,3,-1,-1,-4,-6,-5])\n",
        "\n",
        "def mape(y, y_pred): \n",
        "    return np.mean(np.abs((y - y_pred) / y)) * 100\n",
        "\n",
        "print(mae(y, y_pred))\n",
        "print(mape(y, y_pred))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vugXsypDDqSk",
        "outputId": "55d2d0f2-ae90-4ba2-dcfc-eb648b06226b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9\n",
            "33.166666666666664\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn import linear_model as lm\n",
        "# Create linear regression object\n",
        "lr = lm.LinearRegression()\n",
        "lr.fit([[0],[1],[2],[3]], [0,1,0,3])\n",
        "print(\"Intercept: \", lr.intercept_)\n",
        "print(\"Coefficient: \", lr.coef_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KqeCFTuVD5Bk",
        "outputId": "ff4de677-ad25-40ef-acf5-212dd5e85b49"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Intercept:  -0.20000000000000018\n",
            "Coefficient:  [0.8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def func_linreg_sympy(*mark):\n",
        "    n=int(len(mark))\n",
        "    x,y,x2,y2,sum_x,sum_y,xy,a,b,=0,0,0,0,0,0,0,0,0\n",
        "    for i in range(0,n,2):\n",
        "        x+=mark[i]/n*2\n",
        "        y+=mark[i+1]/n*2\n",
        "        xy=xy+(mark[i]*mark[i+1])\n",
        "        x2+=mark[i]**2\n",
        "        y2+=mark[i+1]**2\n",
        "        sum_x+=mark[i]\n",
        "        sum_y+=mark[i+1]\n",
        "    a=(xy-y*sum_x)/(x2-x*sum_x)\n",
        "    b=(y*x2-x*xy)/(x2-x*sum_x)\n",
        "    print('уравение:y =',str(a)+'x +',str(b))\n",
        "func_linreg_sympy(0,0,1,1,2,0,3,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PeHnPBV9EElo",
        "outputId": "807bc22d-9146-47b4-a73f-963ff68c5c47"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "уравение:y = 0.8x + -0.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_classification_parameters(TN, TP, FN, FP):\n",
        "    Acc = (TN + TP) / (TN + TP + FN + FP)\n",
        "    Preс = TP / (TP + FP)\n",
        "    Rec = TP / (TP + FN)\n",
        "    print('Accuracy: {0}\\nPrecision: {1}\\nRecall: {2}'.format(Acc, Preс, Rec))"
      ],
      "metadata": {
        "id": "Q_9IfDlXElOa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def manhet(list1, list2, list3, list4):\n",
        "    s = 0\n",
        "    for a, b, c, d in zip(list1, list2, list3, list4):\n",
        "        s += abs(a - b) + abs(a - c) + abs(a - d)\n",
        "    return s\n",
        "\n",
        "a = [1, 1, 0]\n",
        "b = [0, 2, -1]\n",
        "c = [2, 3, 1]\n",
        "d = [1, 0, 4]\n",
        "\n",
        "print('a:', manhet(a, b, c, d))\n",
        "print('b:', manhet(b, c, d, a))\n",
        "print('c:', manhet(c, b, a, d))\n",
        "print('d:', manhet(d, b, c, a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZqHMjSAZe35J",
        "outputId": "c893bd89-f11d-492b-ac91-0fe86fd1cc57"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a: 12\n",
            "b: 16\n",
            "c: 16\n",
            "d: 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "strr = \"you're my special friend\"\n",
        "strr = strr.replace(\"'\", \" a\")\n",
        "print(strr)\n",
        "print(f'{strr[1]}{\"\"}{strr[2]}')\n",
        "print(f'{strr.split(\" \")[3]} {strr.split(\" \")[-1]}')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GtODgauA0Qj9",
        "outputId": "50fcb0b5-3400-4f38-96be-7506a8f765b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "you are my special friend\n",
            "ou\n",
            "special friend\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "strr_in = '11100110'\n",
        "d1 = 2\n",
        "d2 = 4\n",
        "str0 = d1 * '0'\n",
        "str1 = d2 * '1'\n",
        "ex1 = str0 + str1\n",
        "ex2 = str1 + str0\n",
        "print(ex1)\n",
        "print(ex2)\n",
        " \n",
        "if ex1 in strr_in or ex2 in strr_in:\n",
        "  print('found!')\n",
        "else:\n",
        "  print('nah:(')\n"
      ],
      "metadata": {
        "id": "X18-7naFe3ZE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb74e2fa-68ed-45f6-b8ff-027cbe0f787b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "001111\n",
            "111100\n",
            "nah:(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_classification_parameters(TN, TP, FN, FP):\n",
        "    Acc = (TN + TP) / (TN + TP + FN + FP)\n",
        "    Preс = TP / (TP + FP)\n",
        "    Rec = TP / (TP + FN)\n",
        "    print('Accuracy: {0}\\nPrecision: {1}\\nRecall: {2}'.format(Acc, Preс, Rec))\n",
        "\n",
        "get_classification_parameters(TN=25,FP=10,FN=20,TP=15)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-XvsA5xi_in",
        "outputId": "8dd6d02e-12ed-47a0-e6d7-8c535d8422bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.5714285714285714\n",
            "Precision: 0.6\n",
            "Recall: 0.42857142857142855\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_auc_score\n",
        "\n",
        "roc_auc_score([0,1,0,1,0,1], [0.6,0.81,0.5,0.9,0.7,0.75])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KiB7lx0_jHUh",
        "outputId": "97aa6b4c-7c75-401c-9a70-1b4d1da19ac5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = 12345\n",
        "product = 1\n",
        "while num != 0:\n",
        "    last_digit = num % 10\n",
        "    product = product * last_digit\n",
        "    num = num // 10\n",
        "print(product)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BER67tCP_k55",
        "outputId": "113eca33-3235-4224-987f-e1731f64f308"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = 123456789\n",
        "total = 0\n",
        "while num != 0:\n",
        "    last_digit = num % 10\n",
        "    if last_digit > 4:\n",
        "        total += 1\n",
        "    num = num // 10\n",
        "print(total)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k2aB8Spw_siq",
        "outputId": "32ea0982-5d9f-4b43-a6b5-16d155cfdff6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "st = '5321'\n",
        "''.join(sorted(st))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "5DVAsNuJSy0N",
        "outputId": "b1d05a40-49d7-4b35-cd7a-5f032715642c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1235'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(10):\n",
        "    print(i, end='*')\n",
        "    if i > 6:\n",
        "        break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aA2HeqzpBriA",
        "outputId": "d0ae736f-04b3-410e-9d32-e1aff57005fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0*1*2*3*4*5*6*7*"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "i = 100\n",
        "while i > 0:\n",
        "    if i == 40:\n",
        "        break\n",
        "    print(i, end='*')\n",
        "    i -= 20"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "37rwIUDdB05G",
        "outputId": "a3731672-a8e7-43ce-c978-603476825932"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100*80*60*"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = 10\n",
        "while n > 0:\n",
        "    n -= 1\n",
        "    if n == 2:\n",
        "        continue\n",
        "    print(n, end='*')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WHYDbcGPCxlG",
        "outputId": "6b402873-79a5-40a9-baf3-4e7087844133"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9*8*7*6*5*4*3*1*0*"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "result = 0\n",
        "for i in range(10):\n",
        "    if i % 2 == 0:\n",
        "        continue\n",
        "    result += i\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "30MV0daXC34W",
        "outputId": "43c30407-7e7e-4ea3-fe39-7e19ccb0508b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mult = 1\n",
        "for i in range(1, 11):\n",
        "   if i % 2 == 0:\n",
        "      continue\n",
        "   if i % 9 == 0:\n",
        "      break\n",
        "   mult *= i\n",
        "print(mult)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OYcTO5mVC8Ke",
        "outputId": "e0a4a4e5-b261-48f8-dcc3-b0495a178e58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "105\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(8):\n",
        "    for j in range(6):\n",
        "        print('*', end='')\n",
        "    print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8r-TMNTchiy_",
        "outputId": "28b4ba9d-59a7-43d1-b67a-e9fd26aea212"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "******\n",
            "******\n",
            "******\n",
            "******\n",
            "******\n",
            "******\n",
            "******\n",
            "******\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(1, 4):\n",
        "    for j in range(3, 6):\n",
        "        print(i, j)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-P0IavKNjHqG",
        "outputId": "8b8cb6ee-3bec-49d4-d646-2a92067d6573"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 3\n",
            "1 4\n",
            "1 5\n",
            "2 3\n",
            "2 4\n",
            "2 5\n",
            "3 3\n",
            "3 4\n",
            "3 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(1, 4):\n",
        "    for j in range(3, 5):\n",
        "        print(i + j, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nNhYNVoajOCn",
        "outputId": "dca1be98-0f59-4750-cf2a-5f12823ba6cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "455667"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "counter = 0\n",
        "for i in range(99, 102):\n",
        "    temp = i\n",
        "    while temp > 0:\n",
        "        counter += 1\n",
        "        temp //= 10\n",
        "print(counter)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "unSRvU4HjUUU",
        "outputId": "92cfca02-87da-44c6-942e-3e4d081a9e2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res = \"Programming is fun!\"\n",
        "ans = res[1:5]\n",
        "ans"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "tcm0F1it1mKd",
        "outputId": "39354999-baa6-427a-a326-67baa2b04f85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'rogr'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res = \"12 is > than 1.\"\n",
        "ans = res[-5:-1]\n",
        "ans"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "WtFUaSnR2HH-",
        "outputId": "07d13fc2-ab69-46de-e737-3f9635c61715"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'an 1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "for i in range(1, n+1):\n",
        "    for j in range(1, i + 1):\n",
        "        print(j, end='')\n",
        "    for k in range(i-1, 0, -1):\n",
        "        print(k, end='')\n",
        "    print()"
      ],
      "metadata": {
        "id": "TZGPP5xIMeiS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s = '01234567891011121314151617'\n",
        "for i in range(0, len(s), 5):\n",
        "    print(s[i], end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xoINrLPFWW4s",
        "outputId": "d0cb21f5-e3f9-45b6-c1ea-d2ceb39c2ab5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "051217"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "strr = 'aabbcc'\n",
        "s1 = set(strr)\n",
        "s1\n",
        "len(strr)\n",
        "len(s1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2hDJA8qBfZsY",
        "outputId": "a1a642fe-f71a-4894-b407-92cba7062aa1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'abcdefg'\n",
        "print(s[::-3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "epOgz19Rflhm",
        "outputId": "4a501b23-666c-4da8-e7cc-6e3239eeb81c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "gda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'i LEARN Python LAnguaGE'\n",
        "print(s.swapcase())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oVLdE8fk5rvo",
        "outputId": "160cb0bb-4be5-4c21-cd4f-3a8c4353e4b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I learn pYTHON laNGUAge\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for j in range(1,10):\n",
        "    print(j, end='')\n",
        "    if j % 3 == 0:\n",
        "      print('\\n') "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Jl3IuWYrESG",
        "outputId": "e5c3b107-2255-4f02-f4c9-08732e27b5f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n",
            "\n",
            "456\n",
            "\n",
            "789\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'aabbAAccDDaa'\n",
        "s = s.lower()\n",
        "print(s.count('a'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MR9vlAcJzC0l",
        "outputId": "86bcbdee-1243-4ea3-a2e9-201b168ec0dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'www.stepik.org'\n",
        "print(s.startswith('www'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXdKw2nnzpDa",
        "outputId": "b0b95003-1a15-4ff4-f8c5-d2d963d487e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'abcdababa'\n",
        "print(s.replace('ab', '123'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XhaM9QGpxSnJ",
        "outputId": "6ddacba4-75a9-4eaf-e65c-4d1df5640290"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123cd123123a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = '    abbc    '\n",
        "print(s.isspace())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yia0uzdF7KXq",
        "outputId": "a5dc2d27-8237-487f-d5e6-e630a8ae3c7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str = \"you're my special friend\"\n",
        "print(f'{str[0]}{str[1]}')\n",
        "print(f'{str.split(\" \")[1]} {str.split(\" \")[2]}')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pw4ltouOCmFp",
        "outputId": "4b3976d8-7680-4a08-f590-70cad51c96f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yo\n",
            "my special\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"The\\n logs\\n wo\\n't chop themselves\", end=\"!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a1iREYY2F1if",
        "outputId": "230878e8-e8b5-49f0-a7a2-0ef584e83de0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The\n",
            " logs\n",
            " wo\n",
            "'t chop themselves!"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "DwExbFy9xrzO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "kax = 100\n",
        "mar = kax // 7\n",
        "rep = mar % 5 / float(2)\n",
        "\n",
        "bat = kax / (rep + 1)\n",
        "bat"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZLeatkolGKNt",
        "outputId": "ae5908a4-a97b-4f9e-8b49-072bdb6d680f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "33.333333333333336"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Google search - 1\n",
        "На вход программе подается натуральное число nn, затем nn строк, затем еще одна строка — поисковый запрос. Напишите программу, которая выводит все введенные строки, в которых встречается поисковый запрос.\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подаются натуральное число nn — количество строк, затем сами строки в указанном количестве, затем один поисковый запрос.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести все введенные строки, в которых встречается поисковый запрос.\n",
        "\n",
        "Примечание. Поиск не должен быть чувствителен к регистру символов."
      ],
      "metadata": {
        "id": "7dtj_hx_xuz8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "tbnVju-Yxni0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "ls = [input() for _ in range(n)]\n",
        "s4 = input()\n",
        "for l in ls:\n",
        "    if s4.lower() in l.lower():\n",
        "        print(l)"
      ],
      "metadata": {
        "id": "WLrP2qwaxnRj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'BEEGEEK'\n",
        "chars = list(s)\n",
        "s = '**'.join(chars)\n",
        "print(s)"
      ],
      "metadata": {
        "id": "k6DPhIO5qdrm",
        "outputId": "377d337c-33a7-43cb-97c1-695fb878ee2d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "B**E**E**G**E**E**K\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "colors = ['Red', 'Blue', 'Green', 'Black', 'White']\n",
        "del colors[-1]\n",
        "colors.remove('Green')\n",
        "\n",
        "print(colors)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2XoPxdgQgTPp",
        "outputId": "331ad69e-1a39-4f98-9772-e49f0595a4d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Red', 'Blue', 'Black']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def print_number(a, b, c):\n",
        "    d = (a + c) // b\n",
        "    print(d)\n",
        "\n",
        "print_number(2, 3, 11)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7xbHcPiqSaix",
        "outputId": "b6a3305c-932d-4c92-edd0-fb431933f65f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = str(987654)\n",
        "s[:-6:-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "M8zxDRduVa4b",
        "outputId": "c7cd3630-e3b3-4cd3-8b92-39473926f756"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'45678'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Произведение чисел\n",
        "Напишите программу для определения, является ли число произведением двух чисел из данного набора, выводящую результат в виде ответа «ДА» или «НЕТ».\n",
        "\n",
        "Формат входных данных\n",
        "В первой строке подаётся число n\\, (0 < n < 1000)n(0<n<1000) – количество чисел в наборе. В последующих nn строках вводятся целые числа, составляющие набор (могут повторяться). Затем следует целое число, которое является или не является произведением двух каких-то чисел из набора.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести «ДА» или «НЕТ» в соответствии с условием задачи.\n",
        "\n",
        "Примечание 1. Само на себя число из набора умножиться не может, другими словами, два множителя должны иметь разные индексы в наборе.\n",
        "\n",
        "Примечание 2. Для решения задачи используйте вложенные циклы."
      ],
      "metadata": {
        "id": "UaQMKAUg9zTI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cnt = int(input())\n",
        "lst = [int(input()) for _ in range(cnt)]\n",
        "dgt = int(input())\n",
        "\n",
        "res = 'НЕТ'\n",
        "for i in range(len(lst)):\n",
        "    for j in range(i+1, len(lst)):\n",
        "            if lst[i] * lst[j] == dgt:\n",
        "                res = 'ДА'\n",
        "                break\n",
        "print(res)   "
      ],
      "metadata": {
        "id": "R-UAJMZC9z__"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Дана строка текста, состоящая из букв русского алфавита \"О\" и \"Р\". Буква \"О\" – соответствует выпадению Орла, а буква \"Р\" – соответствует выпадению Решки. Напишите программу, которая подсчитывает наибольшее количество подряд выпавших Решек."
      ],
      "metadata": {
        "id": "Q7N2_-muEk4y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = input().split('О')\n",
        "print(max(map(len, lst)))"
      ],
      "metadata": {
        "id": "JJJg_6A4Ekhi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "(357-654)+701\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VSPYKpTiNZ_b",
        "outputId": "0297b60f-5bd8-4207-e918-9c1f0b32bfb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "404"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [-6, -8, 0, 1, 3, 8, -7, 12, 17, 24, 25, 3, 5, 1]\n",
        "res = 0\n",
        "for num in numbers:\n",
        "    res += (num % 2 == 1) and (num > 1) \n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aQf4AH9-N9ib",
        "outputId": "197320d8-3799-47d1-9a3a-50a51f7ee028"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [[1, 7, 8], [9, 7, 102], [6, 106, 105], [100, 99, 98, 103], [1, 2, 3]]\n",
        "maximum = -1\n",
        "maximum  = max([l for ls in list1 for l in ls ])\n",
        "print(maximum)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zkgQN_BRJjKh",
        "outputId": "32e7379c-8cb1-48d2-9bf9-fb4002f77ed8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "106\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [[1, 7, 8], [9, 7, 102], [102, 106, 105], [100, 99, 98, 103], [1, 2, 3]]\n",
        "\n",
        "for l in list1:\n",
        "  l.reverse() \n",
        "\n",
        "print(list1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kNVLoGg3e3l_",
        "outputId": "c267f1b4-eed3-4068-ef20-488272558a2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[8, 7, 1], [102, 7, 9], [105, 106, 102], [103, 98, 99, 100], [3, 2, 1]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list1 = [[1, 7, 8], [9, 7, 102], [102, 106, 105], [100, 99, 98, 103], [1, 2, 3]]\n",
        "total = sum([l for ls in list1 for l in ls ])\n",
        "counter = len([l for ls in list1 for l in ls ])\n",
        "total / counter"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H7xgqRWS8fks",
        "outputId": "4082bfa0-afc0-4e64-9091-69fa4a90b572"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "53.3125"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [[12, 221, 3], [41, 5, 633], [71, 8, 99]]\n",
        "\n",
        "maximum = my_list[0][0]\n",
        "minimum = my_list[0][0]\n",
        "\n",
        "for row in my_list:\n",
        "    if max(row) > maximum:\n",
        "        maximum = max(row)\n",
        "    if min(row) < minimum:\n",
        "        minimum = min(row)\n",
        "\n",
        "print(maximum + minimum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4p9m_7KG1Jor",
        "outputId": "ff090820-c4c8-441f-bdbb-f7a7d3bdbb61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "636\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "digits = [1, -2, -5, 1, 4, 3, -3, 2]\n",
        "\n",
        "\n",
        "def balance(a):\n",
        "    def wrapper(f):\n",
        "        if sum(a) != 0:\n",
        "            return lambda: 'there is no balance, dude'\n",
        "        return f\n",
        "    return wrapper\n",
        "\n",
        "\n",
        "@balance(digits)\n",
        "def check():\n",
        "    return 'cool, we have balance'\n",
        "\n",
        "\n",
        "print(check(), end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Toarhx6-kri-",
        "outputId": "22fec982-d068-4bb8-efdd-1df507762dc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "there is no balance, dude"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = 8\n",
        "matrix = [[0]*n for _ in range(n)]    # создаем квадратную матрицу размером 8×8\n",
        "\n",
        "for i in range(n):                     # заполняем главную диагональ единицами, а побочную двойками\n",
        "    matrix[i][i] = 1\n",
        "    matrix[i][n-i-1] = 2\n",
        "\n",
        "for r in range(n):                     # выводим матрицу\n",
        "    for c in range(n):\n",
        "        print(matrix[r][c], end=' ')\n",
        "    print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HNMie2OFnXvK",
        "outputId": "923cfe85-8a40-4934-a9df-ea8d39901acd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 0 0 0 0 0 0 2 \n",
            "0 1 0 0 0 0 2 0 \n",
            "0 0 1 0 0 2 0 0 \n",
            "0 0 0 1 2 0 0 0 \n",
            "0 0 0 2 1 0 0 0 \n",
            "0 0 2 0 0 1 0 0 \n",
            "0 2 0 0 0 0 1 0 \n",
            "2 0 0 0 0 0 0 1 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = 3\n",
        "a = [[1, 2, 3],\n",
        "     [4, 5, 6],\n",
        "     [7, 8, 9]]\n",
        "\n",
        "for i in range(n):\n",
        "    for j in range(n):\n",
        "        print(a[n - i - 1][n - j - 1], end=' ')\n",
        "    print()"
      ],
      "metadata": {
        "id": "vRjAK9c0t6yP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a2fc01c-898a-406d-e950-ab93fa6f2c34"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9 8 7 \n",
            "6 5 4 \n",
            "3 2 1 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = 5\n",
        "a = [[19, 21, 33, 78, 99], \n",
        "     [41, 53, 66, 98, 76], \n",
        "     [79, 80, 90, 60, 20],\n",
        "     [33, 11, 45, 67, 90],\n",
        "     [45, 67, 12, 98, 23]]\n",
        "\n",
        "maximum = -1\n",
        "minimum = 100\n",
        "\n",
        "for i in range(n):\n",
        "    if a[i][i] > maximum:\n",
        "        maximum = a[i][i]\n",
        "    if a[i][n - i - 1] < minimum:\n",
        "        minimum = a[i][n - i - 1]\n",
        "print(minimum + maximum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9rh03D4dFEaq",
        "outputId": "f1fc0717-7e07-4c8e-f348-31e581d9532f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "101\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n , m = int(input()), int(input())\n",
        "\n",
        "matrix = [[0]*m for _ in range(n)]\n",
        "for i in range(n):\n",
        "    for j in range(m):\n",
        "        matrix[i][j] = input()\n",
        "\n",
        "for row in matrix:\n",
        "    print(*row)"
      ],
      "metadata": {
        "id": "T6gjEwWsSX5W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n , m = int(input()), int(input())\n",
        "\n",
        "matrix = [[0]*m for _ in range(n)]\n",
        "for i in range(n):\n",
        "    for j in range(m):\n",
        "        matrix[i][j] = input()\n",
        "\n",
        "for row in matrix:\n",
        "    print(*row)\n",
        "\n",
        "print()\n",
        "for j in range(m):\n",
        "    for i in range(n):\n",
        "        print(matrix[i][j],end=' ')\n",
        "    print()"
      ],
      "metadata": {
        "id": "IcNF56EPSYwH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HI1kNKQWUefM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
        "\n",
        "for i in range(n):\n",
        "    cn = 0\n",
        "    sum_row= sum(matrix[i])/n  \n",
        "    for j in  range(n):\n",
        "        if matrix[i][j] > sum_row:\n",
        "            cn += 1\n",
        "    print(cn)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        },
        "id": "znXcGFQZ50_h",
        "outputId": "8e54c459-ef30-4233-af03-52415f66a675"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "12\n",
            "34\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-8c722ce46472>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0msum_row\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m  \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mif\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0msum_row\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m             \u001b[0mcn\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
        "maxx = []\n",
        "\n",
        "for i in range(n):\n",
        "    for j in  range(n):\n",
        "        if i >= j:\n",
        "            maxx.append(matrix[i][j])\n",
        "print(max(maxx))\n"
      ],
      "metadata": {
        "id": "xOFPFrPy7nnr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Максимальный в области 2 🌶️\n",
        "Напишите программу, которая выводит максимальный элемент в заштрихованной области квадратной матрицы.\n",
        "\n",
        "\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подаётся натуральное число nn — количество строк и столбцов в матрице, затем элементы матрицы (целые числа) построчно через пробел.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести одно число — максимальный элемент в заштрихованной области квадратной матрицы.\n",
        "\n",
        "Примечание. Элементы диагоналей также учитываются."
      ],
      "metadata": {
        "id": "l2tgXcyr9m2I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
        "maxx = []\n",
        "\n",
        "for i in range(n):\n",
        "    for j in  range(n):\n",
        "        if (i < j and i < n - 1 - j) or (i > j and i > n - 1 - j):\n",
        "            continue\n",
        "        else:\n",
        "            maxx.append(matrix[i][j])\n",
        "print(max(maxx))"
      ],
      "metadata": {
        "id": "D1mnse8a73y5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Суммы четвертей\n",
        "Квадратная матрица разбивается на четыре четверти, ограниченные главной и побочной диагоналями: верхнюю, нижнюю, левую и правую.\n",
        "\n",
        "\n",
        "\n",
        "Напишите программу, которая вычисляет сумму элементов: верхней четверти; правой четверти; нижней четверти; левой четверти.\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подаётся натуральное число nn — количество строк и столбцов в матрице, затем элементы матрицы (целые числа) построчно через пробел.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести текст в соответствии с условием задачи.\n",
        "\n",
        "Примечание. Элементы диагоналей не учитываются."
      ],
      "metadata": {
        "id": "lwMe0o_gDZJS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "matrix = [[int(i) for i in input().split()] for j in range(n)]\n",
        "\n",
        "sum1 =0 \n",
        "sum2 = 0 \n",
        "sum3 = 0\n",
        "sum4 = 0\n",
        "\n",
        "for i in range(n):\n",
        "    for j in  range(n):\n",
        "        if (i < j and i < n - 1 - j):\n",
        "            sum1 += matrix[i][j]\n",
        "        elif (i < j and i > n - 1 - j):\n",
        "            sum2 += matrix[i][j]\n",
        "        elif (i > j and i > n - 1 - j):\n",
        "            sum3 += matrix[i][j]\n",
        "        elif (i > j and i < n - 1 - j):\n",
        "            sum4 += matrix[i][j]\n",
        "\n",
        "print(f'''\n",
        "Верхняя четверть: {sum1}\n",
        "Правая четверть: {sum2}\n",
        "Нижняя четверть: {sum3}\n",
        "Левая четверть: {sum4}\n",
        "''')"
      ],
      "metadata": {
        "id": "cAcnowi9DaC1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5\n",
        "y = 7\n",
        "\n",
        "x = x ^ y \n",
        "y = x ^ y \n",
        "x = x ^ y \n",
        "\n",
        "print(x)\n",
        "print(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qeJPN1N_RbKE",
        "outputId": "1622a2bd-c830-4846-c5fc-691ed83f7f74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n, m = int(input()), int(input())\n",
        "\n",
        "for i in range(n):\n",
        "    mult = []\n",
        "    for j in range(m):\n",
        "        mult.append(str(i * j).ljust(3))\n",
        "    print(*mult)"
      ],
      "metadata": {
        "id": "4x9dMNPNVJLm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "f = 21\n",
        "e = 10\n",
        "f = 5 * f + 5\n",
        "e = f - 10 - e * 5\n",
        "e"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xsg5Bpj6VJyi",
        "outputId": "51d289d7-59df-452c-f134-d78a44a7555d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "50"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ls = [input() for _ in range(4)]\n",
        "print('\\n'.join(ls[::-1]))"
      ],
      "metadata": {
        "id": "tYrrGHJoKcvd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n, m = map(int, input().split())\n",
        "for i in range(1, n+1):\n",
        "    for _ in range(m):\n",
        "        print(i, end =' ')\n",
        "    print()"
      ],
      "metadata": {
        "id": "FXBAqHfg9ix_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(input().split())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7dKWiysnZ_UG",
        "outputId": "76b9bd36-cab7-442d-86e2-e723cade7ad5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Магия перестаёт существовать после того, как вы понимаете, как она работает.\n",
            "['Магия', 'перестаёт', 'существовать', 'после', 'того,', 'как', 'вы', 'понимаете,', 'как', 'она', 'работает.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sg = ''.join('бвгд, ж, з, й, к, л, м, н, п, р, с, т, ф, х, ц, ч, ш, щ'.split(',')).replace(' ','')\n",
        "sg"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "R0OKrGjHcMyG",
        "outputId": "7cb4fa89-c018-4e79-c584-c7242c9b1c1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'бвгджзйклмнпрстфхцчшщ'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Напишите программу, которая считывает исходную строку и получает новую путём замены каждого символа следующим за ним, стоящим в таблице ASCII."
      ],
      "metadata": {
        "id": "zNiJhl3gi_fu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st = input()\n",
        "res = ''\n",
        "for s in st:\n",
        "    res += chr(ord(s)+1)\n",
        "print(res)"
      ],
      "metadata": {
        "id": "nNXz5kK3i63_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = map(int, input().split(' '))\n",
        "a\n",
        "# print(input()[a, b+1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ep_LBaDurQuw",
        "outputId": "619f6057-f903-40a4-fd53-f2f5ddfc267d"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 2\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'мама    мыла   раму '\n",
        "ls = s.split(' ')\n",
        "res = []\n",
        "for l in ls:\n",
        "  if l == '':\n",
        "    pass\n",
        "  else:\n",
        "    res.append(l)\n",
        "print(' '.join(res))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "txIpsLbAKQKO",
        "outputId": "98c848a5-06b3-446a-d80c-1a754ce8c515"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "мама мыла раму\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# s = input()\n",
        "s = '256.0.0.0'\n",
        "res_total = 'YES'\n",
        "ls = s.split('.')\n",
        "# print(ls)\n",
        "if s.count('.') != 3:\n",
        "   res_total = 'NO'\n",
        "else:\n",
        "   for l in ls:\n",
        "    #  print(l.isdigit())\n",
        "       if not l.isdigit():\n",
        "           res_total = 'NO'\n",
        "           break\n",
        "       elif len(l) < 0 or  len(l) > 3:\n",
        "           res_total = 'NO'\n",
        "           break\n",
        "       elif  int(l) < 0 or int(l) > 255:\n",
        "           res_total = 'NO'\n",
        "           break\n",
        "print(res_total)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "59hvtL-OkKHh",
        "outputId": "81e74a00-2ec1-48b3-8ea7-2cc4cb71b309"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NO\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "key = 9\n",
        "ciphertext = [''] * key\n",
        "ciphertext"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OH5hXii37nG2",
        "outputId": "0568bd3d-9e8f-4e5a-8bac-af1dbdf188ac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['', '', '', '', '', '', '', '', '']"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "86 / 9"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nSHHE-BFWc-r",
        "outputId": "be9761ac-edee-4e89-9c06-ae75f0f85296"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.555555555555555"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "str = \"you're my special friend\"\n",
        "print(f'{str[0]}{str[1]}')\n",
        "print(f'{str.split(\" \")[1]} {str.split(\" \")[2]}')  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DbsLiWRO69lb",
        "outputId": "d4df2878-7c57-4a62-f730-13857756aa57"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yo\n",
            "my special\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "string = 'haha'\n",
        "result = ''\n",
        "for i, c in enumerate(string):\n",
        "    if i % 2 == 1:\n",
        "        result += c\n",
        "    else:\n",
        "        result += 's'\n",
        "print(result, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DY0zUauPJM3I",
        "outputId": "c730e96a-348d-40a3-b68e-0cc1fca81816"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sasa"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "spam = {'eggs': 'bacon'} \n",
        "print ( ' bacon ' in spam)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "isTOU57kJfPs",
        "outputId": "d32529cc-2fa5-476f-fb09-ec725128dc9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "spam = {'name': 'Zophie', 'species': 'cat', 'age': 8}\n",
        "for s in spam.values():\n",
        "  print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gscs_3BQVl7T",
        "outputId": "bc30bf8d-2123-43d4-87c2-17ac05dac551"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Zophie\n",
            "cat\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n,m = map(int, input().split())\n",
        "matrix = [['.']*m for _ in range(n)]\n",
        "for i in range(n):\n",
        "    for j in range(m):\n",
        "        if (i+j)%2!=0:\n",
        "            matrix[i][j] = '*'\n",
        "for m in matrix:\n",
        "    print(*m)"
      ],
      "metadata": {
        "id": "yDfKULVJWVlV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = 5\n",
        "for _ in range(n):\n",
        "  res = []\n",
        "  for _ in range(n):\n",
        "    res.append([0]*n)\n",
        "print(*res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RU-OyL16suD5",
        "outputId": "ec4abc38-1974-46df-d3b4-c0cdeb956acc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(2**2**3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hAE3kGLDcSIG",
        "outputId": "19153943-d244-44e0-8d8e-a50445555a43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "256\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "print(math.factorial(20))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rVMVsmNIcR9l",
        "outputId": "86e34a22-ecb0-439a-dd8b-8e2f9480212b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2432902008176640000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(2*5**(2*2-2)- ((-2)**2**2-2**2**3)+10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kS0wQ3wTioAd",
        "outputId": "4f322271-6ecc-4c01-a9fb-0901a403008c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "names = ('Michael', 'John', 'Freddie')\n",
        "print(names)"
      ],
      "metadata": {
        "id": "QDaHgezRjDi2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a95cc0e5-9bc1-4f66-a3fe-2c2a2cfd9592"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Michael', 'John', 'Freddie')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "poets = [\n",
        "    ('Тургенев', 14),\n",
        "    ('Есенин', 13),\n",
        "    ('Маяковский', 28),\n",
        "    ('Фет', 15),\n",
        "    ('Лермонтов', 20)]\n",
        "\n",
        "for i in range(len(poets)):\n",
        "    for j in range(i+1, len(poets)):\n",
        "        if poets[i] > poets[j]:\n",
        "            poets[i], poets[j] = poets[j], poets[i]\n",
        "\n",
        "print(poets[0])\n",
        "print(poets[-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-cpAMEkcUUNu",
        "outputId": "a6ff82ef-1bca-4def-ca37-37ed0f751637"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Есенин', 13)\n",
            "('Фет', 15)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "notes = ('Do', 'Re', 'Mi', 'Fa', 'Sol', 'La', 'Si')\n",
        "\n",
        "do, re, *tail, si = notes\n",
        "\n",
        "print(tail)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ws_SATRUWviF",
        "outputId": "5cad31af-56d1-45a0-9312-6dcd35c3a430"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Mi', 'Fa', 'Sol', 'La']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tpl = (10, 20, 30, 40, 50, 60, 70, 80)\n",
        "print(tpl[2:5], tpl[:4], tpl[3:])"
      ],
      "metadata": {
        "id": "meFgnofkXewy",
        "outputId": "a86ae28d-8ce6-409a-9e66-67d6f394691f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(30, 40, 50) (10, 20, 30, 40) (40, 50, 60, 70, 80)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print((int(str(1)*123))**2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fF0Gl3v2cU3V",
        "outputId": "35637f5b-82e6-492e-8461-444a6d5b0944"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12345679012345679012345679012345679012345679012345679012345679012345679012345679012345679012345679012345679012345679012345654320987654320987654320987654320987654320987654320987654320987654320987654320987654320987654320987654320987654320987654321\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(set(input())))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J-bxASh5cZ_J",
        "outputId": "c83b2683-59df-4da1-f196-d77318700e13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "карабас-барабас\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "myset = set('python')\n",
        "\n",
        "item = myset.pop()\n",
        "print(item, len(myset))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-uFlQEdGmRr_",
        "outputId": "76af69bb-4527-42a6-8a30-e9ee2226a142"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "myset = set()\n",
        "for i in range(10):\n",
        "    if i % 2 == 0:\n",
        "        myset.add('even')\n",
        "    else:\n",
        "        myset.add('odd')\n",
        "print(len(myset))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4zS-N7HVmqky",
        "outputId": "03ebd1fe-aecb-42ca-f30a-efeb6405a530"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "text = input()\n",
        "lst = [word.lower().strip('.,;:-?!') for word in text.split()]\n",
        "#print(s)\n",
        "A = set()\n",
        "for elem in lst:\n",
        "    A.add(elem)\n",
        "print(len(A))"
      ],
      "metadata": {
        "id": "xqQMUnYaMEGf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Встречалось ли число раньше?\n",
        "На вход программе подается строка текста, содержащая числа. Для каждого числа выведите слово YES (в отдельной строке), если это число ранее встречалось в последовательности или NO, если не встречалось.\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подается строка текста, содержащая числа, разделенные символом пробела.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести текст в соответствии с условием задачи.\n",
        "\n",
        "Примечание. Ведущие нули в числах должны игнорироваться."
      ],
      "metadata": {
        "id": "9nag0qGnNZrL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st = set()\n",
        "for d in input().split():\n",
        "    l1 = len(st)\n",
        "    st.add(d.lstrip('0'))\n",
        "    if len(st) == l1:\n",
        "        print('YES')\n",
        "    else:\n",
        "        print('NO')\n",
        "        "
      ],
      "metadata": {
        "id": "OK-5zubENZbv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "set1 = {'a', 'b', 'c', 'd', 'h'}\n",
        "set2 = {'b', 'd', 'f', 'h'}\n",
        "\n",
        "set1 - set2 & set1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TCRydQyzHupB",
        "outputId": "b02d0cb6-684e-4354-815b-c3134b175ed3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'a', 'c'}"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Общие цифры\n",
        "На вход программе подается натуральное число nn, а затем nn различных натуральных чисел, каждое на отдельной строке. Напишите программу, которая выводит все общие цифры в порядке возрастания у всех введенных чисел.\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подаются натуральное число n \\ge 1n≥1, а затем nn различных натуральных чисел, каждое на отдельной строке.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести цифры в соответствии с условием задачи. Если общих цифр нет, то ничего выводить не нужно."
      ],
      "metadata": {
        "id": "COjPA5ls5tv3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l = []\n",
        "for _ in range(int(input())):\n",
        "    l.append(set(input()))\n",
        "#print(l)\n",
        "r = l[0]\n",
        "for i in range(1,len(l)):\n",
        "    r.intersection_update(l[i])\n",
        "print(*sorted(r))"
      ],
      "metadata": {
        "id": "8S7VK9FX5ea5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "words = ['Plum', 'Grapefruit', 'apple', 'orange', 'pomegranate', 'Cranberry', 'lime', 'Lemon', 'grapes', 'persimmon', 'tangerine', 'Watermelon', 'currant', 'Almond']\n",
        "res = set(w[0].lower() for w in words)\n",
        "print(*res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1H1YgdS_EoLy",
        "outputId": "f1254e9f-ff81-48c1-943b-62c8fc698244"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "g c o a p w l t\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sentence = '''My very photogenic mother died in a freak accident (picnic, lightning) when I was three, and, save for a pocket of warmth in the darkest past, nothing of her subsists within the hollows and dells of memory, over which, if you can still stand my style (I am writing under observation), the sun of my infancy had set: surely, you all know those redolent remnants of day suspended, with the midges, about some hedge in bloom or suddenly entered and traversed by the rambler, at the bottom of a hill, in the summer dusk; a furry warmth, golden midges.'''\n",
        "res1 = sentence.strip(\"'\").strip(\".\").strip(\":\").strip(\",\").strip(\"!\").strip(\"?\").strip(\"'\").strip(\";\").strip(\"(\").strip(\")\").lower().split()\n",
        "print(res1)\n",
        "set1 = {r.strip(\"'\").strip(\".\").strip(\":\").strip(\",\").strip(\"!\").strip(\"?\").strip(\"'\").strip(\";\").strip(\"(\").strip(\")\") for r in res1}\n",
        "print(' '.join(sorted(list(set1))))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dqTpUKjWFU3G",
        "outputId": "9b40be1a-c1b7-4b12-ccb1-6d5524abcb14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['my', 'very', 'photogenic', 'mother', 'died', 'in', 'a', 'freak', 'accident', '(picnic,', 'lightning)', 'when', 'i', 'was', 'three,', 'and,', 'save', 'for', 'a', 'pocket', 'of', 'warmth', 'in', 'the', 'darkest', 'past,', 'nothing', 'of', 'her', 'subsists', 'within', 'the', 'hollows', 'and', 'dells', 'of', 'memory,', 'over', 'which,', 'if', 'you', 'can', 'still', 'stand', 'my', 'style', '(i', 'am', 'writing', 'under', 'observation),', 'the', 'sun', 'of', 'my', 'infancy', 'had', 'set:', 'surely,', 'you', 'all', 'know', 'those', 'redolent', 'remnants', 'of', 'day', 'suspended,', 'with', 'the', 'midges,', 'about', 'some', 'hedge', 'in', 'bloom', 'or', 'suddenly', 'entered', 'and', 'traversed', 'by', 'the', 'rambler,', 'at', 'the', 'bottom', 'of', 'a', 'hill,', 'in', 'the', 'summer', 'dusk;', 'a', 'furry', 'warmth,', 'golden', 'midges']\n",
            "a about accident all am and at bloom bottom by can darkest day dells died dusk entered for freak furry golden had hedge her hill hollows i if in infancy know lightning memory midges mother my nothing observation of or over past photogenic picnic pocket rambler redolent remnants save set some stand still style subsists suddenly summer sun surely suspended the those three traversed under very warmth was when which with within writing you\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "myset = {'Yellow', 'Orange', 'Black'}\n",
        "myset.discard('Blue')\n",
        "\n",
        "print(myset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t_39READIhGE",
        "outputId": "31c0044a-cd88-43d3-f564-6ee840900fcd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Orange', 'Yellow', 'Black'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Набор сообщений\n",
        "На мобильных кнопочных телефонах текстовые сообщения можно отправлять с помощью цифровой клавиатуры. Поскольку с каждой клавишей связано несколько букв, для большинства букв требуется несколько нажатий клавиш. При однократном нажатии цифры генерируется первый символ, указанный для этой клавиши. Нажатие цифры 2, 3, 42,3,4 или 55 раз генерирует второй, третий, четвертый или пятый символ клавиши.\n",
        "\n",
        "1\t.,?!:\n",
        "2\tABC\n",
        "3\tDEF\n",
        "4\tGHI\n",
        "5\tJKL\n",
        "6\tMNO\n",
        "7\tPQRS\n",
        "8\tTUV\n",
        "9\tWXYZ\n",
        "0\tspace (пробел)\n",
        "Напишите программу, которая отображает нажатия клавиш, необходимые для введенного сообщения.\n",
        "\n",
        "Формат входных данных\n",
        "На вход программе подается одна строка – текстовое сообщение.\n",
        "\n",
        "Формат выходных данных\n",
        "Программа должна вывести нажатия клавиш, необходимых для введенного сообщения.\n",
        "\n",
        "Примечание 1. Ваша программа должна обрабатывать как прописные, так и строчные буквы.\n",
        "\n",
        "Примечание 2. Ваша программа должна игнорировать любые символы, не указанные в приведенной выше таблице.\n",
        "\n",
        "Примечание 3. Nokia 3310, чтобы вспомнить как это было 😄\n",
        "\n"
      ],
      "metadata": {
        "id": "mefvB9qlmPrO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d={\".\":'1', \",\":'11', \"?\":'111', \"!\":'1111', \":\":'11111',\n",
        "    \"A\":'2', \"B\":'22', \"C\":'222',\n",
        "    \"D\":'3', \"E\":'33', \"F\":'333',\n",
        "    \"G\":'4', \"H\":'44', \"I\":'444',\n",
        "    \"J\":'5', \"K\":'55', \"L\":'555',\n",
        "    \"M\":'6', \"N\":'66', \"O\":'666',\n",
        "    \"P\":'7', \"Q\":'77', \"R\":'777', \"S\": '7777',\n",
        "    \"T\":'8', \"U\":'88', \"V\":'888',\n",
        "    \"W\":'9', \"X\":'99', \"Y\":'999', \"Z\": '9999',\n",
        "    \" \":'0'\n",
        "}\n",
        "st = input().upper().replace('\"', '')\n",
        "res = ''\n",
        "for s in st:\n",
        "    res += d[s]\n",
        "print(res)"
      ],
      "metadata": {
        "id": "vT7U24fEmL_T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pets = [('Hatiko', 'Parker', 'Wilson', 50),\n",
        "        ('Rusty', 'Josh', 'King', 25),\n",
        "        ('Fido', 'John', 'Smith', 28),\n",
        "        ('Butch', 'Jake', 'Smirnoff', 18),\n",
        "        ('Odi', 'Emma', 'Wright', 18),\n",
        "        ('Balto', 'Josh', 'King', 25),\n",
        "        ('Barry', 'Josh', 'King', 25),\n",
        "        ('Snape', 'Hannah', 'Taylor', 40),\n",
        "        ('Horry', 'Martha', 'Robinson', 73),\n",
        "        ('Giro', 'Alex', 'Martinez', 65),\n",
        "        ('Zooma', 'Simon', 'Nevel', 32),\n",
        "        ('Lassie', 'Josh', 'King', 25),\n",
        "        ('Chase', 'Martha', 'Robinson', 73),\n",
        "        ('Ace', 'Martha', 'Williams', 38),\n",
        "        ('Rocky', 'Simon', 'Nevel', 32)]\n",
        "\n",
        "result = {}\n",
        "for i in pets:\n",
        "  result.update({i[1:]:[]})\n",
        "#print(result)\n",
        "for j in pets:\n",
        "  for k,v in result.items():\n",
        "    if k == j[1:] and j[0] != v:\n",
        "      result.update({k:v + [j[0]]})\n",
        "result"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cCImhN-sgF3M",
        "outputId": "fb4eb206-bcb1-49f3-c0e8-1fd52e8fd292"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{('Parker', 'Wilson', 50): ['Hatiko'],\n",
              " ('Josh', 'King', 25): ['Rusty', 'Balto', 'Barry', 'Lassie'],\n",
              " ('John', 'Smith', 28): ['Fido'],\n",
              " ('Jake', 'Smirnoff', 18): ['Butch'],\n",
              " ('Emma', 'Wright', 18): ['Odi'],\n",
              " ('Hannah', 'Taylor', 40): ['Snape'],\n",
              " ('Martha', 'Robinson', 73): ['Horry', 'Chase'],\n",
              " ('Alex', 'Martinez', 65): ['Giro'],\n",
              " ('Simon', 'Nevel', 32): ['Zooma', 'Rocky'],\n",
              " ('Martha', 'Williams', 38): ['Ace']}"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "693+1735 + 1131"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01zs4aLQxIZ3",
        "outputId": "414f67a2-35b5-4660-e7fa-af561b754901"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3559"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "info = {'emp1': {'name': 'Timur', 'job': 'Teacher'},\n",
        "        'emp2': {'name': 'Ruslan', 'job': 'Developer'},\n",
        "        'emp3': {'name': 'Rustam', 'job': 'Tester'}}\n",
        "\n",
        "for emp in info:\n",
        "    print('Employee ID:', emp)\n",
        "    for key in info[emp]:\n",
        "        print(key + ':', info[emp][key])\n",
        "    print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iYG6t61cHnf9",
        "outputId": "9bb8067f-3d24-4f60-8287-cfbd7760e5ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Employee ID: emp1\n",
            "name: Timur\n",
            "job: Teacher\n",
            "\n",
            "Employee ID: emp2\n",
            "name: Ruslan\n",
            "job: Developer\n",
            "\n",
            "Employee ID: emp3\n",
            "name: Rustam\n",
            "job: Tester\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = '1:men 2:kind 90:number 0:sun 34:book 56:mountain 87:wood 54:car 3:island 88:power 7:box 17:star 101:ice'\n",
        "\n",
        "result = {int(ss.split(':')[0]) : ss.split(':')[1] for ss in s.split()}"
      ],
      "metadata": {
        "id": "Fv5msuzyLMU0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [34, 10, 4, 6, 10, 23, 90, 100, 21, 35, 95, 1, 36, 38, 19, 1, 6, 87, 1000, 13456, 360]\n",
        "\n",
        "result = {x: sorted([y for y in range(1, x//2) if x % y == 0]) for x in numbers}\n",
        "result"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pqc1JRx1czV8",
        "outputId": "7e462111-382c-493e-df8b-a2787811ddf6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{34: [1, 2],\n",
              " 10: [1, 2],\n",
              " 4: [1],\n",
              " 6: [1, 2],\n",
              " 23: [1],\n",
              " 90: [1, 2, 3, 5, 6, 9, 10, 15, 18, 30],\n",
              " 100: [1, 2, 4, 5, 10, 20, 25],\n",
              " 21: [1, 3, 7],\n",
              " 35: [1, 5, 7],\n",
              " 95: [1, 5, 19],\n",
              " 1: [],\n",
              " 36: [1, 2, 3, 4, 6, 9, 12],\n",
              " 38: [1, 2],\n",
              " 19: [1],\n",
              " 87: [1, 3, 29],\n",
              " 1000: [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 125, 200, 250],\n",
              " 13456: [1, 2, 4, 8, 16, 29, 58, 116, 232, 464, 841, 1682, 3364],\n",
              " 360: [1,\n",
              "  2,\n",
              "  3,\n",
              "  4,\n",
              "  5,\n",
              "  6,\n",
              "  8,\n",
              "  9,\n",
              "  10,\n",
              "  12,\n",
              "  15,\n",
              "  18,\n",
              "  20,\n",
              "  24,\n",
              "  30,\n",
              "  36,\n",
              "  40,\n",
              "  45,\n",
              "  60,\n",
              "  72,\n",
              "  90,\n",
              "  120]}"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import string\n",
        "N = int(input())    # длина пароля\n",
        "\n",
        "#N = 20 #password length\n",
        "\n",
        "#allowed string constants\n",
        "allowedChars = string.ascii_letters\n",
        "\n",
        "#genereate password\n",
        "password = ''.join(random.choice(allowedChars) for _ in range(N))\n",
        "\n",
        "print(password)"
      ],
      "metadata": {
        "id": "ISXFvSjMzm8M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Лотерейный билет содержит 77 чисел из диапазона от 11 до 4949 (включительно).\n",
        "\n",
        "Напишите программу, которая с помощью модуля random генерирует 77 различных случайных чисел для лотерейного билета. Программа должна вывести числа в порядке возрастания на одной строке через один символ пробела.\n",
        "\n",
        "Примечание. Убедитесь, что сгенерированные числа не содержат дубликатов."
      ],
      "metadata": {
        "id": "qiMwYP5C7akl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "res = sorted(list({random.randrange(1, 50) for _ in range(7)}))\n",
        "print(' '.join(map(str, res)))"
      ],
      "metadata": {
        "id": "F_f5P8bB5Dp7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        " \n",
        "numbers = [1, 2, 4, 6, 7, 9]\n",
        "\n",
        "rand_numbers = random.sample(numbers, 3)\n",
        "rand_numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BijXMR-OhiSw",
        "outputId": "93f0130f-20da-4047-e8b7-ad46f208d236"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[7, 1, 6]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "def generate_ip():\n",
        "    numbers = [i for i in range(256)]\n",
        "    res = ''.join(map(str,random.sample(numbers, 1)))+'.'+''.join(map(str,random.sample(numbers, 1)))+'.'+''.join(map(str,random.sample(numbers, 1)))+'.'+''.join(map(str,random.sample(numbers, 1)))\n",
        "    return res\n",
        "generate_ip()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "L0nVxOxveyLX",
        "outputId": "641890a1-5387-42d7-8a89-87ce08a1af52"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'250.162.65.246'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from random import randrange as r\n",
        "\n",
        "def generate_ip():\n",
        "    return f'{r(256)}.{r(256)}.{r(256)}.{r(256)}'"
      ],
      "metadata": {
        "id": "rctKdzRUfiH6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import string\n",
        "import random\n",
        "from random import randrange as r\n",
        "#LetterLetterNumber_NumberLetterLetter\n",
        "def generate_index():\n",
        "    letr = string.ascii_uppercase\n",
        "    random.choice\n",
        "    return f'{random.choice(letr)}{random.choice(letr)}{r(99)}_{r(99)}{random.choice(letr)}{random.choice(letr)}'"
      ],
      "metadata": {
        "id": "xg0fDJayfjdv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from random import randrange\n",
        "tickets = set()\n",
        "while len(tickets) != 100:\n",
        "    tickets.add(randrange(1000000, 10000000))\n",
        "print(*tickets, sep='\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XzuqSkt0jL40",
        "outputId": "460d5d2b-aa27-4de0-b84a-cdf112a7a3db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7998999\n",
            "5356060\n",
            "8822813\n",
            "1036328\n",
            "6255150\n",
            "4554798\n",
            "5752376\n",
            "2191422\n",
            "8160831\n",
            "3216965\n",
            "9839694\n",
            "2469465\n",
            "3474523\n",
            "6589534\n",
            "1704544\n",
            "8273507\n",
            "2831463\n",
            "1884778\n",
            "1416810\n",
            "2388588\n",
            "5411965\n",
            "6471808\n",
            "4799119\n",
            "3638418\n",
            "6406294\n",
            "3725974\n",
            "5733529\n",
            "3376288\n",
            "4363938\n",
            "4559524\n",
            "4565674\n",
            "3628716\n",
            "6576818\n",
            "8871610\n",
            "9684156\n",
            "1487043\n",
            "8940228\n",
            "3962058\n",
            "8475850\n",
            "9582286\n",
            "3210958\n",
            "3112664\n",
            "6654173\n",
            "5000926\n",
            "9762531\n",
            "3060968\n",
            "5038827\n",
            "2883831\n",
            "7969017\n",
            "9095421\n",
            "5399805\n",
            "7745791\n",
            "4705029\n",
            "8527628\n",
            "6007053\n",
            "6570261\n",
            "4108057\n",
            "7781150\n",
            "1852203\n",
            "7178542\n",
            "3942192\n",
            "5502278\n",
            "6435143\n",
            "6171468\n",
            "1474897\n",
            "8347481\n",
            "7702367\n",
            "3252069\n",
            "7443302\n",
            "4649830\n",
            "2069865\n",
            "3219305\n",
            "3587952\n",
            "1108848\n",
            "7021425\n",
            "4634488\n",
            "6442365\n",
            "7652734\n",
            "7916432\n",
            "8664978\n",
            "8022933\n",
            "7067552\n",
            "8635298\n",
            "9475497\n",
            "5508527\n",
            "8953264\n",
            "5503923\n",
            "9522622\n",
            "3733956\n",
            "9865169\n",
            "8160725\n",
            "8188376\n",
            "5452254\n",
            "8243167\n",
            "3611103\n",
            "1293288\n",
            "4530155\n",
            "6453740\n",
            "1268723\n",
            "9465334\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "def generate_password(length):\n",
        "    result = []\n",
        "    digits = '23456789';\n",
        "    small_letters = 'qwertyuipasdfghjkzxcvbnm';\n",
        "    huge_letters = 'QWERTYUPASDFGHJKLZXCVBNM';\n",
        "    s = \"qwertyuipasdfghjkzxcvbnmQWERTYUPASDFGHJKLZXCVBNM23456789\"\n",
        "    result += random.sample([elem for elem in digits], 1)\n",
        "    result += random.sample([elem for elem in small_letters], 1)\n",
        "    result += random.sample([elem for elem in huge_letters], 1)\n",
        "    result += random.sample([elem for elem in s], length - 3)\n",
        "    print(''.join(result))\n",
        "\n",
        "def generate_passwords(count, length):\n",
        "    for i in range(count):\n",
        "        generate_password(length)\n",
        "\n",
        "n, m = int(input()), int(input())\n",
        "\n",
        "generate_passwords(n, m)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s7ztj-v9kyWw",
        "outputId": "073bfcd0-1613-4145-c27c-70b71ef90edc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "6\n",
            "2zFJzU\n",
            "6yYXFN\n",
            "7vXMZE\n",
            "9iBhxH\n",
            "5yZn8j\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = '9.73 8.84 8.92 9.60 9.32 8.97 8.53 1.26 6.62 9.85 1.85 1.80 0.83 6.75 9.74 9.11 9.14 5.03 5.03 1.34 3.52 8.09 7.89 8.24 8.23 5.22 0.30 2.59 1.25 6.24 2.14 7.54 5.72 2.75 2.32 2.69 9.32 8.11 4.53 0.80 0.08 9.36 5.22 4.08 3.86 5.56 1.43 8.36 6.29 5.13'\n",
        "from decimal import Decimal as D\n",
        "sm = 0\n",
        "ls = s.split()\n",
        "for l in ls:\n",
        "    sm += D(l)\n",
        "print(sm)\n",
        "print(*sorted([str(D(l)) for l in ls],reverse=True)[:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zZilkXin1_p_",
        "outputId": "fc23823a-d8c3-428c-e33e-9ce8c193a975"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "279.12\n",
            "9.85 9.74 9.73 9.60 9.36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from decimal import *\n",
        "num = list(str(Decimal(input())).replace('.','').replace('-',''))\n",
        "print(max(map(int, num))+min(map(int, num)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "akeq4okl208B",
        "outputId": "b7204273-51bb-4325-f80b-b9a4a8b2de40"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.1244354689\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['0', '.', '1', '2', '4', '4', '3', '5', '4', '6', '8', '9']"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Напишите функцию matrix(), которая создает, заполняет и возвращает матрицу заданного размера. При этом (в зависимости от переданных аргументов) она должна вести себя так:\n",
        "\n",
        "matrix() — возвращает матрицу 1 \\times 11× 1, в которой единственное число равно нулю;\n",
        "matrix(n) — возвращает матрицу n \\times nn× n, заполненную нулями;\n",
        "matrix(n, m) — возвращает матрицу из nn строк и mm столбцов, заполненную нулями;\n",
        "matrix(n, m, value) — возвращает матрицу из nn строк и mm столбцов, в которой каждый элемент равен числу value."
      ],
      "metadata": {
        "id": "Qk8f-BrtTefK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def matrix(n = 1, m = None, v = 0):\n",
        "    if n == 1 and m == None:\n",
        "        m = 1\n",
        "    elif n != 1 and m == None:\n",
        "        m = n\n",
        "    return [[v] * m for _ in range(n)]\n"
      ],
      "metadata": {
        "id": "LFgZjNuZTfil"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def func(*args):\n",
        "    return max(args) + min(args)\n",
        "\n",
        "\n",
        "print(func(10, 15, *[31, 42, 5, 1], *(17, 28, 19, 100), 13, 12))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YKIFpBjJoA7",
        "outputId": "178f0ce9-2879-451a-a03e-689af80c7772"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "101\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(name, *args):\n",
        "    name = name.split()\n",
        "    args = list(args)\n",
        "    name.extend(args)\n",
        "    name = ' and '.join(name)\n",
        "    return f'Hello, {name}!'\n",
        "\n",
        "print(greet('Timur'))\n",
        "print(greet('Timur', 'Roman'))\n",
        "print(greet('Timur', 'Roman', 'Ruslan'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MFH_ZaQ4TI60",
        "outputId": "426adbb4-8724-4396-8bf7-50d180f343a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Timur!\n",
            "Hello, Timur and Roman!\n",
            "Hello, Timur and Roman and Ruslan!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def comparator(pair):\n",
        "    return pair[1]\n",
        "\n",
        "\n",
        "pairs = [(5, 4), (3, 2), (1, 7), (8, 2)]\n",
        "pairs.sort(key=comparator)\n",
        "print(pairs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cnwWYbxuTNmd",
        "outputId": "043845aa-048f-457b-a692-9c103da284d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(3, 2), (8, 2), (5, 4), (1, 7)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def comparator(pair):\n",
        "    return pair[0] + pair[1]\n",
        "\n",
        "\n",
        "pairs = [(5, 4), (3, 2), (1, 7), (8, 2)]\n",
        "pairs.sort(key=comparator, reverse=True)\n",
        "print(pairs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JySXtYsIqvC3",
        "outputId": "c338469d-f042-440d-c79f-5124bf65cdfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(8, 2), (5, 4), (1, 7), (3, 2)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [(10, 10, 10), (30, 45, 56), (81, 80, 39), (1, 2, 3), (12, 45, 67), (-2, -4, 100), (1, 2, 99), (89, 90, 34), (10, 20, 30), (50, 40, 50), (34, 78, 65), (-5, 90, -1)]\n",
        "\n",
        "def func(x):\n",
        "    return min(x) + max(x)\n",
        "\n",
        "print(sorted(numbers, key=func))"
      ],
      "metadata": {
        "id": "4oBA2-iMsZE1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def map(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        result.append(function(item))\n",
        "    return result\n",
        "  \n",
        "numbers = [-2, 45, 45, -7, -45, 37, -42, 27, -58, -58, -12, -27, -49, -27, -56, 4, -99, -11, 86]\n",
        "\n",
        "var1 = max(numbers, key=abs)\n",
        "var2 = min(map(abs, numbers))\n",
        "\n",
        "print(var1 + var2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JiMJY7BRsZsQ",
        "outputId": "2a6df6ed-6663-4ddf-fd35-5fc8a1e925aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-97\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def filter(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        if function(item):\n",
        "            result.append(item)\n",
        "    return result\n",
        "\n",
        "def predicate(word):\n",
        "    return word == word[::-1]\n",
        "\n",
        "\n",
        "words = ['abba', 'qwerty', 'python', 'a', 'deed', 'nun', 'level', 'language', 'deified', 'bbbbb', 'mother', 'sister', 'surface', '1234321']\n",
        "filtered = filter(predicate, words)\n",
        "print(len(filtered))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K9GWxlV2rcGw",
        "outputId": "0ce59427-2944-4dcb-f4f7-94ab8ad44a0a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def map(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        result.append(function(item,2))\n",
        "    return result\n",
        "\n",
        "\n",
        "numbers = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.12013, 23.22222, 90.09873, 45.45, 314.1528, 2.71828, 1.41546]\n",
        "for m in map(round, numbers):\n",
        "  print(m)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yxQKm1CtAMbh",
        "outputId": "2f9c3505-e79e-44f7-8cc5-92a55b907e18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.57\n",
            "5.58\n",
            "4.01\n",
            "56.24\n",
            "9.01\n",
            "32.12\n",
            "23.22\n",
            "90.1\n",
            "45.45\n",
            "314.15\n",
            "2.72\n",
            "1.42\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def map(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        result.append(function(item))\n",
        "    return result\n",
        "\n",
        "\n",
        "def filter(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        if function(item):\n",
        "            result.append(item)\n",
        "    return result\n",
        "\n",
        "\n",
        "numbers = [1014, 1321, 675, 1215, 56, 1386, 1385, 431, 1058, 486, 1434, 696, 1016, 1084, 424, 1189, 475, 95, 1434, 1462, 815, 776, 657, 1225, 912, 537, 1478, 1176, 544, 488, 668, 944, 207, 266, 1309, 1027, 257, 1374, 1289, 1155, 230, 866, 708, 144, 1434, 1163, 345, 394, 560, 338, 232, 182, 1438, 1127, 928, 1309, 98, 530, 1013, 898, 669, 105, 130, 1363, 947, 72, 1278, 166, 904, 349, 831, 1207, 1496, 370, 725, 926, 175, 959, 1282, 336, 1268, 351, 1439, 186, 273, 1008, 231, 138, 142, 433, 456, 1268, 1018, 1274, 387, 120, 340, 963, 832, 1127]\n",
        "\n",
        "def cube(n):\n",
        "    return n**3\n",
        "\n",
        "def check_d(n):\n",
        "  res = []\n",
        "  if len(str(n)) == 3 and n % 5 == 2:\n",
        "    res.append(n)\n",
        "  return res\n",
        "\n",
        "for m in map(cube, filter(check_d, numbers)):\n",
        "  print(m)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8DU0UcYRAyax",
        "outputId": "9a65a7b7-600a-4a2e-e7bc-9accb965860f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "283593393\n",
            "758550528\n",
            "154854153\n",
            "8869743\n",
            "16974593\n",
            "12487168\n",
            "6028568\n",
            "849278123\n",
            "2863288\n",
            "57960603\n",
            "575930368\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def map(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        result.append(function(item))\n",
        "    return result\n",
        "\n",
        "\n",
        "def filter(function, items):\n",
        "    result = []\n",
        "    for item in items:\n",
        "        if function(item):\n",
        "            result.append(item)\n",
        "    return result\n",
        "\n",
        "\n",
        "numbers = [77, 293, 28, 242, 213, 285, 71, 286, 144, 276, 61, 298, 280, 214, 156, 227, 228, 51, -4, 202, 58, 99, 270, 219, 94, 253, 53, 235, 9, 158, 49, 183, 166, 205, 183, 266, 180, 6, 279, 200, 208, 231, 178, 201, 260, -35, 152, 115, 79, 284, 181, 92, 286, 98, 271, 259, 258, 196, -8, 43, 2, 128, 143, 43, 297, 229, 60, 254, -9, 5, 187, 220, -8, 111, 285, 5, 263, 187, 192, -9, 268, -9, 23, 71, 135, 7, -161, 65, 135, 29, 148, 242, 33, 35, 211, 5, 161, 46, 159, 23, 169, 23, 172, 184, -7, 228, 129, 274, 73, 197, 272, 54, 278, 26, 280, 13, 171, 2, 79, -2, 183, 10, 236, 276, 4, 29, -10, 41, 269, 94, 279, 129, 39, 92, -63, 263, 219, 57, 18, 236, 291, 234, 10, 250, 0, 64, 172, 216, 30, 15, 229, 205, 123, -105]\n",
        "\n",
        "def filtr(n):\n",
        "  if 9 < abs(n) < 100 and n % 7 == 0:\n",
        "    return n \n",
        "\n",
        "def sqq(nm):\n",
        "    return nm ** 2\n",
        "\n",
        "\n",
        "print(sum(map(sqq,filter(filtr, numbers))))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nn_KIIzfvu8O",
        "outputId": "779f3cf0-7801-42ef-a0e1-48b77ab01882"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25137\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "funcs = [lambda x: x ** 0.5, lambda x: x ** 2, lambda x: x ** 3]\n",
        "print(funcs[1](9))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NIkqgkLNCbKJ",
        "outputId": "74d6938e-b324-4596-fac0-4cf9c4f42895"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "81\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dict1 = {'x': 1}\n",
        "dict2 = {'y': 2}\n",
        "dict3 = {'x': 3, 'y': 4}\n",
        "\n",
        "result = list(filter(lambda d: 'x' in d.keys(), [dict1, dict2, dict3]))\n",
        "\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C1zpLWsJCpge",
        "outputId": "6369dfe4-1ea5-4669-8146-8bbdb5ebe45d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{'x': 1}, {'x': 3, 'y': 4}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
        "result = list(filter(lambda x: True, primes))\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DFmyW6ceFwFn",
        "outputId": "eaf03d3f-0eaf-4499-8fb4-c79d27078328"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'\n",
        "print(full_name('ben', 'affleck'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d27xyHNkGD_6",
        "outputId": "e7398aaa-d774-484a-8b6e-65320e28a357"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Full name: Ben Affleck\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "words1 = ['яблоко', 'ананас', 'апельсин', 'хурма', 'гранат', 'мандарин', 'айва']\n",
        "words2 = ['林檎', 'パイナップル', 'オレンジ', '柿']\n",
        "words3 = ['apple', 'pineapple', 'orange', 'persimmon', 'pomegranate']\n",
        "\n",
        "print(len(list(zip(words1, words2, words3))))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vNG6wRw-1OJ9",
        "outputId": "881356a9-5eea-47bb-83e3-9b4ce0988a8c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "countries = ['Russia', 'USA', 'UK', 'Germany', 'France', 'India']\n",
        "capitals = ['Moscow', 'Washington', 'London', 'Berlin', 'Paris', 'Delhi']\n",
        "population = [145_934_462, 331_002_651, 80_345_321, 67_886_011, 65_273_511, 1_380_004_385]\n",
        "#используйте for ... , ... , .... in zip(... , ... , ... ) а дальше f-строкой\n",
        "for cn, ca, po in zip(countries, capitals, population):\n",
        "    print(f'{cn} is the capital of {ca}, population equal {po} people.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cByfpqnn21vg",
        "outputId": "ef25b53e-5f03-40ec-de5a-130676f45f42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Russia is the capital of Moscow, population equal 145934462 people.\n",
            "USA is the capital of Washington, population equal 331002651 people.\n",
            "UK is the capital of London, population equal 80345321 people.\n",
            "Germany is the capital of Berlin, population equal 67886011 people.\n",
            "France is the capital of Paris, population equal 65273511 people.\n",
            "India is the capital of Delhi, population equal 1380004385 people.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = input()\n",
        "r = all([any([y.isupper() for y in s]),any([y.islower() for y in s]),any([y.isdigit() for y in s]), len(s) >= 7])\n",
        "print('YES' if r else 'NO')"
      ],
      "metadata": {
        "id": "W6RD2o4V62nE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "emails = {'nosu.edu': ['timyr', 'joseph', 'svetlana.gaeva', 'larisa.mamuk'], \n",
        "          'gmail.com': ['ruslan.chaika', 'rustam.mini', 'stepik-best'], \n",
        "          'msu.edu': ['apple.fruit', 'beegeek', 'beegeek.school'], \n",
        "          'yandex.ru': ['surface', 'google'],\n",
        "          'hse.edu': ['tomas-henders', 'cream.soda', 'zivert'],\n",
        "          'mail.ru': ['angel.down', 'joanne', 'the.fame.moster']}\n",
        "for d,nm in emails.items():\n",
        "  for n in nm:\n",
        "    print(f'{n}@{d}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "olQxQU2e64Sh",
        "outputId": "2d5a2b30-8931-40ec-cca1-dd028f182037"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "timyr@nosu.edu\n",
            "joseph@nosu.edu\n",
            "svetlana.gaeva@nosu.edu\n",
            "larisa.mamuk@nosu.edu\n",
            "ruslan.chaika@gmail.com\n",
            "rustam.mini@gmail.com\n",
            "stepik-best@gmail.com\n",
            "apple.fruit@msu.edu\n",
            "beegeek@msu.edu\n",
            "beegeek.school@msu.edu\n",
            "surface@yandex.ru\n",
            "google@yandex.ru\n",
            "tomas-henders@hse.edu\n",
            "cream.soda@hse.edu\n",
            "zivert@hse.edu\n",
            "angel.down@mail.ru\n",
            "joanne@mail.ru\n",
            "the.fame.moster@mail.ru\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "emails = {'nosu.edu': ['timyr', 'joseph', 'svetlana.gaeva', 'larisa.mamuk'], \n",
        "          'gmail.com': ['ruslan.chaika', 'rustam.mini', 'stepik-best'], \n",
        "          'msu.edu': ['apple.fruit', 'beegeek', 'beegeek.school'], \n",
        "          'yandex.ru': ['surface', 'google'],\n",
        "          'hse.edu': ['tomas-henders', 'cream.soda', 'zivert'],\n",
        "          'mail.ru': ['angel.down', 'joanne', 'the.fame.moster']}\n",
        "res = []\n",
        "for d,nm in emails.items():\n",
        "  for n in nm:\n",
        "    res.append(n+'@'+d)\n",
        "for r in sorted(res):\n",
        "  print(r)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ztNMe8YQI3qL",
        "outputId": "1602c120-ef72-4ebe-a6da-fcc075f49a2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "angel.down@mail.ru\n",
            "apple.fruit@msu.edu\n",
            "beegeek.school@msu.edu\n",
            "beegeek@msu.edu\n",
            "cream.soda@hse.edu\n",
            "google@yandex.ru\n",
            "joanne@mail.ru\n",
            "joseph@nosu.edu\n",
            "larisa.mamuk@nosu.edu\n",
            "ruslan.chaika@gmail.com\n",
            "rustam.mini@gmail.com\n",
            "stepik-best@gmail.com\n",
            "surface@yandex.ru\n",
            "svetlana.gaeva@nosu.edu\n",
            "the.fame.moster@mail.ru\n",
            "timyr@nosu.edu\n",
            "tomas-henders@hse.edu\n",
            "zivert@hse.edu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(''.join(chr(a) for a in (2**6+8, 101, int(\"0x6C\", 16), 108, int(\"1\"*3), 30+-8%11)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_uhbFcJpHcdg",
        "outputId": "a328d1f8-d8d5-435d-e1e6-4fe49c50d982"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def outer_func(a, b):\n",
        "    def inner_func(c, d):\n",
        "        return c + d + a*b\n",
        "    return inner_func\n",
        "\n",
        "res = outer_func(5, 10)(3, 2)\n",
        "\n",
        "print(res)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J57wI4khMUtj",
        "outputId": "eaf63681-99b6-4bfc-9235-040c748f32b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print((lambda x: (x + 3) * 5 / 2)(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XEVCCj8FMeea",
        "outputId": "7810b6fb-8e1f-4bbf-c066-8bf1e45dc819"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data = [['p', 'y', 't', 'h', 'o', 'n'], ['s', 't', 'e', 'p', 'i', 'k']]\n",
        "result = list(map(lambda x: '.'.join(x), data))\n",
        "print(result[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hfdi6nLjkkUF",
        "outputId": "8a0ba01f-7302-4bdd-8647-31d5783fc6f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "s.t.e.p.i.k\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(list(filter(None, ['', 1, 7, 'beegeek', None, False, 0])))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z9zAIMVukrJw",
        "outputId": "902f1be3-eee1-4693-c92b-b4d456315255"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 7, 'beegeek']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import reduce\n",
        "import operator\n",
        "\n",
        "def flatten(data):\n",
        "    return reduce(operator.concat, data, [])\n",
        "\n",
        "result = flatten([[1, 2], [3, 4], [], [5]])\n",
        "\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kXhvhcNSlTOx",
        "outputId": "c0b1b34f-a6c0-4676-e522-ec02953b2187"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " (2+3j - 4.5-1.5j).real"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "htjFvzcfma9g",
        "outputId": "76159002-1174-470a-fa8d-0632066cd06e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-2.5"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "count = 0\n",
        "for i in range(-10, -60, -3):\n",
        "  count += 1\n",
        "count"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tzK9xkOTnr9d",
        "outputId": "3cccb15c-fbb0-4358-9ebf-df3c130136c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "-7 % 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w9DPbxmECEaR",
        "outputId": "251c4ad4-fbdd-49b7-91b2-6d3d0d32df12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "13<<2>>1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r5rmxYq19pZ4",
        "outputId": "16dbe504-6ce6-4c7a-8e66-40afa2d4cc38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "days = 'пн/вт/ср/чт/пт/сб/вс'.split('/')\n",
        "i = int(input())\n",
        "if i  >= 7:\n",
        "        ind = i % 7\n",
        "elif i == 0:\n",
        "        ind = 0\n",
        "\n",
        "else:\n",
        "    ind = i\n",
        "print(days[ind])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mXDqVTIDXTjR",
        "outputId": "e8f811f7-4ede-4544-c031-92d83f4acb5b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "55\n",
            "вс\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(1, 3):\n",
        "    for j in range(2, 2):\n",
        "        for k in range(3, 5):\n",
        "            print(k)\n",
        "    for b in range(3,4):\n",
        "        for z in range(5,3):\n",
        "            print(z)\n",
        "    print(i)"
      ],
      "metadata": {
        "id": "OMpNP27ZpI1-",
        "outputId": "5bd7965c-e548-4b3f-de28-482fea28ec27",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum = 0\n",
        "element = input()\n",
        "if not element.isalpha():\n",
        "    while int(element) != 0:\n",
        "        sum += int(element)\n",
        "        element = input()\n",
        "    print(sum)\n",
        "else:\n",
        "    print(-1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G1PPfBVkqw6c",
        "outputId": "486bc505-55c7-47a9-a4c6-08871bbd00fc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "-1\n",
            "0\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n1, n2, n3, n4 = [int(i) for i in input().split('.')]\n",
        "# ваш код ниже (используйте переменные n1-n4)\n",
        "res = True\n",
        "if 0<n1<=255 and 0<=n2<=255 and 0<=n3<=255 and 0<=n4<=255:\n",
        "    b1 = bin(n1).replace('0b','')\n",
        "    b2 = bin(n2).replace('0b','')\n",
        "    b3 = bin(n3).replace('0b','')\n",
        "    b4 = bin(n4).replace('0b','')\n",
        "    b_all = b1 + b2 + b3 + b4\n",
        "    #print(b_all)\n",
        "    for d in b_all[b_all.find('0'):]:\n",
        "      if d == '1':\n",
        "        res = 'False'\n",
        "        break\n",
        "    print(res)\n",
        "else:\n",
        "    print(False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gweUgNRVwIrB",
        "outputId": "6199a23a-6103-4255-d6a6-f9ada0730621"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "255.0.0.1\n",
            "11111111001\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s = \"backend\"\n",
        "print(s[-2:1:-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z_IdcRzk3LeU",
        "outputId": "dab48599-a935-4050-e1da-cba645dcf359"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nekc\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(ord('ъ'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ty-YhmGA4HlA",
        "outputId": "a77628f5-f178-447b-bc80-6f531446efd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1098\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Шифр Цезаря\n",
        "\n",
        "ашифруйте сообщение шифром цезаря.\n",
        "\n",
        "Например:\n",
        "\n",
        "abc -> def для шага 3\n",
        "\n",
        "На вход программе подается строка состоящая из букв латинского алфавита в нижнем регистре, которую нужно зашифровать и сдвиг, на который нужно сдвинуть буквы в слове."
      ],
      "metadata": {
        "id": "N17lYNv8Dwlm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "st, step = input(), int(input())\n",
        "res = ''\n",
        "for s in st:\n",
        "    base = ord('A') if s.isupper() else ord('a')\n",
        "    res += chr((ord(s) + step - base) % 26 + base) \n",
        "print(res)"
      ],
      "metadata": {
        "id": "y9jm4_PdDy7v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x=list(input().lower())  # делаем из слова список букв\n",
        "y=[]                     # пустой список для количества символов\n",
        "print(x)\n",
        "for i in x:              # цикл по списку букв в строке\n",
        "    y.append(x.count(i)) # считаем количество текущей буквы в списке\n",
        "print(max(y))            # находим и выводим максимальное число"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WNcj8uCLD1-q",
        "outputId": "f05d0154-990b-4cd6-a824-e16d9b062a7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "aaabbccccaaaab\n",
            "['a', 'a', 'a', 'b', 'b', 'c', 'c', 'c', 'c', 'a', 'a', 'a', 'a', 'b']\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "d = {'a': '1', 'b': '2', 'c': '3'}\n",
        "s = 'abacaba'\n",
        "table = s.maketrans(d)\n",
        "print(s.translate(table))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T5S7pmBrTdjN",
        "outputId": "c9ad7262-6507-4d2c-bda3-dc8158a12472"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1213121\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = {1,2,3,4,5}\n",
        "b = {3,4,5,6,7}\n",
        "c = (a & b - a) | b\n",
        "c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_WKiKoz5VZY8",
        "outputId": "49ac1465-0615-46c5-9c11-c783d2f68a71"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{3, 4, 5, 6, 7}"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(True, ('01.03.2023', '15:00'),)\n",
        "\n",
        "('Pokemon',)\n",
        "\n",
        "('Pokemon')\n",
        "\n",
        "([123, 834])\n",
        "\n",
        "[(32, 'success'), (64, 'failed'), ]\n",
        "\n",
        "((32, 'success'), (64, 'failed'), )\n",
        "\n",
        "([123, 834],)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eEq8WqVfkM-G",
        "outputId": "5bf1ee92-2f3d-4b4a-d017-d3711d87bae8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([123, 834],)"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\n",
        "    len(\n",
        "        {\n",
        "            i.replace('b','d',1) if i.startswith('b') else i.replace('c','') \n",
        "            for i in ['aa','bbb','cccc', 'bacbac'] if len(i) > 2\n",
        "        }\n",
        "    )\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8sP8MatzlmBz",
        "outputId": "78e1f92e-32e9-4945-f04a-ae8ab66b9908"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [int(i) for i in input().split()]\n",
        "lst.sort()\n",
        "#print(lst)\n",
        "if len(lst) %2 == 0:\n",
        "    print(int((lst[len(lst)//2-1]+lst[len(lst)//2+1])/2-1))\n",
        "else:\n",
        "    print(int(lst[len(lst)//2]))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vGadQKet9rlQ",
        "outputId": "cfb4b754-166b-4632-e9ab-fafab8d854eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 3\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "users = [\n",
        "    {\n",
        "        \"id\": 1,\n",
        "        \"name\": \"Anton\",\n",
        "        \"position\": {\n",
        "            \"name\": \"Backend\",\n",
        "            \"lang\": \"Python\"\n",
        "        }\n",
        "    },\n",
        "    {\n",
        "        \"id\": 1,\n",
        "        \"name\": \"Ivan\",\n",
        "        \"position\": {\n",
        "            \"name\": \"Frontend\",\n",
        "            \"lang\": \"JS\"\n",
        "        }\n",
        "    },\n",
        "]\n",
        "\n",
        "\n",
        "print(users[1][\"name\"], users[0][\"position\"][\"name\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gbVcBGXcC1A2",
        "outputId": "6926a6b5-a031-4d1a-bd0b-5791e2bcb35c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ivan Backend\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print({i if i == 24 else 'ff': i*i for i in [j for j in range(100)] if i % 17 == 0}['ff'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sQPn87KaDVqi",
        "outputId": "46a9d8db-5b61-4436-f4cf-fcce1696d5eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7225\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from heapq import heappush, heappop\n",
        "\n",
        "heap = []\n",
        "heappush(heap, 0.10)\n",
        "heappush(heap, 0.12)\n",
        "heappush(heap, 0.20)\n",
        "heappush(heap, 1.10)\n",
        "heappush(heap, 1.15)\n",
        "heappush(heap, 1.7)\n",
        "heappush(heap, 2.0)\n",
        "\n",
        "print(heappop)\n",
        "for i in range(len(heap)):\n",
        "    print(heappop(heap))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ItvJpHleOnwG",
        "outputId": "e893ead4-c96d-42d7-dd3e-cbb9a756c2d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<built-in function heappop>\n",
            "0.1\n",
            "0.12\n",
            "0.2\n",
            "1.1\n",
            "1.15\n",
            "1.7\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "st = \"Пётр идет домой\".split()\n",
        "del st[::1]\n",
        "st"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zV5H0uDMkGOu",
        "outputId": "c173fde0-eab9-4b2e-91e7-0ad19d76e3c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#l = [1,2,3,'ls','t',5, 3.14,3.14]\n",
        "#l.append('al')\n",
        "#l.pop()\n",
        "#l.count(3.14)\n",
        "l = [1,24,2,5,6]\n",
        "l.sort()\n",
        "l\n",
        "#l.reverse()\n",
        "l\n",
        "for el in l:\n",
        "  print(el)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JWG0u0bU-91m",
        "outputId": "36100188-736f-4085-eaf9-50b9a2e29277"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "5\n",
            "6\n",
            "24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def func(**kwargs):\n",
        "  for key in kwargs:\n",
        "    print(key, kwargs[key])\n",
        "\n",
        "func(name = 'Test', number = 2, status = True)"
      ],
      "metadata": {
        "id": "nnRCWk1u_t95",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80b28471-542b-40c3-a059-dce26b522f16"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name Test\n",
            "number 2\n",
            "status True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def func_test(x):\n",
        "  if x <= -2:\n",
        "    return 1-((x+2)**2)\n",
        "  elif -2<x<=2:\n",
        "    return -x/2\n",
        "  else:\n",
        "    return (x-2)**2+1\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  print(func_test(4.5))\n",
        "  print(func_test(1))\n",
        "  print(func_test(-4.5))\n",
        "  \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VS8gyzTQiXhM",
        "outputId": "01b4cdca-7ce0-47b1-c405-0d00f453fc2a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7.25\n",
            "-0.5\n",
            "-5.25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def f(x):\n",
        "    if x <= -2:\n",
        "        square = (x + 2) ** 2\n",
        "        x = 1 - square \n",
        "    elif x > -2 and x <= 2:\n",
        "        m = -(x / 2)\n",
        "        x = m\n",
        "    elif x > 2:\n",
        "        square1 = (x - 2) ** 2\n",
        "        x = square1 + 1\n",
        "    return x\n",
        "print(f(-4.5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JHEbCaZrjmYz",
        "outputId": "46e41916-5a76-45ad-83e5-204e32efe2ae"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-5.25\n"
          ]
        }
      ]
    }
  ]
}