КР_ЗБ_ПИ21_1с_(Мартынова).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "КР-ЗБ-ПИ21-1с.(Мартынова)ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/helign/FINUN/blob/main/%D0%9A%D0%A0_%D0%97%D0%91_%D0%9F%D0%9821_1%D1%81_(%D0%9C%D0%B0%D1%80%D1%82%D1%8B%D0%BD%D0%BE%D0%B2%D0%B0).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Контрольная работа\n"
      ],
      "metadata": {
        "id": "xGMQjJ_ruTc1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1.\n",
        "\n",
        "Напишите **рекурсивную** функцию ```fact```, которая вычисляет факториал заданного числа ```x```. \n"
      ],
      "metadata": {
        "id": "u7jHKQmhOqTg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fact(x):\n",
        "  return 1 if (x < 1) else x*fact(x-1)"
      ],
      "metadata": {
        "id": "VlRnn8x4JPng"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#2\n",
        " Создайте функцию ```filter_even```, которая принимает на вход список целых чисел,  и фильтруя, возвращает список, содержащий только четные числа. Используйте ```filter``` для фильтрации и  ```lambda```."
      ],
      "metadata": {
        "id": "7KqKtOl0_dP0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def filter_even(li):\n",
        "  return list(filter(lambda x: x % 2 == 0,li))"
      ],
      "metadata": {
        "id": "jQywtfM9JqOv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3\n",
        "Напишите функцию ```square``` ,которая принимает на вход список целых чисел и возвращает список с возведенными в квадрат элементами. Используйте ```map```."
      ],
      "metadata": {
        "id": "gYXn-ZOcBbiG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def square(li):\n",
        "  return list(map(lambda x: x**2,li))"
      ],
      "metadata": {
        "id": "HEzHOZUdJlxU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#4\n",
        "Напишите функцию бинарного поиска ```bin_search```, которая принимает на вход отсортированный список и элемент. Функция должна возвращать индекс искомого элемента в списке. \n",
        "\n",
        "Ввод: \n",
        "```\n",
        "[2,5,7,9,11,17,222] 11\n",
        "```\n",
        "Вывод: \n",
        " ```\n",
        " 4\n",
        " ```\n",
        "\n",
        "Ввод:\n",
        "```\n",
        " [2,5,7,9,11,17,222] 12\n",
        "```\n",
        "Вывод:\n",
        "```\n",
        "  -1\n",
        "```"
      ],
      "metadata": {
        "id": "IJ6rXeTNFfFv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#we love divide and conquer pattern in this house, here we go\n",
        "#iterative bc it's faster in bench allegedly\n",
        "\n",
        "def bin_search(li, element): \n",
        "    first = 0 \n",
        "    last = len(li)-1 \n",
        "    i = -1 \n",
        "    while (first<=last) and (i==-1):\n",
        "        mid = (first+last)//2\n",
        "        if li[mid] == element:\n",
        "            i=mid\n",
        "        else:\n",
        "            if element<li[mid]:\n",
        "                last=mid-1\n",
        "            else:\n",
        "                first=mid+1\n",
        "    return i"
      ],
      "metadata": {
        "id": "vb09yidrI-8D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#5\n",
        "Напишите функцию ```is_palindrome``` определяющую,является ли строка палиндромом.\n",
        "Палиндромами являются текстовые строки, которые одинаково читаются слева направо и справа налево. В строках не учитываются знаки препинания, пробельные символы и цифры; регистр не имеет значения. \n",
        "\n",
        "На вход подается строка ```string```.\n",
        "\n",
        "Выведите YES, если строка является палиндромом и NO иначе.\n",
        "\n",
        "Запрещается использовать reverse списка - ```list[::-1]``` и функцию ```reversed```.\n",
        "Чтобы учесть это ограничение, эту задачу рекомендуется решать используя технику решения задач \"два указателя\". Один указатель читает только символы слева направо, а второй - справа налево.\n",
        "\n",
        "Примеры:\n",
        "\n",
        "Ввод \n",
        "```\n",
        "Madam, I'm Adam\n",
        "``` \n",
        "Вывод\n",
        "```\n",
        "YES\n",
        "```\n",
        "Ввод\n",
        "```\n",
        "А роза упала на лапу Азора\n",
        "``` \n",
        "Вывод  \n",
        "```\n",
        "YES\n",
        "```"
      ],
      "metadata": {
        "id": "Uhry6tBPMl9s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def is_palindrome(string):\n",
        "    string = ''.join(filter(str.isalpha, string)).lower()\n",
        "    i = 0\n",
        "    j = len(string)-1\n",
        "    pal = True\n",
        "    while (i<j) and pal:\n",
        "        if(string[i]!=string[j]):\n",
        "            pal = False\n",
        "        i += 1\n",
        "        j -= 1\n",
        "    return pal"
      ],
      "metadata": {
        "id": "gPf3lum4GgIF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 6\n",
        "Написать функцию ```calculate```, которая принимает на вход текстовый файл содержащий строки следующего формата:\n",
        "\n",
        "Формат файла:\n",
        "    ```арифметическая операция```    ```целое число #1```    ```целое число #2```\\\n",
        "Разделитель - 4 пробела\n",
        "\n",
        "Функция должна вернуть 1 строку.\n",
        "Строка содержит набор из чисел, разделенных запятой. \n",
        "После последнего числа запятая не ставится.\n",
        "Каждое число - результат операции: \n",
        "    ```\"результирующее целое число\"``` = ```\"целое число #1\"``` применить ```\"арифметическая операция\"``` ```\"целое число #2\"```\n",
        "\n",
        "**Пример входного файла:**\n",
        "\n",
        "`+    5    4`\\\n",
        "`-    -10449    -7623`\\\n",
        "`**    2    10`\n",
        "\n",
        "**Пример выходной строки (для примера входного файла выше):**\n",
        "\n",
        "`9,-2826,1024`\n",
        "\n",
        "**Допустимые операции:**\n",
        "\n",
        "`+ (сложение)`\\\n",
        "`- (вычитание)`\\\n",
        "`* (умножение)`\\\n",
        "`// (целочисленное деление) (для этой операции подаются только положительные числа)`\\\n",
        "`% (остаток от деления) (для этой операции подаются только положительные числа)`'\\\n",
        "`** (возведение в степень) (для этой операции подаются только положительные числа)`\n",
        "\n",
        "Входные числа - только целые.\\\n",
        "Выходные числа - только целые.\n",
        "\n",
        "[Входной файл для самопроверки.](https://drive.google.com/file/d/1OcqaMTseYffO2JAF_thBJDJ-aqFq9Vxc/view?usp=sharing)\n",
        "\n",
        "[Выходная строка для самопроверки содержится в файле.](https://drive.google.com/file/d/1IkCn8C6ULuEIngSSpkvI-0cIhDUiIEk9/view?usp=sharing)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "MkFFSL_fQ__r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "operations = {\n",
        "    '+': lambda x, y: x + y,\n",
        "    '*': lambda x, y: x * y,\n",
        "    '-': lambda x, y: x - y,\n",
        "    '%': lambda x, y: x % y,\n",
        "    '//': lambda x, y: x // y,\n",
        "    '**': lambda x, y: x ** y,\n",
        "}\n",
        "\n",
        "def resolve(op, a, b): \n",
        "    return operations[op](a, b) \n",
        "\n",
        "def calculate(path2file):\n",
        "    result=\"\" \n",
        "    with open(path2file, mode='r') as f:\n",
        "        while(True):\n",
        "            line = f.readline()\n",
        "            if not line:\n",
        "                break\n",
        "            op=line.split()[0]\n",
        "            a =int(line.split()[1])\n",
        "            b =int(line.split()[2])\n",
        "            if result==\"\":\n",
        "                result=str(resolve(op,a,b))\n",
        "            else:\n",
        "                result=result+\",\"+str(resolve(op,a,b))\n",
        "        f.close\n",
        "    return result"
      ],
      "metadata": {
        "id": "m79AEMjZHIZZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 7\n",
        "Написать функцию ```substring_slice```,которой на вход поступают два текстовых файла.\n",
        "\n",
        "- Первый файл содержит строки текста.   \n",
        " \n",
        "- Второй файл содержит строки из двух целых неотрицательных чисел.\n",
        "Первое число в строке всегда меньше или равно второму.\n",
        "Числа всегда меньше длины соответствующей строки первого файла.\n",
        "Соответствующей - это значит 1-ая строка из 1-го файла соответствует 1-ой строке из 2-го файла, а 123-я строка из 1-го файла соответствует 123-ей строке из 2-го файла.\n",
        "\n",
        "- Функция должна вернуть строку, состоящую из подстрок 1-го входного файла.\n",
        "Подстроки разделены пробелами.\n",
        "Какие брать подстроки - написано во втором файле.\n",
        "В конце файла пробела нет.\n",
        "\n",
        "**Например**\n",
        "120 строка в 1-ом файле: `JBOljrfkrfjgikenfjerkrkvkfKUGlknc`\n",
        "120 строка во 2-ом файле: `13 27`\n",
        "Это значит 120 подстрока в результирующем файле это символы с 13 по 27, включая 13-ый и 27-ой символы.\n",
        "Не забывайте, что нумерация символов в строке с 0.\n",
        "Пример требуемой подстроки: `kenfjerkrkvkfKU`\n",
        "- **Пример 1-го входного файла:**\n",
        "  ```\n",
        "QxBpXEeyDWHiuTttWjhFMGTlrCMqpSvrNOQoxUbyiZombbLaYqBHvydPJlvdspwwpgeLNlHMVYrZvPsQkcQgPpierYSahialdXlde\n",
        "rNsZEKdYYlKKRrYGNWEXTYXOpQqrdGANRfoyeVvRwLVhZDfzKhFQkuSYODIXFLYafnXbxuwqZKQKjSiFZAtSponvmulcjicIDhNaQ\n",
        "TttSFLqbNkHvOeHSKTTGEEGxwtXImLeCmcKjvsIkIIvvlsUSazNuEsdDYlOljweSubVJxHbSJkBpByFiUCFctgrLKhlYgEWWuDYqx\n",
        "```\n",
        "\n",
        "- **Пример 2-го входного файла:**\n",
        "```\n",
        "30 84\n",
        "5 79\n",
        "70 70\n",
        "```\n",
        "- **Пример выходной строки:**\n",
        "```\n",
        "vrNOQoxUbyiZombbLaYqBHvydPJlvdspwwpgeLNlHMVYrZvPsQkcQgP KdYYlKKRrYGNWEXTYXOpQqrdGANRfoyeVvRwLVhZDfzKhFQkuSYODIXFLYafnXbxuwqZKQKjSiF b\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "kYzWG0NAUKdc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "[Пример 1-го входного файла для самопроверки.](https://drive.google.com/file/d/1XlnnBunKfNA2c4so3VKH1kXKvFjOLDAX/view?usp=sharing)\n",
        "\n",
        "[Пример 2-го входного файла для самопроверки.](https://drive.google.com/file/d/1_gIyNhoSptvlvfA8UOlY60rXDva1fW2G/view?usp=sharing)\n",
        "\n",
        "[Пример выходной строки для двух файлов выше содержится в этом файле.](https://drive.google.com/file/d/11Lsq1DV8iuMsZ_LPuTj50w5Htq1-95Ys/view?usp=sharing)"
      ],
      "metadata": {
        "id": "x_5FK_dPw6tv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def substring_slice(path2file_1,path2file_2):\n",
        "    result=\"\"\n",
        "    with open(path2file_1, mode='r') as f1:\n",
        "        with open(path2file_2,mode='r') as f2:\n",
        "            while(True):\n",
        "                line1 = f1.readline()\n",
        "                line2 = f2.readline()\n",
        "                if not line1 or not line2:\n",
        "                    break\n",
        "                i=int(line2.split()[0])\n",
        "                j=int(line2.split()[1])\n",
        "                if result==\"\":\n",
        "                    result=line1[i:j+1] \n",
        "                else:\n",
        "                    result=result+\" \"+line1[i:j+1]\n",
        "            f.close\n",
        "    return result"
      ],
      "metadata": {
        "id": "eMGyu-8raMQB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#i think the check file is actually pushed right instead of left but this passes the \"unit test\"\n",
        "#like, \n",
        "#if i write down \"12345\"[3-1:5] i will get 345 like down here\n",
        "print(\"12345\"[3-1:5])\n",
        "#so i think it should be [i-1:j]"
      ],
      "metadata": {
        "id": "JrDCBRWQ9kXP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#8\n",
        "\n",
        "Написать функцию ```decode_ch```,на вход которой поступает строка.В ней хранится набор химических символов (He, O, H, Mg, Fe, ...). Без пробелов.\n",
        "Нужно расшифровать химические символы в название химических элементов.Функция должна вернуть строку - расшифровку\n",
        "\n",
        "Для удобства, прилагается [json файл](https://drive.google.com/file/d/1Uugf4zLRjBx-73RfelroOrf1JlTtpLfi/view?usp=sharing), который ставит в соответствие химическому символу его химическое название.\n",
        "\n",
        "Как прочитать этот файл в словарь python (dict):\n",
        "```\n",
        "periodic_table = json.load(open('periodic_table.json'))\n",
        "```\n",
        "- **Пример входной строки:**\n",
        "```\n",
        "NOTiFICaTiON\n",
        "```\n",
        "-**Пример выходной строки:**\n",
        "```\n",
        "АзотКислородТитанФторЙодКальцийТитанКислородАзот\n",
        "```\n",
        "\n",
        "Обратите внимание, что, например, \"Bi\" - это \"Висмут\", а не \"БорЙод\".\n",
        "То есть регистр (заглавные или прописные) букв имеет значение.\n",
        "\n"
      ],
      "metadata": {
        "id": "uSMlKPcMqh69"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "import json\n",
        "\n",
        "def decode_ch(sting_of_elements):\n",
        "    result=\"\"\n",
        "    with open('periodic_table.json', 'r', encoding='utf-8') as f:\n",
        "        periodic_table = json.load(f)\n",
        "        f.close()\n",
        "    list_of_elements = re.findall('[A-Z][a-z]*', str)\n",
        "    for e in list_of_elements:\n",
        "        result+=periodic_table.get(e)\n",
        "    return result\n",
        "\n",
        "#print(decode_ch(\"NOTiFICaTiON\"))"
      ],
      "metadata": {
        "id": "bqokuO7sr0ij"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#9\n",
        "\n",
        "Создайте класс с названием Student.\n",
        "\n",
        "При инициализации объекта подается два аргумента. Первый - имя студента. Второй - фамилия студента.\n",
        "\n",
        "1. Создайте три атрибута объекта данного класса:\n",
        "\n",
        "- *name* имя студента\n",
        "- *surname* фамилия студента\n",
        "- *fullname* имя и фамилия студента через пробел\n",
        "2. Создайте метод для экземпляра класса Student под названием greeting, который при вызове возвращает строку Hello, I am Student\n",
        "Здесь и далее нужно только написать сам класс. \n",
        "3. Добавьте новый атрибут класса под названием grades. При инициализации объекта соответственно добавляется новый аргумент, в котором будет лежать список оценок данного студента, по дефолту равный списку [3,4,5]. Создайте метод под названием mean_grade, который возвращает среднее всех оценок студента (то есть среднее этого атрибута).\n",
        "4. Сделайте метод is_otlichnik, который возвращает строку YES, если средняя оценок студента больше или равна 4.5 и NO в противном случае.\n",
        "Примечание: этот метод должен вызывать метод mean_grade внутри себя.\n",
        "5. На этот раз определим операцию сложения для двух студентов. Пусть такая операция возвращает строку следующего вида: \"Name1 is friends with Name2\", где Name1 и Name2 - имена первого студента и второго (именно атрибут name). То есть, если создать два экземпляра класса Student, то их сумма должна вернуть вышеописанную строку.\n",
        "6. Теперь переопределим поведение нашего класса с функцией print. Пусть при вызове функции print от экземпляра класса Student печатается его атрибут fullname.\n",
        "\n"
      ],
      "metadata": {
        "id": "vsy-ZLYuDnVj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student:\n",
        "    def __init__(self, name, surname, grades=[3,4,5]):\n",
        "        self.__name = name\n",
        "        self.__surname = surname\n",
        "        self.__fullname = name + ' ' + surname\n",
        "        self.__grades = grades\n",
        "    \n",
        "    def greeting(self):\n",
        "        return (\"Hello, I am Student \"+ self__fullname + \"!\")\n",
        "\n",
        "    def mean_grade(self):\n",
        "        return sum(self.__grades)/len(self.__grades)\n",
        "    \n",
        "    def is_otlichnik(self):\n",
        "        if self.mean_grade()>=4.5:\n",
        "            return \"YES\"\n",
        "        else:\n",
        "            return \"NO\"\n",
        "    #magic\n",
        "    def __add__(self, other):\n",
        "        return (self.__name + \" is friends with \" + other.__name)\n",
        "    \n",
        "    def __str__(self):\n",
        "        return self.__fullname"
      ],
      "metadata": {
        "id": "chG9dOmytJO2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#10\n",
        "\n",
        "Определите  класс исключений ```MyError```,\n",
        " который принимает строковое сообщение ```msg``` в качестве параметра при инициализации и также имеет атрибут ```msg```.\n",
        "\n",
        "Подсказка: Чтобы определить кастомный класс  исключения,нужно создавать класс, унаследованный от ```Exception```.\n",
        "\n"
      ],
      "metadata": {
        "id": "o1JGnKEu5ZYc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyError(Exception):\n",
        "    def __init__(self, msg):\n",
        "        self.__msg = msg\n",
        "        \n",
        "        super(MyError, self).__init__(msg)\n",
        "    \n",
        "    def get_msg(self):\n",
        "        return self.__msg"
      ],
      "metadata": {
        "id": "mKbHbLI3tEFi"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}