\n",
"\n",
"**Задача 1. Номер появления слова** \n",
"В единственной строке записан текст. Для каждого слова из данного текста подсчитайте, сколько раз оно встречалось в этом тексте ранее. \n",
"*Словом считается последовательность непробельных символов идущих подряд, слова разделены одним или большим числом пробелов или символами конца строки.*\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Дано\n",
"simple_text = \"one two three two two one\"\n",
"patterer = \"макака коалу в какао макала, \\n\\\n",
"коала какао лениво лакала, \\n\\\n",
"макака макала, коала икала, \\n\\\n",
"устала макака - какао не стало.\"\n",
"#print(patterer)\n",
"# Решение 1\n",
"d = {}\n",
"for word in simple_text.split():\n",
" if word in d:\n",
" print(d[word], end = ' ')\n",
" d[word] += 1\n",
" else:\n",
" print(0, end = ' ')\n",
" d[word] = 1 \n",
"\n",
"# Решение 2\n",
"d = dict()\n",
"for word in patterer.split():\n",
" print(d.get(word, 0), end = ' ')\n",
" d[word] = d.get(word, 0) + 1\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Задача 2. Словарь синонимов** \n",
"Дан словарь, состоящий из пар слов. Каждое слово является синонимом к парному ему слову. Все слова в словаре различны. Для слова из словаря, записанного в последней строке, определите его синоним.\n",
"\n",
"| Пример ввода|Образец вывода|\n",
"|:--|--:|\n",
"|`3`| |\n",
"|`Hello Hi`| |\n",
"|`Bye Goodbye`| |\n",
"|`List Array`| |\n",
"|`Goodbye`|`Bye`|\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"n:3\n",
"2 synonims: hi hello\n",
"2 synonims: bye goodbye\n",
"2 synonims: list array\n"
]
}
],
"source": [
"# Решение\n",
"n = int(input(\"n:\"))\n",
"d = {}\n",
"for i in range(n):\n",
" s1, s2 = input('2 synonims: ').split()\n",
" d[s1] = s2\n",
" d[s2] = s1"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"word:goodbye\n",
"bye\n"
]
}
],
"source": [
"word = input('word:')\n",
"print(d[word])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
" \n",
"**Задача 3. Выборы в США** \n",
"*Как известно, в США президент выбирается не прямым голосованием, а путем двухуровневого голосования. Сначала проводятся выборы в каждом штате, и определяется победитель выборов в данном штате. Затем проводятся государственные выборы: на этих выборах каждый штат имеет определенное число голосов — число выборщиков от этого штата. На практике, все выборщики от штата голосуют в соответствии с результатами голосования внутри штата, то есть на заключительной стадии выборов в голосовании участвуют штаты, имеющие различное число голосов.* \n",
"В первой строке дано количество записей. Далее, каждая запись содержит фамилию кандидата и число голосов, отданных за него в одном из штатов. Подведите итоги выборов: для каждого из участника голосования определите число отданных за него голосов. Участников нужно выводить в алфавитном порядке.\n",
"\n",
"| Пример ввода|Образец вывода|\n",
"|:--|:--|\n",
"|`5`| |\n",
"|`Trump 14`|`Biden 35`|\n",
"|`Biden 26`|`Jorgensen 1` |\n",
"|`Jorgensen 1`| `Trump 34`|\n",
"|`Biden 9`| |\n",
"|`Trump 20`| |\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# Решение\n",
"d = {}\n",
"n = int(input('n = '))\n",
"for i in range(n):\n",
" s = input('data: ')\n",
" name, votes = s.split()\n",
" d[name] = d.get(name, 0) + int(votes)\n",
"print(d) \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for key in sorted(d.keys()):\n",
" print(key, d[key])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Задача 4. Самое частое слово** \n",
"Дан текст: в первой строке задано число строк, далее идут сами строки. Выведите слово, которое в этом тексте встречается чаще всего. Если таких слов несколько, выведите то, которое меньше в лексикографическом порядке.\n",
"\n",
"*В качестве теста попробуйте использовать первые 5-7 строк из Дзен Питона.*"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The Zen of Python, by Tim Peters\n",
"\n",
"Beautiful is better than ugly.\n",
"Explicit is better than implicit.\n",
"Simple is better than complex.\n",
"Complex is better than complicated.\n",
"Flat is better than nested.\n",
"Sparse is better than dense.\n",
"Readability counts.\n",
"Special cases aren't special enough to break the rules.\n",
"Although practicality beats purity.\n",
"Errors should never pass silently.\n",
"Unless explicitly silenced.\n",
"In the face of ambiguity, refuse the temptation to guess.\n",
"There should be one-- and preferably only one --obvious way to do it.\n",
"Although that way may not be obvious at first unless you're Dutch.\n",
"Now is better than never.\n",
"Although never is often better than *right* now.\n",
"If the implementation is hard to explain, it's a bad idea.\n",
"If the implementation is easy to explain, it may be a good idea.\n",
"Namespaces are one honking great idea -- let's do more of those!\n"
]
}
],
"source": [
"# Дзен Питона\n",
"import this"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"n: 5\n",
"> Beautiful is better than ugly\n",
"> Explicit is better than implicit\n",
"> Simple is better than complex\n",
"> Complex is better than complicated\n",
"> Flat is better than nested\n",
"better\n"
]
}
],
"source": [
"# Решение\n",
"d = {}\n",
"n = int(input('n: '))\n",
"for i in range(n):\n",
" s = input('> ')\n",
" for w in s.split():\n",
" d[w] = d.get(w, 0) + 1\n",
"mx = max(d.values()) \n",
"a = [word for word in d if d[word]==mx]\n",
"print(min(a))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"Beautiful is better than ugly\n",
"Explicit is better than implicit\n",
"Simple is better than complex\n",
"Complex is better than complicated\n",
"Flat is better than nested"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['is', 'better', 'than']"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Задача 5. Частотный анализ** \n",
"Дан текст: в первой строке записано количество строк в тексте, а затем сами строки. Выведите все слова, встречающиеся в тексте, по одному на каждую строку. Слова должны быть отсортированы по убыванию их количества появления в тексте, а при одинаковой частоте появления — в лексикографическом порядке. \n",
"*Указание. После того, как вы создадите словарь всех слов, вам захочется отсортировать его по частоте встречаемости слова. Желаемого можно добиться, если создать список, элементами которого будут кортежи из двух элементов: частота встречаемости слова и само слово. Например,*\n",
"```python\n",
"[(2, 'hi'), (1, 'what'), (3, 'is')]\n",
"```\n",
"*Тогда стандартная сортировка будет сортировать список кортежей, при этом кортежи сравниваются по первому элементу, а если они равны — то по второму. Это почти то, что требуется в задаче.*\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"d = dict()\n",
"n = int(input('n: '))\n",
"for i in range(n):\n",
" s = input('> ')\n",
" for w in s.split():\n",
" d[w] = d.get(w, 0) + 1\n",
"a = [(-d[w], w) for w in d] # обратите внимание на минус!\n",
"a.sort()\n",
"\n",
"for n, word in a:\n",
" print(word)\n",
"\n",
"# for w in a:\n",
"# print(w[1])\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Задача 1. Сумма двух**. \n",
"Дан список целых чисел `nums` и целое число `target` $-$ целевое значение. Нужно вычислить индексы двух элементов списка, сумма которых равна этому целевому значению.\n",
"\n",
"Еще раз: \n",
"найти индексы `i` и `j`, такие что `i!=j` и `nums[i] + nums[j] == target`.\n",
"\n",
"При решении нужно считать, что в списке есть только одна такая пара элементов."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"# очевидное плохое правильное решение\n",
"def sum_two(nums, target):\n",
" n = len(nums)\n",
" for i in range(n-1):\n",
" for j in range(i+1, n):\n",
" if nums[i]+nums[j]==target:\n",
" return [i, j]"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"nums = [2,7,11,15]\n",
"target = 9\n",
"assert sum_two(nums, target)==[0, 1], 'Тест1 не удался'\n",
"\n",
"nums = [3,2,4]\n",
"target = 6\n",
"assert sum_two(nums, target)==[1,2], 'Тест2 не удался'\n",
"\n",
"nums = [3,3]\n",
"target = 6\n",
"assert sum_two(nums, target)==[0,1], 'Тест3 не удался'"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"16.280023097991943\n"
]
},
{
"ename": "AssertionError",
"evalue": "Слишком долго",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mAssertionError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m
\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[0mdt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mdt\u001b[0m\u001b[1;33m<\u001b[0m\u001b[1;36m0.1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Слишком долго'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mAssertionError\u001b[0m: Слишком долго"
]
}
],
"source": [
"# тест проверки на скорость работы алгоритма\n",
"from random import randint\n",
"from time import time\n",
"n = 10**5\n",
"nums = [randint(1, n) for _ in range(n)]\n",
"nums[1000] = -5\n",
"nums[n - 1000] = -5\n",
"target = -10\n",
"t = time()\n",
"assert sum_two(nums, target)==[1000,n-1000], 'Тест4 не удался'\n",
"dt = time()-t\n",
"print(dt)\n",
"assert dt<0.1, 'Слишком долго'"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 - 3 1 - 5 2 - 7 3 - 11 4 - 0 5 - 5 \n",
"--------------\n",
"0 - 3 1 - 5 2 - 7 3 - 11 4 - 0 5 - 5 "
]
}
],
"source": [
"# сначала поговорим про enumerate\n",
"a = [3, 5, 7, 11, 0, 5]\n",
"\n",
"for i in range(len(a)):\n",
" print(i, '-', a[i], end = ' ')\n",
"print('\\n--------------') \n",
"for i, x in enumerate(a):\n",
" print(i, '-', x, end=' ')"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"# правильное хорошее решение\n",
"def sum_two_good(nums, target):\n",
" d = {}\n",
" for i, x in enumerate(nums):\n",
" if x in d: \n",
" return [d[x], i]\n",
" else:\n",
" d[target-x] = i\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"nums = [2,7,11,15]\n",
"target = 9\n",
"assert sum_two_good(nums, target)==[0, 1], 'Тест1 не удался'\n",
"\n",
"nums = [3,2,4]\n",
"target = 6\n",
"assert sum_two_good(nums, target)==[1,2], 'Тест2 не удался'\n",
"\n",
"nums = [3,3]\n",
"target = 6\n",
"assert sum_two_good(nums, target)==[0,1], 'Тест3 не удался'"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.05000019073486328\n"
]
}
],
"source": [
"# тест проверки на скорость работы алгоритма\n",
"from random import randint\n",
"from time import time\n",
"n = 10**5\n",
"nums = [randint(1, n) for _ in range(n)]\n",
"nums[1000] = -5\n",
"nums[n - 1000] = -5\n",
"target = -10\n",
"t = time()\n",
"assert sum_two_good(nums, target)==[1000,n-1000], 'Тест4 не удался'\n",
"dt1 = time()-t\n",
"print(dt1)\n",
"assert dt1<1, 'Слишком долго'"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"325.599219897385"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dt/dt1\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Задача А.** В тексте программы несколько переменных получили значения. Например,\n",
"\n",
"```python\n",
"n = 1\n",
"pi = 3.14\n",
"s = 'hello'\n",
"```\n",
"Требуется создать словарь, ключами которого были бы имена переменных, а значениями – значения этих переменных. В приведенном примере должен получиться словарь\n",
"\n",
"```python\n",
"{'n': 1, 's': 'hello', 'pi': 3.14}\n",
"```\n",
"\n",
"Решение должно быть универсальным, т.е. не зависеть от имен использованных переменных и присвоенных им значений.\n",
"\n",
"**Задача Б.** (Не хочу пользоваться списками). Можно ли автоматически (в цикле) присвоить переменным `x1`, `x2`, `x3`, `x4`, `x5` значения 10, 20, 30, 40 и 50?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Идея для решения**\n",
"\n",
"Функция `globals()` выдает словарь глобальных переменных (ключ – имя переменной). Функция `locals()` возвращает словарь только локальных переменных. \n",
"Пример ниже. \n",
"\n",
"\n",
" \n",
"Предупреждение: В Ipython Notebook получится слишком много вывода. Лучше выполнить в Python Shell. Или хотя бы перезагрузить ядро.\n",
" \n",
"С другой стороны, если выполнить прямо здесь, станет понятнее, что такое `In[1]` и т.д.\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x, y = 5, 10\n",
"def test():\n",
" y, z = 33, 44\n",
" print('globals:', globals())\n",
" print('locals:', locals())\n",
"test()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Решение задачи Б\n",
"for i in range(1,6):\n",
" globals()[\"x\"+str(i)] = 10*i\n",
"print(x1, x2, x3, x4, x5) "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Решение задачи А\n",
"main_dict = set(locals().keys())\n",
"#------------------------------------\n",
"nnn = 1\n",
"ppi = 3.14\n",
"qq = 234455\n",
"ss = 'hello'\n",
"#------------------------------------\n",
"cur_dict = set(locals().keys())\n",
"d = {}\n",
"for key in cur_dict - main_dict - {'main_dict'}:\n",
" d[key]=locals()[key]\n",
"print(d)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.11.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}