Yummy🍭Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Yummy🍭Python.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPpwxnEV81FpgvdAG0Hb84M",
      "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/Yummy%F0%9F%8D%ADPython.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": 2,
      "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": 8,
      "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": 4,
      "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": 7,
      "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": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NO\n"
          ]
        }
      ]
    }
  ]
}