basic_principles_part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2 Модель данных: объекты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Реализуйте программу, которая будет вычислять количество различных объектов в списке.\n",
    "Два объекта a и b считаются различными, если a is b равно False.\n",
    "\n",
    "Вашей программе доступна переменная с названием objects, которая ссылается на список, содержащий не более 100 объектов. Выведите количество различных объектов в этом списке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "objects = [1, 2, 1, 5, 0, True, False, True, 'false', [], [1,2], [1,2], (222)]\n",
    "len(objects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# первая попытка, мой вариант\n",
    "\n",
    "types_obj = set()\n",
    "\n",
    "for obj in objects:\n",
    "    if id(obj) not in types_obj:\n",
    "        types_obj.add(id(obj))\n",
    "print(len(types_obj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# второй вариант, условие не нужно если работаю с множеством, добавляю list comprehension\n",
    "\n",
    "types_obj = set()\n",
    "[types_obj.add(id(obj)) for obj in objects]\n",
    "print(len(types_obj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# правильный вариант преподавателя с проходкой по двум спискам и сравнением объектов поочерёдно\n",
    "# 1 is 2, 2 is 3 etc.\n",
    "\n",
    "n = len(objects)\n",
    "ans = n\n",
    "for i in range(n):\n",
    "    for j in range(i):\n",
    "        if id(objects[i]) == id(objects[j]):\n",
    "            ans -= 1\n",
    "            break\n",
    "\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Стэк вызовов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "MODULE\n",
      "- G -  <function f at 0x1099a8940>\n",
      "- F\n",
      "- G -  <function h at 0x1099a8790>\n",
      "- H\n",
      "- 12\n",
      "H - end\n",
      "G - end\n",
      "F - end\n",
      "G - end\n"
     ]
    }
   ],
   "source": [
    "def h():\n",
    "    print(\"- H\")\n",
    "    print(\"- 12\")\n",
    "    print(\"H - end\")\n",
    "\n",
    "def f():\n",
    "    print(\"- F\")\n",
    "    g(h)\n",
    "    print(\"F - end\")\n",
    "\n",
    "def g(a):\n",
    "    print(\"- G - \",a)\n",
    "    a()\n",
    "    print(\"G - end\")\n",
    "\n",
    "print(\"\\nMODULE\")\n",
    "g(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Напишите реализацию функции **closest_mod_5**, принимающую в качестве единственного аргумента целое число **x** и возвращающую самое маленькое целое число **y**, такое что:\n",
    "\n",
    "- **y** больше или равно **x**\n",
    "- **y** делится нацело на 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def closest_mod_5(x):\n",
    "    if x % 5 == 0:\n",
    "        return x\n",
    "    return (x + 5) - (x % 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "closest_mod_5(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# решение преподавателя через рекурсию\n",
    "def closest_mod_5_prep(x):\n",
    "    return x if x % 5 == 0 else closest_mod_5(x + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "closest_mod_5_prep(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.3 Задачка на сочетание элементов из n по k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сочетанием из n элементов по k называется подмножество этих n элементов размера k.\n",
    "Два сочетания называются различными, если одно из сочетаний содержит элемент, который не содержит другое.\n",
    "Числом сочетаний из n по k называется количество различных сочетаний из n по k. Обозначим это число за C(n, k).\n",
    "\n",
    "Пример:\n",
    "- Пусть n = 3, т. е. есть три элемента (1, 2, 3). Пусть k = 2.\n",
    "- Все различные сочетания из 3 элементов по 2: (1, 2), (1, 3), (2, 3).\n",
    "- Различных сочетаний три, поэтому C(3, 2) = 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, k = map(int, input().split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# моё решение через рекурсию\n",
    "\n",
    "def c_is_n_k(n, k):\n",
    "    if k > n:\n",
    "        return 0\n",
    "    elif k == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return c_is_n_k(n-1, k) + c_is_n_k(n-1, k-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "252"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n, k = map(int, input().split())\n",
    "c_is_n_k(n, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# оптимальное решение через какой-то треугольник Паскаля\n",
    "n, k = map(int, input().split())\n",
    "\n",
    "sz = max(n, k) + 1\n",
    "c = [[0] * sz for _ in range(sz)]\n",
    "\n",
    "c[0][0] = 1\n",
    "for i in range(1, sz):\n",
    "    for j in range(i + 1):\n",
    "        c[i][j] = c[i - 1][j] + c[i - 1][j - 1]\n",
    "\n",
    "print(c[n][k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "watafak?\n"
     ]
    }
   ],
   "source": [
    "nums = [2]\n",
    "if not nums:\n",
    "    print('not nums')\n",
    "else:\n",
    "    print('watafak?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1074"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = [439, 635]\n",
    "sum(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ss'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dct = {1: 'ss', 2: 'tt'}\n",
    "dct[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}