├── 156.Опечатки ├── input.txt └── Опечатки.ipynb ├── 161.ГенераторТочекВКруге └── ГенераторТочекВКруге.ipynb ├── 163.СуммаНаГранях └── СуммаНаГранях.ipynb ├── 171.КоллекцияСтатуэток ├── input.txt └── КоллекцияСтатуэток.ipynb ├── 177.ТайнаЕгипетскихПирамид └── ТайнаЕгипетскихПирамид.ipynb ├── 178.РешающийПень └── РешающийПень.ipynb ├── 184.ВосстановлениеКоэффициентов ├── data.csv └── ВосстановлениеКоэффицентов.ipynb ├── 200.Разминка ├── output.csv ├── test.tsv ├── train.tsv └── Разминка.ipynb ├── 207.ОбобщенныйAUC ├── input.txt ├── output.txt └── ОбобщенныйAUC.ipynb ├── 209.Перестановки ├── out.txt ├── permutations.in └── Перестановки.ipynb ├── 214-327.Рестораны-Рестораны2 ├── restaurants_train.txt └── Рестораны.ipynb ├── 221.ЛинейноРазделимаяВыборка ├── input.txt └── ЛинейноРазделимаяВыборка.ipynb ├── 224.УникальныеЗапросы └── УникальныеЗапросы.ipynb ├── 233.РанжированиеПоПарам └── РанжированиеПоПарам.ipynb ├── 240.Монетки ├── coins.in ├── output.txt └── Монетки.ipynb ├── 243.РекомендательнаяСистемаSVD ├── input.txt └── РекомендательнаяСистемаSVD.ipynb ├── 262.ЛентаРекомендаций ├── input.txt └── ЛентаРекомендаций.ipynb ├── 266.КластеризацияСимвольныхПоследовательностей ├── input.txt └── КластеризацияСимвольныхПоследовательностей.ipynb ├── 271.Интерполяция └── Интерполяция.ipynb ├── 282.D-CoV-3999 ├── D-CoV-3999.ipynb └── input.txt ├── 283.КанатнаяДорога ├── input.txt └── КанатнаяДорога.ipynb ├── 288.ОптимальнаяКонстанта ├── input.txt ├── output.txt └── ОптимальнаяКонстанта.ipynb ├── 297.Исчезнувшая ├── bad_in.txt ├── bad_in12.txt ├── in-search-of-kitty_test-2.txt ├── input2.txt └── Исчезнувшая.ipynb ├── 301.БутылкиРома ├── output.txt └── БутылкиРома.ipynb ├── 312.ИннокентийИДрузья ├── answers.csv └── ИннокентийИДрузья.ipynb ├── 314.ОптимальнаяКонстанта2 ├── input.txt └── ОптимальнаяКонстанта2.ipynb ├── 318.МногорукийБандит └── МногорукийБандит.ipynb ├── 322.БезградиентнаяОптимизация └── БезградиентнаяОптимизацияФункции.ipynb ├── 373.Омографы ├── word.csv └── Омографы.ipynb ├── 382.ПредсказаниеПогоды ├── input.txt └── ПредсказаниеПогоды.ipynb ├── 384.ЗвездныеКарты2.0 ├── submit.csv └── ЗвездныеКарты2.0.ipynb ├── README.md └── extra_data ├── kanat_explanation.jpg ├── ml_coderun_result.png └── transformers.jpg /156.Опечатки/input.txt: -------------------------------------------------------------------------------- 1 | mlax 2 | drum 3 | 50 4 | l r 5 | mlax gtwt 6 | m d 7 | mlax ujoc 8 | ml pq 9 | m f 10 | ml bf 11 | mlax aruq 12 | mlax nqdd 13 | mlax fglm 14 | mlax bfit 15 | mlax mziq 16 | mla hlb 17 | a u 18 | mlax vmpa 19 | m w 20 | a w 21 | ax ok 22 | mla kqf 23 | m e 24 | x x 25 | ml if 26 | ml gk 27 | l e 28 | mla xrh 29 | m j 30 | a c 31 | a b 32 | m q 33 | ax fr 34 | ml sb 35 | mlax gxxx 36 | x m 37 | mlax hczx 38 | l q 39 | la sv 40 | l g 41 | ax eh 42 | lax mjh 43 | la ec 44 | la pv 45 | ml iq 46 | a q 47 | lax jrs 48 | la qn 49 | lax bjo 50 | l o 51 | a z 52 | l n 53 | a c -------------------------------------------------------------------------------- /156.Опечатки/Опечатки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В качестве первого решения, которое пришло в голову, была идея использовать поиск в ширину, в котором начальной вершиной было слово с ошибками (можно использовать и слово без ошибок, поменяются лишь переходы в обратном порядке), а целью поиска слово без ошибок, в качестве вершин - слова, которые могут быть получены с помощью заданных перестановок, эти слова генерировались по мере углубления. Соответственно, если нашли, то выходим, если длина переходов превысила 4 или все варианты рассмотрены, но слово не найдено, то тоже выходим со значением -1. Однако, данное решение вполне ожидаемо получает TL.\n", 7 | "\n", 8 | "P.S. Внизу представлено решение через поиск в ширину, которое укладывается в лимиты." 9 | ], 10 | "metadata": { 11 | "collapsed": false 12 | } 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 8, 17 | "outputs": [], 18 | "source": [ 19 | "from collections import deque\n", 20 | "\n", 21 | "\n", 22 | "with open('input.txt','r') as f:\n", 23 | " target = f.readline()\n", 24 | " with_errors = f.readline()\n", 25 | " n = int(f.readline())\n", 26 | " pairs = {}\n", 27 | " for _ in range(n):\n", 28 | " correct,error = f.readline().split()\n", 29 | " if error in pairs:\n", 30 | " pairs[error].add(correct)\n", 31 | " else:\n", 32 | " pairs[error] = set([correct])\n", 33 | "\n", 34 | "def nth_repl(s, sub, repl, n):\n", 35 | " \"\"\"\n", 36 | " Функция, которая заменяет N-ное вхождение подстроки в строку\n", 37 | "\n", 38 | " :param s: входная строка\n", 39 | " :param sub: подстрока, которую надо заменить\n", 40 | " :param repl: подстрока, на которую надо заменить\n", 41 | " :param n: номер вхождения подстроки в строку\n", 42 | " :return: строку, в который заменена n-ная подстрока\n", 43 | "\n", 44 | " \"\"\"\n", 45 | " find = s.find(sub)\n", 46 | " i = find != -1\n", 47 | " while find != -1 and i != n:\n", 48 | " find = s.find(sub, find + 1)\n", 49 | " i += 1\n", 50 | " if i == n:\n", 51 | " return s[:find] + repl + s[find+len(sub):]\n", 52 | " return s\n", 53 | "\n", 54 | "deq = deque()\n", 55 | "deq.append((with_errors,0))\n", 56 | "visited = set()\n", 57 | "visited.add(with_errors)\n", 58 | "\n", 59 | "res = -1\n", 60 | "while deq:\n", 61 | " u, path_len = deq.popleft()\n", 62 | " if path_len > 4:\n", 63 | " break\n", 64 | " if u == target:\n", 65 | " res = path_len\n", 66 | " break\n", 67 | " for k,values in pairs.items():\n", 68 | " for v in values:\n", 69 | " replaced = []\n", 70 | " n = u.count(k)\n", 71 | " for i in range(1,n+1):\n", 72 | " elem = nth_repl(u,k,v,i)\n", 73 | " if elem not in visited:\n", 74 | " deq.append((elem,path_len+1))\n", 75 | " visited.add(elem)\n", 76 | "print(res)" 77 | ], 78 | "metadata": { 79 | "collapsed": false 80 | } 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "source": [ 85 | "В следующем решении мы идем с двух концов, то есть проверяем можем ли мы получить искомое слово сделав 2 замены в исходном слове и 2 замены в слове с ошибками, чтобы это проверить мы смотрим имеются ли пересечения между этими двумя множествами, если оно есть, то получается было сделано 4 ошибки. Аналогично для другого количества ошибок. (Например, если после 1 замены у нас в множестве содержится искомое слово, значит, была сделана 1 ошибка и так далее.)" 86 | ], 87 | "metadata": { 88 | "collapsed": false 89 | } 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "outputs": [], 95 | "source": [ 96 | "from collections import deque\n", 97 | "\n", 98 | "with open('input.txt','r') as f:\n", 99 | " target = f.readline()\n", 100 | " with_errors = f.readline()\n", 101 | " n = int(f.readline())\n", 102 | " pairs = {}\n", 103 | " inverse_pairs = {}\n", 104 | " for _ in range(n):\n", 105 | " correct,error = f.readline().split()\n", 106 | " if error in pairs:\n", 107 | " pairs[error].add(correct)\n", 108 | " else:\n", 109 | " pairs[error] = set([correct])\n", 110 | " if correct in inverse_pairs:\n", 111 | " inverse_pairs[correct].add(error)\n", 112 | " else:\n", 113 | " inverse_pairs[correct] = set([error])\n", 114 | "\n", 115 | "\n", 116 | "def nth_repl(s, sub, repl, n):\n", 117 | " find = s.find(sub)\n", 118 | " i = find != -1\n", 119 | " while find != -1 and i != n:\n", 120 | " find = s.find(sub, find + 1)\n", 121 | " i += 1\n", 122 | " if i == n:\n", 123 | " return s[:find] + repl + s[find+len(sub):]\n", 124 | " return s\n", 125 | "\n", 126 | "from_errors = []\n", 127 | "from_correct = []\n", 128 | "\n", 129 | "\n", 130 | "def replace(arr,dct):\n", 131 | " res = set()\n", 132 | " for u in arr:\n", 133 | " for k,values in dct.items():\n", 134 | " for v in values:\n", 135 | " n = u.count(k)\n", 136 | " for i in range(1,n+1):\n", 137 | " elem = nth_repl(u,k,v,i)\n", 138 | " if elem not in res:\n", 139 | " res.add(elem)\n", 140 | " return res\n", 141 | "\n", 142 | "for i in range(2):\n", 143 | " if i == 0:\n", 144 | " res_from_errors_1 = replace([with_errors],pairs)\n", 145 | " if target in res_from_errors_1:\n", 146 | " res = 1\n", 147 | " break\n", 148 | " res_from_correct = replace([target],inverse_pairs)\n", 149 | " if res_from_errors_1&res_from_correct:\n", 150 | " res = 2\n", 151 | " break\n", 152 | " else:\n", 153 | " res_from_errors_1 = replace(res_from_errors_1,pairs)\n", 154 | " if res_from_errors_1&res_from_correct:\n", 155 | " res = 3\n", 156 | " break\n", 157 | " res_from_correct = replace(res_from_correct,inverse_pairs)\n", 158 | " if res_from_errors_1&res_from_correct:\n", 159 | " res = 4\n", 160 | " break\n", 161 | " else:\n", 162 | " res = -1\n", 163 | " break\n", 164 | "print(res)" 165 | ], 166 | "metadata": { 167 | "collapsed": false 168 | } 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "source": [ 173 | "Решение от [Кобелева Льва](https://github.com/evlko), которое также использует BFS подход, но проходит ограничения." 174 | ], 175 | "metadata": { 176 | "collapsed": false 177 | } 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "outputs": [], 183 | "source": [ 184 | "import sys\n", 185 | "from collections import deque\n", 186 | "\n", 187 | "def find_minimum_substitutions(word_a, word_b, substitutions):\n", 188 | " q = deque([(word_a, 0)])\n", 189 | " visited = set([word_a])\n", 190 | "\n", 191 | " while q:\n", 192 | " word_c, substitutions_count = q.popleft()\n", 193 | "\n", 194 | " for sub in substitutions:\n", 195 | " if sub in word_c:\n", 196 | " subs = substitutions[sub]\n", 197 | " for c_sub in subs:\n", 198 | " word_t = word_c.replace(sub, c_sub, 1)\n", 199 | " if word_t == word_b:\n", 200 | " return substitutions_count + 1\n", 201 | " elif word_t not in visited and substitutions_count + 1 < 4:\n", 202 | " visited.add(word_t)\n", 203 | " q.append((word_t, substitutions_count + 1))\n", 204 | "\n", 205 | " return -1\n", 206 | "\n", 207 | "def main():\n", 208 | " word_a = str(input())\n", 209 | " word_b = str(input())\n", 210 | " substitutions = {}\n", 211 | " substitutions_num = int(input())\n", 212 | " result = float('inf')\n", 213 | "\n", 214 | " for s in range(substitutions_num):\n", 215 | " k, v = map(str, input().split(' '))\n", 216 | " if k != v:\n", 217 | " if k in substitutions:\n", 218 | " substitutions[k].add(v)\n", 219 | " else:\n", 220 | " substitutions[k] = set([v])\n", 221 | "\n", 222 | " result = find_minimum_substitutions(word_a, word_b, substitutions)\n", 223 | " print(result)\n", 224 | "\n", 225 | "\n", 226 | "if __name__ == '__main__':\n", 227 | " main()" 228 | ], 229 | "metadata": { 230 | "collapsed": false 231 | } 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": null, 236 | "outputs": [], 237 | "source": [], 238 | "metadata": { 239 | "collapsed": false 240 | } 241 | } 242 | ], 243 | "metadata": { 244 | "kernelspec": { 245 | "display_name": "Python 3", 246 | "language": "python", 247 | "name": "python3" 248 | }, 249 | "language_info": { 250 | "codemirror_mode": { 251 | "name": "ipython", 252 | "version": 2 253 | }, 254 | "file_extension": ".py", 255 | "mimetype": "text/x-python", 256 | "name": "python", 257 | "nbconvert_exporter": "python", 258 | "pygments_lexer": "ipython2", 259 | "version": "2.7.6" 260 | } 261 | }, 262 | "nbformat": 4, 263 | "nbformat_minor": 0 264 | } 265 | -------------------------------------------------------------------------------- /161.ГенераторТочекВКруге/ГенераторТочекВКруге.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче можно и нужно сгенерировать выборки для двух генераторов, визуализировать и увидеть, что они различаются лишь своим разбросом относительно центра круга. Таким образом, получается, что мы можем классифицировать генераторы на основе дисперсий выборок, которые они создают. В моем решении я выбрал порог в 0.45." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "\n", 22 | "data = []\n", 23 | "with open('input.txt','r') as f:\n", 24 | " for line in f:\n", 25 | " data.append([float(x) for x in line.split()])\n", 26 | "\n", 27 | "res = []\n", 28 | "temp = np.zeros(shape=(1000,2))\n", 29 | "\n", 30 | "for i in range(100):\n", 31 | " temp[:,0] = data[i][0::2]\n", 32 | " temp[:,1] = data[i][1::2]\n", 33 | " if temp.std()>0.45:\n", 34 | " res.append(2)\n", 35 | " else:\n", 36 | " res.append(1)\n", 37 | "\n", 38 | "with open(\"output.txt\", \"w+\") as file:\n", 39 | " file.write('\\n'.join([str(i) for i in res]))" 40 | ] 41 | } 42 | ], 43 | "metadata": { 44 | "kernelspec": { 45 | "display_name": "Python 3", 46 | "language": "python", 47 | "name": "python3" 48 | }, 49 | "language_info": { 50 | "codemirror_mode": { 51 | "name": "ipython", 52 | "version": 2 53 | }, 54 | "file_extension": ".py", 55 | "mimetype": "text/x-python", 56 | "name": "python", 57 | "nbconvert_exporter": "python", 58 | "pygments_lexer": "ipython2", 59 | "version": "2.7.6" 60 | } 61 | }, 62 | "nbformat": 4, 63 | "nbformat_minor": 0 64 | } 65 | -------------------------------------------------------------------------------- /163.СуммаНаГранях/СуммаНаГранях.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче после наивного подсчета математического ожидания нам необходимо вычесть случаи, которые неоправданно увеличивают нашу статистику, что и происходит в двух циклах, в которых считаются частоты символов и на основе этих частот, а также их значений уменьшается математическое ожидание в соответствии с условием задачи." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "from collections import Counter\n", 22 | "\n", 23 | "data = []\n", 24 | "with open('input.txt', 'r') as f:\n", 25 | " for i in f.readline().split():\n", 26 | " data.append(float(i))\n", 27 | " k = int(f.readline())\n", 28 | "\n", 29 | "cnt = Counter(data)\n", 30 | "Mx = np.mean(data)*k\n", 31 | "Mx_a = 0\n", 32 | "\n", 33 | "for key,v in cnt.items():\n", 34 | " cnt[key] = v/len(data)\n", 35 | "\n", 36 | "for key,v in cnt.items():\n", 37 | " Mx_a += (k-1)*key*cnt[key]**2\n", 38 | "\n", 39 | "Mx -= Mx_a\n", 40 | "\n", 41 | "with open(\"output.txt\", \"w\") as file:\n", 42 | " file.write(str(Mx))" 43 | ] 44 | } 45 | ], 46 | "metadata": { 47 | "kernelspec": { 48 | "display_name": "Python 3", 49 | "language": "python", 50 | "name": "python3" 51 | }, 52 | "language_info": { 53 | "codemirror_mode": { 54 | "name": "ipython", 55 | "version": 2 56 | }, 57 | "file_extension": ".py", 58 | "mimetype": "text/x-python", 59 | "name": "python", 60 | "nbconvert_exporter": "python", 61 | "pygments_lexer": "ipython2", 62 | "version": "2.7.6" 63 | } 64 | }, 65 | "nbformat": 4, 66 | "nbformat_minor": 0 67 | } 68 | -------------------------------------------------------------------------------- /171.КоллекцияСтатуэток/input.txt: -------------------------------------------------------------------------------- 1 | 10 2 2 | 1 9 2 4 3 1 8 2 10 9 -------------------------------------------------------------------------------- /171.КоллекцияСтатуэток/КоллекцияСтатуэток.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче используется метод скользящего окна, в котором мы стремимся поддерживать необходимое количество статуэток (минимум по 1 каждого типа), а также при наличии всех элементов в наборе стремимся минимизировать сумму элементов, удаляя лишние элементы слева. Окно представлено в виде очереди, количество необходимых элементов в окне хранится в словаре, текущая сумма и минимально возможная представлены соответствующими переменными." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "outputs": [], 16 | "source": [ 17 | "from collections import deque\n", 18 | "import math\n", 19 | "with open('input.txt','r') as f:\n", 20 | " n,k = map(int,f.readline().split())\n", 21 | " arr = list(map(int,f.readline().split()))\n", 22 | "\n", 23 | "needed_set = set([i for i in range(1,k+1)])\n", 24 | "cur_sum = 0\n", 25 | "min_sum = math.inf\n", 26 | "deq = deque()\n", 27 | "dct = {}\n", 28 | "for i in arr:\n", 29 | " if len(dct) < k:\n", 30 | " cur_sum += i\n", 31 | " deq.append(i)\n", 32 | " if i in needed_set:\n", 33 | " dct[i] = dct.get(i,0) + 1\n", 34 | " if len(dct) == k:\n", 35 | " while True:\n", 36 | " cur = deq[0]\n", 37 | " if cur not in dct or dct[cur] > 1:\n", 38 | " deq.popleft()\n", 39 | " cur_sum -= cur\n", 40 | " if cur in dct:\n", 41 | " dct[cur] -= 1\n", 42 | " else:\n", 43 | " break\n", 44 | " else:\n", 45 | " if i in needed_set:\n", 46 | " cur_sum += i\n", 47 | " deq.append(i)\n", 48 | " dct[i] = dct.get(i,0) + 1\n", 49 | " while deq:\n", 50 | " cur = deq[0]\n", 51 | " if cur not in dct or dct[cur] > 1:\n", 52 | " deq.popleft()\n", 53 | " cur_sum -= cur\n", 54 | " if cur in dct:\n", 55 | " dct[cur] -= 1\n", 56 | " else:\n", 57 | " break\n", 58 | " else:\n", 59 | " cur_sum += i\n", 60 | " deq.append(i)\n", 61 | " if cur_sum < min_sum and len(dct) == k:\n", 62 | " min_sum = cur_sum\n", 63 | "\n", 64 | "print(min_sum)" 65 | ], 66 | "metadata": { 67 | "collapsed": false 68 | } 69 | } 70 | ], 71 | "metadata": { 72 | "kernelspec": { 73 | "display_name": "Python 3", 74 | "language": "python", 75 | "name": "python3" 76 | }, 77 | "language_info": { 78 | "codemirror_mode": { 79 | "name": "ipython", 80 | "version": 2 81 | }, 82 | "file_extension": ".py", 83 | "mimetype": "text/x-python", 84 | "name": "python", 85 | "nbconvert_exporter": "python", 86 | "pygments_lexer": "ipython2", 87 | "version": "2.7.6" 88 | } 89 | }, 90 | "nbformat": 4, 91 | "nbformat_minor": 0 92 | } 93 | -------------------------------------------------------------------------------- /177.ТайнаЕгипетскихПирамид/ТайнаЕгипетскихПирамид.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче нам необходимо подобрать коэффициенты так, чтобы функция давала как можно близкий результат к истинному значению. Вспомните обычную линейную регрессию, как на обучающих картинках с 1 входной переменной и одной выходной, и/или функцию f(x)=kx+b, здесь все тоже самое, только больше коэффицентов и функция выглядит сложнее. Чтобы решать подобные задачи можно пользоваться модулем scipy.optimize, в данном случае методом curve_fit, который использует нелинейный метод наименьших квадратов для того, чтобы подобрать коэффициенты функции для наших данных." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "from scipy.optimize import curve_fit\n", 21 | "import numpy as np\n", 22 | "\n", 23 | "with open('input.txt','r') as f:\n", 24 | " n = int(f.readline())\n", 25 | " x = []\n", 26 | " y = []\n", 27 | " for _ in range(n):\n", 28 | " a,b = map(float,f.readline().split())\n", 29 | " x.append(a)\n", 30 | " y.append(b)\n", 31 | "\n", 32 | "def f(x,a,b,c,d):\n", 33 | " res = a*np.tan(x)+(b*np.sin(x)+c*np.cos(x))**2 + d*np.sqrt(x)\n", 34 | " return res\n", 35 | "(a,b,c,d),_ = curve_fit(f,np.array(x),np.array(y))\n", 36 | "print(np.round(a,2),np.round(b,2),np.round(c,2),np.round(d,2))" 37 | ] 38 | } 39 | ], 40 | "metadata": { 41 | "kernelspec": { 42 | "display_name": "Python 3", 43 | "language": "python", 44 | "name": "python3" 45 | }, 46 | "language_info": { 47 | "codemirror_mode": { 48 | "name": "ipython", 49 | "version": 2 50 | }, 51 | "file_extension": ".py", 52 | "mimetype": "text/x-python", 53 | "name": "python", 54 | "nbconvert_exporter": "python", 55 | "pygments_lexer": "ipython2", 56 | "version": "2.7.6" 57 | } 58 | }, 59 | "nbformat": 4, 60 | "nbformat_minor": 0 61 | } 62 | -------------------------------------------------------------------------------- /178.РешающийПень/РешающийПень.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Недооцененная по сложности задача, решение которой хорошо описанно [тут](https://habr.com/ru/companies/yandex/articles/414997/). В итоге, я ориентировался на это же решение и подробнее не опишу. Возможно, кому-то будет понятнее мой код без использования классов (но вряд ли). Также ниже ещё один подход к задаче." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "outputs": [], 16 | "source": [ 17 | "import sys\n", 18 | "\n", 19 | "n = int(sys.stdin.readline())\n", 20 | "xy = []\n", 21 | "right_n = 0\n", 22 | "sum_right = 0\n", 23 | "right_sse = 0\n", 24 | "for _ in range(n):\n", 25 | " x,y = map(float,sys.stdin.readline().split())\n", 26 | " xy.append([x,y])\n", 27 | " sum_right += y\n", 28 | " right_n += 1\n", 29 | " b = sum_right/right_n\n", 30 | " right_diff = y - b\n", 31 | " right_sse += right_diff*(y-b)\n", 32 | "\n", 33 | "\n", 34 | "xy.sort()\n", 35 | "\n", 36 | "a = 0\n", 37 | "sum_left = 0\n", 38 | "left_n = 0\n", 39 | "left_sse = 0\n", 40 | "\n", 41 | "min_mse = right_sse\n", 42 | "\n", 43 | "min_c = xy[0][0]\n", 44 | "min_b = sum_right/right_n\n", 45 | "min_a = 0\n", 46 | "\n", 47 | "for i in range(len(xy)-1):\n", 48 | " cur_item = xy[i]\n", 49 | " next_item = xy[i+1]\n", 50 | " c = (cur_item[0]+next_item[0])/2\n", 51 | " sum_left += cur_item[1]\n", 52 | " sum_right -= cur_item[1]\n", 53 | " left_n += 1\n", 54 | " right_n -= 1\n", 55 | " left_diff = cur_item[1] - a\n", 56 | " right_diff = cur_item[1] - b\n", 57 | " a = sum_left/left_n\n", 58 | " b = sum_right/right_n\n", 59 | " left_sse += left_diff*(cur_item[1]-a)\n", 60 | " right_sse -= right_diff*(cur_item[1]-b)\n", 61 | " if cur_item[0] == next_item[0]:\n", 62 | " continue\n", 63 | "\n", 64 | " temp_mse = left_sse + right_sse\n", 65 | " if temp_mse= threshold:\n", 144 | " continue\n", 145 | "\n", 146 | " sum_left = sum_left_cs[i-1]\n", 147 | " rmse = (sum_left**2) / i + ((sum_total - sum_left)**2) / (n-i)\n", 148 | "\n", 149 | " if rmse > best_rmse:\n", 150 | " best_rmse, best_threshold = rmse, threshold\n", 151 | "\n", 152 | " if best_rmse != float('-inf'):\n", 153 | " left_class, right_class = np.mean(Y[X < best_threshold]), np.mean(Y[X >= best_threshold])\n", 154 | " else:\n", 155 | " best_threshold = X[0] - 0.5\n", 156 | " left_class, right_class = -np.mean(Y[X >= best_threshold]), np.mean(Y[X >= best_threshold])\n", 157 | " if left_class == right_class:\n", 158 | " best_threshold = min(X) - 0.5\n", 159 | " if right_class == 0:\n", 160 | " left_class = -1\n", 161 | " else:\n", 162 | " left_class *= -1\n", 163 | "\n", 164 | " if np.isnan(left_class):\n", 165 | " if right_class == 0:\n", 166 | " left_class = -1\n", 167 | " else:\n", 168 | " left_class = right_class * -1\n", 169 | " best_threshold -= 0.5\n", 170 | "\n", 171 | " print(left_class, right_class, best_threshold)\n", 172 | "\n", 173 | "if __name__ == '__main__':\n", 174 | " main()" 175 | ], 176 | "metadata": { 177 | "collapsed": false 178 | } 179 | } 180 | ], 181 | "metadata": { 182 | "kernelspec": { 183 | "display_name": "Python 3", 184 | "language": "python", 185 | "name": "python3" 186 | }, 187 | "language_info": { 188 | "codemirror_mode": { 189 | "name": "ipython", 190 | "version": 2 191 | }, 192 | "file_extension": ".py", 193 | "mimetype": "text/x-python", 194 | "name": "python", 195 | "nbconvert_exporter": "python", 196 | "pygments_lexer": "ipython2", 197 | "version": "2.7.6" 198 | } 199 | }, 200 | "nbformat": 4, 201 | "nbformat_minor": 0 202 | } 203 | -------------------------------------------------------------------------------- /184.ВосстановлениеКоэффициентов/ВосстановлениеКоэффицентов.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Данная задача похожа на задачу 177. ТайнаЕгипетскихПирамид. Отличие лишь в том, что здесь нам нужно подобрать коэффициенты для одного конкретного набора данных и отправить эти коэффициенты в систему. Собственно, это я и сделал, используя curve_fit. Как можно видеть по MSE коэффициенты подобраны достаточно хорошо." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import pandas as pd\n", 21 | "\n", 22 | "data = pd.read_csv('data.csv',header=None)\n", 23 | "data = data.sort_values(0)" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 5, 29 | "outputs": [], 30 | "source": [ 31 | "import numpy as np\n", 32 | "def f(x,a,b,c):\n", 33 | " return (a*np.sin(x) + b*np.log(x))**2+c*x**2" 34 | ], 35 | "metadata": { 36 | "collapsed": false 37 | } 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 14, 42 | "outputs": [], 43 | "source": [ 44 | "from scipy.optimize import curve_fit\n", 45 | "\n", 46 | "\n", 47 | "(a,b,c),_ = curve_fit(f,data[0],data[1])" 48 | ], 49 | "metadata": { 50 | "collapsed": false 51 | } 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 8, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/plain": "[]" 60 | }, 61 | "execution_count": 8, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | }, 65 | { 66 | "data": { 67 | "text/plain": "
", 68 | "image/png": "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\n" 69 | }, 70 | "metadata": {}, 71 | "output_type": "display_data" 72 | } 73 | ], 74 | "source": [ 75 | "import matplotlib.pyplot as plt\n", 76 | "\n", 77 | "plt.plot(data[0],data[1])" 78 | ], 79 | "metadata": { 80 | "collapsed": false 81 | } 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 16, 86 | "outputs": [ 87 | { 88 | "data": { 89 | "text/plain": "0.0007579519912499222" 90 | }, 91 | "execution_count": 16, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | "from sklearn.metrics import mean_squared_error\n", 98 | "\n", 99 | "mean_squared_error(data[1],f(data[0],a,b,c))" 100 | ], 101 | "metadata": { 102 | "collapsed": false 103 | } 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 17, 108 | "outputs": [ 109 | { 110 | "data": { 111 | "text/plain": "(3.1415517673082314, 2.718403822771998, 3.999961533285704)" 112 | }, 113 | "execution_count": 17, 114 | "metadata": {}, 115 | "output_type": "execute_result" 116 | } 117 | ], 118 | "source": [ 119 | "a,b,c" 120 | ], 121 | "metadata": { 122 | "collapsed": false 123 | } 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "outputs": [], 129 | "source": [], 130 | "metadata": { 131 | "collapsed": false 132 | } 133 | } 134 | ], 135 | "metadata": { 136 | "kernelspec": { 137 | "display_name": "Python 3", 138 | "language": "python", 139 | "name": "python3" 140 | }, 141 | "language_info": { 142 | "codemirror_mode": { 143 | "name": "ipython", 144 | "version": 2 145 | }, 146 | "file_extension": ".py", 147 | "mimetype": "text/x-python", 148 | "name": "python", 149 | "nbconvert_exporter": "python", 150 | "pygments_lexer": "ipython2", 151 | "version": "2.7.6" 152 | } 153 | }, 154 | "nbformat": 4, 155 | "nbformat_minor": 0 156 | } 157 | -------------------------------------------------------------------------------- /200.Разминка/output.csv: -------------------------------------------------------------------------------- 1 | 0.2582278200000003 2 | 0.24118709000000027 3 | 0.2966510200000001 4 | 0.9545774099999995 5 | 0.02334326000000036 6 | 0.36751454000000044 7 | 0.19707804000000026 8 | 0.7775291300000002 9 | 0.9068613399999994 10 | 0.8835934400000005 11 | 0.05308194000000033 12 | 0.9794770999999995 13 | 0.9556584000000001 14 | 0.19200866000000022 15 | 0.5547952500000002 16 | 0.9173990300000001 17 | 0.32006895000000013 18 | 0.8811622499999998 19 | 0.9093828199999996 20 | 0.6671593900000001 21 | 0.2923097500000003 22 | 0.1894403000000003 23 | 0.05936055000000038 24 | 0.8375691699999999 25 | 0.00705595000000038 26 | 0.6475046800000002 27 | 0.5185568300000003 28 | 0.027729970000000364 29 | 0.7937033899999997 30 | 0.9309878599999994 31 | 0.7371860099999998 32 | 0.42713717999999995 33 | 0.7557301099999996 34 | 0.1752398300000003 35 | 0.5954301000000002 36 | 0.23293957000000032 37 | 0.14870587000000013 38 | 0.2360112500000003 39 | 0.6277505300000001 40 | 0.03232687000000039 41 | 0.3891932300000004 42 | 0.4775706100000003 43 | 0.8127945099999996 44 | 0.5880341900000001 45 | 0.4696986900000001 46 | 0.9921059100000003 47 | 0.18528047000000034 48 | 0.5714260200000001 49 | 0.9680336799999998 50 | 0.20562342000000025 51 | 0.3648187300000001 52 | 0.18083921000000042 53 | 0.9970989099999996 54 | 0.69368137 55 | 0.71839136 56 | 0.4707757100000003 57 | 0.7720541599999997 58 | 0.42473482 59 | 0.7020574699999993 60 | 0.8528915799999999 61 | 0.14177051000000032 62 | 0.84029226 63 | 0.92966331 64 | 0.5872017999999999 65 | 0.8567423699999996 66 | 0.2851085100000001 67 | 0.8885657399999998 68 | 0.2781505000000003 69 | 0.31797955000000006 70 | 0.05942245000000037 71 | 0.8686534800000001 72 | 0.024763750000000362 73 | 0.40348741999999993 74 | 0.20373752000000034 75 | 0.5183679400000003 76 | 0.9155697599999999 77 | 0.6467112399999999 78 | 0.2015374600000004 79 | 0.8608198099999997 80 | 0.6885718000000005 81 | 0.7246294199999999 82 | 0.40296885999999993 83 | 0.49702379999999996 84 | 0.40252282 85 | 0.9598498499999992 86 | 0.23917527000000033 87 | 0.5111559400000001 88 | 0.5597592299999996 89 | 0.6697552300000005 90 | 0.5824428800000001 91 | 0.6626323899999997 92 | 0.2532614800000002 93 | 0.2526827600000003 94 | 0.30068069000000025 95 | 0.3903317799999999 96 | 0.8272453199999998 97 | 0.8245191199999995 98 | 0.1471460000000004 99 | 0.32184459000000015 100 | 0.11815692000000032 101 | 0.6551127399999999 102 | 0.5887732099999994 103 | 0.38013300999999994 104 | 0.6887096800000001 105 | 0.4722586700000002 106 | 0.004978020000000386 107 | 0.1987376400000002 108 | 0.7896387100000002 109 | 0.1354044100000004 110 | 0.5788428800000003 111 | 0.8651812200000004 112 | 0.35548584000000016 113 | 0.8744857999999998 114 | 0.014438090000000379 115 | 0.6069737500000003 116 | 0.48492216000000005 117 | 0.5332006000000002 118 | 0.15614877000000021 119 | 0.12800308000000038 120 | 0.7412915900000001 121 | 0.6685012800000003 122 | 0.9908681799999997 123 | 0.58906737 124 | 0.34908302000000047 125 | 0.22308006000000033 126 | 0.84802267 127 | 0.4060448200000003 128 | 0.3862272299999999 129 | 0.16773564000000016 130 | 0.14118602000000025 131 | 0.47590806000000047 132 | 0.5771605099999999 133 | 0.09794928000000036 134 | 0.2555094899999999 135 | 0.09965527000000036 136 | 0.34170139000000016 137 | 0.62390496 138 | 0.8036809800000004 139 | 0.39123604999999984 140 | 0.49964181000000024 141 | 0.22661662000000019 142 | 0.66642085 143 | 0.23497739000000034 144 | 0.27248467000000015 145 | 0.17280947000000021 146 | 0.24102548000000024 147 | 0.1259552200000003 148 | 0.4747790000000003 149 | 0.65625516 150 | 0.7812704499999996 151 | 0.14597808000000034 152 | 0.2088292900000003 153 | 0.8927036999999998 154 | 0.4747862499999999 155 | 0.6649532600000005 156 | 0.49652677999999995 157 | 0.3492591200000001 158 | 0.8230718099999996 159 | 0.42059124000000003 160 | 0.754001439999999 161 | 0.40070504 162 | 0.8121679099999997 163 | 0.99525409 164 | 0.59299426 165 | 0.33306324000000026 166 | 0.6113156000000002 167 | 0.4059538100000001 168 | 0.1338694000000004 169 | 0.86371226 170 | 0.8823039399999999 171 | 0.29234458000000024 172 | 0.5868152 173 | 0.2212889100000003 174 | 0.9876461699999999 175 | 0.7422526399999996 176 | 0.3743777800000001 177 | 0.6942895499999997 178 | 0.5682017499999998 179 | 0.1884051700000001 180 | 0.10048354000000033 181 | 0.07451487000000033 182 | 0.07795955000000035 183 | 0.1845665700000004 184 | 0.30711050000000034 185 | 0.5804992500000004 186 | 0.9207205799999998 187 | 0.3227155700000002 188 | 0.7995498599999997 189 | 0.2211099900000002 190 | 0.8239738600000002 191 | 0.18654807000000018 192 | 0.19468438000000024 193 | 0.9548759200000001 194 | 0.49824012000000045 195 | 0.7099209599999996 196 | 0.6553256799999998 197 | 0.1971238100000003 198 | 0.8488204899999994 199 | 0.8763818999999999 200 | 0.3768000199999999 201 | 0.5782376400000007 202 | 0.09118738000000036 203 | 0.8864234500000003 204 | 0.5198256899999998 205 | 0.8649760899999999 206 | 0.31218642 207 | 0.04656165000000037 208 | 0.1629238900000003 209 | 0.15974500000000025 210 | 0.5683128600000005 211 | 0.7966149600000001 212 | 0.9472432800000006 213 | 0.9919075799999995 214 | 0.8867434799999996 215 | 0.19340995000000025 216 | 0.07328428000000034 217 | 0.33157542000000007 218 | 0.1152803700000004 219 | 0.6358603 220 | 0.6612961299999995 221 | 0.07746465000000032 222 | 0.7517688499999993 223 | 0.9675621600000004 224 | 0.3924147099999999 225 | 0.054824840000000354 226 | 0.3391020200000004 227 | 0.89889274 228 | 0.09662986000000034 229 | 0.9233471499999997 230 | 0.09156402000000029 231 | 0.922108559999999 232 | 0.8253373799999999 233 | 0.29441636000000004 234 | 0.02811883000000037 235 | 0.6274021700000003 236 | 0.2428714300000002 237 | 0.16433238000000022 238 | 0.43979250000000014 239 | 0.9768702499999997 240 | 0.7911115699999998 241 | 0.1249115900000004 242 | 0.08146671000000025 243 | 0.8458476699999993 244 | 0.6632574900000001 245 | 0.5403080700000003 246 | 0.44684526000000035 247 | 0.18001768000000043 248 | 0.7141022099999998 249 | 0.10093047000000029 250 | 0.08534957000000035 251 | 0.48870830999999976 252 | 0.5673520999999995 253 | 0.6931777400000003 254 | 0.6102211400000002 255 | 0.07050470000000034 256 | 0.4266205200000004 257 | 0.8103338200000003 258 | 0.9255724399999994 259 | 0.7228512999999996 260 | 0.4879473300000003 261 | 0.4970029399999999 262 | 0.8204159099999997 263 | 0.7962866700000004 264 | 0.006226140000000383 265 | 0.5560794899999999 266 | 0.7775271499999996 267 | 0.8343835499999996 268 | 0.12831530000000022 269 | 0.6809648399999999 270 | 0.57713821 271 | 0.16534738000000032 272 | 0.5082398399999999 273 | 0.5194635400000003 274 | 0.77950996 275 | 0.14743431000000026 276 | 0.19380547000000034 277 | 0.9788192899999995 278 | 0.30611571000000015 279 | 0.8083630800000001 280 | 0.2640978100000002 281 | 0.48750225000000014 282 | 0.8853188699999992 283 | 0.8746343799999996 284 | 0.0364126000000004 285 | 0.7958534799999999 286 | 0.22528494000000013 287 | 0.7714055199999992 288 | 0.040447540000000316 289 | 0.4484243200000001 290 | 0.4690644 291 | 0.1129690700000003 292 | 0.8395023299999995 293 | 0.14347427000000026 294 | 0.8661131799999997 295 | 0.25457489000000016 296 | 0.17166218000000014 297 | 0.36009425000000034 298 | 0.4358573399999999 299 | 0.4394553500000001 300 | 0.46177779000000035 301 | 0.44078225000000026 302 | 0.4222571300000001 303 | 0.7013373 304 | 0.4185684000000002 305 | 0.96236728 306 | 0.8491050099999993 307 | 0.24249241000000024 308 | 0.1611260300000003 309 | 0.4265438300000001 310 | 0.9157455599999997 311 | 0.44990077 312 | 0.5830020500000002 313 | 0.6875242399999999 314 | 0.02665040000000038 315 | 0.11857097000000022 316 | 0.49918982 317 | 0.32648122000000035 318 | 0.8296404699999993 319 | 0.9217062300000001 320 | 0.8521887700000004 321 | 0.8586529700000001 322 | 0.05930720000000038 323 | 0.8521576499999997 324 | 0.4257786200000003 325 | 0.23449917000000028 326 | 0.8614830499999997 327 | 0.4341591299999996 328 | 0.9109475599999999 329 | 0.6333137399999997 330 | 0.7079645599999997 331 | 0.014115500000000376 332 | 0.26927191999999983 333 | 0.10971666000000034 334 | 0.23437613000000024 335 | 0.6525687800000004 336 | 0.6269050399999998 337 | 0.2883568300000003 338 | 0.44569378000000043 339 | 0.6004080900000004 340 | 0.6456071700000006 341 | 0.5070878400000001 342 | 0.9445066199999994 343 | 0.41290526000000044 344 | 0.6419498200000002 345 | 0.3291451400000002 346 | 0.7920589099999997 347 | 0.7657162200000001 348 | 0.2516361200000002 349 | 0.82685765 350 | 0.07571730000000035 351 | 0.58025408 352 | 0.58480618 353 | 0.7397540899999999 354 | 0.35749578000000004 355 | 0.22736310000000048 356 | 0.7377660299999995 357 | 0.9543400900000001 358 | 0.7686372400000001 359 | 0.5471673099999996 360 | 0.32562264999999996 361 | 0.2510993000000003 362 | 0.38033040000000023 363 | 0.90721685 364 | 0.5329368299999999 365 | 0.4389274800000004 366 | 0.7782704399999991 367 | 0.08058224000000028 368 | 0.6444774900000003 369 | 0.8987450799999996 370 | 0.7136538999999997 371 | 0.046562380000000354 372 | 0.2195072000000001 373 | 0.8975217799999997 374 | 0.87065354 375 | 0.5044306900000002 376 | 0.016030680000000387 377 | 0.94637398 378 | 0.7340840499999997 379 | 0.13202302000000027 380 | 0.19296865000000027 381 | 0.06409771000000034 382 | 0.5298547000000002 383 | 0.0785668800000003 384 | 0.17563513000000022 385 | 0.06371073000000031 386 | 0.4845921699999998 387 | 0.44817064 388 | 0.2879472500000002 389 | 0.2339144600000002 390 | 0.56714478 391 | 0.23535836000000038 392 | 0.02153924000000038 393 | 0.6395286700000002 394 | 0.81437665 395 | 0.4482582600000001 396 | 0.3943375100000001 397 | 0.58849036 398 | 0.7752301599999996 399 | 0.009533870000000376 400 | 0.4862481600000005 401 | 0.7410094899999999 402 | 0.9515622699999993 403 | 0.51516392 404 | 0.012532880000000387 405 | 0.5300303400000004 406 | 0.7442515599999997 407 | 0.06142693000000038 408 | 0.7770951999999998 409 | 0.1374543200000003 410 | 0.5384909100000002 411 | 0.06334966000000035 412 | 0.08688610000000031 413 | 0.17277355000000028 414 | 0.7865781699999999 415 | 0.74400639 416 | 0.05888313000000037 417 | 0.13941254000000033 418 | 0.8169992099999999 419 | 0.51801378 420 | 0.4180203200000001 421 | 0.5376827700000002 422 | 0.12166673000000025 423 | 0.6294489800000003 424 | 0.5178389299999999 425 | 0.9639300099999994 426 | 0.27769273000000055 427 | 0.7719004200000004 428 | 0.5036433599999999 429 | 0.27217846000000023 430 | 0.8645698699999991 431 | 0.34533627000000033 432 | 0.12154835000000032 433 | 0.25569402000000024 434 | 0.7489492299999998 435 | 0.7164593199999996 436 | 0.69981925 437 | 0.030436820000000368 438 | 0.1721811600000003 439 | 0.10681627000000025 440 | 0.3844040300000001 441 | 0.1046506700000003 442 | 0.24151618000000033 443 | 0.23955954000000024 444 | 0.43178142000000014 445 | 0.36464848000000033 446 | 0.31240926000000013 447 | 0.6573008100000002 448 | 0.86812724 449 | 0.6606141199999997 450 | 0.7533755299999998 451 | 0.6429191300000003 452 | 0.2521213700000003 453 | 0.5521242300000002 454 | 0.4359153800000001 455 | 0.43565238999999994 456 | 0.7208951799999996 457 | 0.5842602799999999 458 | 0.9475546600000004 459 | 0.9683993099999999 460 | 0.09764578000000036 461 | 0.5348542000000003 462 | 0.2570408900000002 463 | 0.43959967000000005 464 | 0.6796063499999996 465 | 0.08101658000000031 466 | 0.39651958000000026 467 | 0.91914086 468 | 0.4362332799999999 469 | 0.13831425000000033 470 | 0.14806927000000034 471 | 0.45569734999999995 472 | 0.1260474100000003 473 | 0.05015749000000038 474 | 0.011556580000000378 475 | 0.003793560000000386 476 | 0.1321287900000003 477 | 0.9210580099999999 478 | 0.6832958699999996 479 | 0.26091206000000017 480 | 0.09512470000000035 481 | 0.16884190000000027 482 | 0.4945418300000001 483 | 0.7420742599999994 484 | 0.41071607000000004 485 | 0.04619830000000035 486 | 0.5667150400000005 487 | 0.34264862000000007 488 | 0.046554580000000345 489 | 0.1515774100000003 490 | 0.47792297999999994 491 | 0.09650417000000032 492 | 0.8186868900000006 493 | 0.7876791899999998 494 | 0.6910624899999998 495 | 0.048791020000000365 496 | 0.019945970000000375 497 | 0.47656323999999994 498 | 0.25922461 499 | 0.2880204100000004 500 | 0.4901136200000002 501 | 0.8213629899999999 502 | 0.44364771000000036 503 | 0.8337912200000004 504 | 0.8406284699999989 505 | 0.9289756599999996 506 | 0.5669218799999998 507 | 0.06377927000000036 508 | 0.5789721899999996 509 | 0.88195617 510 | 0.009518870000000377 511 | 0.47470694000000024 512 | 0.9365472299999997 513 | 0.4549315900000002 514 | 0.6183414200000001 515 | 0.7857715999999995 516 | 0.7098037800000003 517 | 0.27442883000000035 518 | 0.2554173000000001 519 | 0.5824833900000004 520 | 0.29496856000000027 521 | 0.13351330000000028 522 | 0.7837103599999999 523 | 0.4507383100000001 524 | 0.7044398299999999 525 | 0.5944313500000002 526 | 0.18819345000000046 527 | 0.8386354200000001 528 | 0.10869418000000035 529 | 0.7418791899999999 530 | 0.7833151800000002 531 | 0.4311068600000004 532 | 0.8133986399999997 533 | 0.40531214000000026 534 | 0.9575842099999998 535 | 0.46101495000000015 536 | 0.5823454400000001 537 | 0.78991714 538 | 0.42369012 539 | 0.28091857000000026 540 | 0.3051317100000003 541 | 0.1532242000000003 542 | 0.94574731 543 | 0.82547792 544 | 0.9179555199999998 545 | 0.5361673700000005 546 | 0.9879233699999994 547 | 0.1791459700000001 548 | 0.41651151000000003 549 | 0.59519751 550 | 0.9277061099999999 551 | 0.24521573000000016 552 | 0.028597930000000386 553 | 0.07423392000000031 554 | 0.6146598699999994 555 | 0.22081151000000018 556 | 0.79635441 557 | 0.7528894999999995 558 | 0.19952826000000037 559 | 0.7138644399999998 560 | 0.19032682000000026 561 | 0.9148643100000002 562 | 0.03796037000000038 563 | 0.8783849899999998 564 | 0.9552114799999998 565 | 0.8761229799999986 566 | 0.87277546 567 | 0.35383521 568 | 0.68264226 569 | 0.7253211599999998 570 | 0.9821248199999992 571 | 0.8328778000000001 572 | 0.9338596500000007 573 | 0.14714944000000027 574 | 0.24844705000000036 575 | 0.7734698400000002 576 | 0.2738056800000002 577 | 0.2637685300000003 578 | 0.7794274800000005 579 | 0.2964122800000001 580 | 0.20867181000000018 581 | 0.32884174000000005 582 | 0.2417349400000002 583 | 0.26267497000000023 584 | 0.06391755000000036 585 | 0.8981634600000001 586 | 0.6130498499999997 587 | 0.21076680000000028 588 | 0.15502741000000014 589 | 0.41656212000000037 590 | 0.8257274800000001 591 | 0.67750405 592 | 0.4215072600000005 593 | 0.7790756699999997 594 | 0.9327528100000002 595 | 0.17508690000000024 596 | 0.4611630300000001 597 | 0.09601908000000035 598 | 0.97295596 599 | 0.7795554999999992 600 | 0.9581425699999995 601 | 0.49158256 602 | 0.4598611699999999 603 | 0.54372262 604 | 0.38555320000000015 605 | 0.7301170699999997 606 | 0.5957165099999999 607 | 0.9459154799999996 608 | 0.4972181700000003 609 | 0.5726576400000001 610 | 0.3876561400000004 611 | 0.02366638000000038 612 | 0.07088055000000042 613 | 0.4511294399999997 614 | 0.6724161399999999 615 | 0.36744585000000024 616 | 0.19853792000000034 617 | 0.6672537700000003 618 | 0.8269392399999995 619 | 0.2848756100000001 620 | 0.9564570600000006 621 | 0.8903124799999997 622 | 0.2776599400000002 623 | 0.09120650000000029 624 | 0.18939801000000026 625 | 0.26775718000000026 626 | 0.38073998000000003 627 | 0.1412410800000003 628 | 0.10598886000000032 629 | 0.1803815500000003 630 | 0.06863203000000033 631 | 0.46890221999999987 632 | 0.7349829200000009 633 | 0.051986570000000315 634 | 0.7003074899999999 635 | 0.5485778000000003 636 | 0.2670225900000001 637 | 0.33144152000000016 638 | 0.9597051699999999 639 | 0.43403612999999996 640 | 0.56984305 641 | 0.11843756000000033 642 | 0.023566820000000373 643 | 0.9502448399999994 644 | 0.9372718700000002 645 | 0.7176935499999999 646 | 0.24557432000000004 647 | 0.2414660200000003 648 | 0.7379763500000003 649 | 0.08988986000000035 650 | 0.49822309000000004 651 | 0.9232835199999998 652 | 0.007515180000000382 653 | 0.8147964800000003 654 | 0.3914515400000002 655 | 0.9188612599999999 656 | 0.08922778000000026 657 | 0.8565816499999999 658 | 0.9541863299999997 659 | 0.5710833500000001 660 | 0.1365652000000004 661 | 0.12146868000000036 662 | 0.3586862799999998 663 | 0.8112453100000006 664 | 0.22689175000000036 665 | 0.8421056200000001 666 | 0.9539531899999998 667 | 0.3646003600000003 668 | 0.06287733000000034 669 | 0.47452646 670 | 0.28174767000000034 671 | 0.05514117000000033 672 | 0.9858674400000003 673 | 0.31630159000000047 674 | 0.4160439700000002 675 | 0.5783829600000001 676 | 0.8128980599999998 677 | 0.051436170000000364 678 | 0.32397256000000035 679 | 0.4026257300000002 680 | 0.6278185199999999 681 | 0.7398288700000002 682 | 0.7789061599999998 683 | 0.03498096000000039 684 | 0.04977870000000036 685 | 0.9803348600000006 686 | 0.63428281 687 | 0.35944951 688 | 0.7160232699999993 689 | 0.3634470000000002 690 | 0.88534235 691 | 0.04766235000000035 692 | 0.9497309600000001 693 | 0.45885246 694 | 0.23216889000000016 695 | 0.6898109100000003 696 | 0.2840330700000004 697 | 0.43748872000000005 698 | 0.7317931900000005 699 | 0.76696505 700 | 0.35439823000000004 701 | 0.5972789799999998 702 | 0.040634780000000356 703 | 0.23833544000000031 704 | 0.9316845 705 | 0.09936358000000037 706 | 0.2722462600000002 707 | 0.3481933400000002 708 | 0.6203031099999996 709 | 0.7791457199999996 710 | 0.2467478700000003 711 | 0.18135368000000018 712 | 0.46281690000000014 713 | 0.4374513300000001 714 | 0.6190844599999998 715 | 0.7851793599999999 716 | 0.29477169000000025 717 | 0.8151508399999998 718 | 0.5759483799999996 719 | 0.51360519 720 | 0.015064850000000381 721 | 0.11722539000000032 722 | 0.19815032000000019 723 | 0.5189426599999996 724 | 0.7246145300000004 725 | 0.14369867000000036 726 | 0.5337717699999998 727 | 0.8421320699999995 728 | 0.7022075799999998 729 | 0.48405049000000006 730 | 0.4165682600000002 731 | 0.7596575599999997 732 | 0.1813429700000004 733 | 0.6416411999999998 734 | 0.6523469899999998 735 | 0.2854786700000001 736 | 0.6500191799999997 737 | 0.11182185000000028 738 | 0.8883460499999998 739 | 0.07481610000000036 740 | 0.9322585700000003 741 | 0.33245026000000033 742 | 0.5764502300000001 743 | 0.33507225000000007 744 | 0.36075396000000015 745 | 0.20227202000000025 746 | 0.2520973400000002 747 | 0.13106345000000022 748 | 0.53138957 749 | 0.0885551000000003 750 | 0.05326242000000032 751 | 0.7792507600000003 752 | 0.6779788700000002 753 | 0.36674826000000005 754 | 0.92417222 755 | 0.6529280599999998 756 | 0.08907328000000034 757 | 0.57419449 758 | 0.7862301500000002 759 | 0.5434140500000002 760 | 0.6333178700000002 761 | 0.7221423699999996 762 | 0.4210269499999999 763 | 0.5046647899999999 764 | 0.6761100299999998 765 | 0.5912919299999995 766 | 0.8071496599999994 767 | 0.9559608800000001 768 | 0.5302764099999999 769 | 0.25200851000000013 770 | 0.6551151299999995 771 | 0.5565309899999997 772 | 0.8840167299999993 773 | 0.62015906 774 | 0.5192358400000006 775 | 0.20505476000000025 776 | 0.07712636000000035 777 | 0.6658118099999999 778 | 0.06355280000000038 779 | 0.9197417700000001 780 | 0.9775624499999997 781 | 0.8748923699999995 782 | 0.25827890000000014 783 | 0.8801783900000002 784 | 0.78201035 785 | 0.37106234 786 | 0.74229722 787 | 0.6913882900000001 788 | 0.27225734000000007 789 | 0.38316845000000005 790 | 0.9273675999999997 791 | 0.031240500000000355 792 | 0.8463735499999996 793 | 0.7734158099999999 794 | 0.5562558600000005 795 | 0.3656338700000001 796 | 0.46771671000000015 797 | 0.6586821099999995 798 | 0.0808396100000003 799 | 0.89014244 800 | 0.44515536000000006 801 | 0.5158671100000001 802 | 0.5727230700000001 803 | 0.5846906000000001 804 | 0.030054220000000367 805 | 0.4283703100000004 806 | 0.8908433599999999 807 | 0.1550490100000003 808 | 0.9381511199999997 809 | 0.2753184100000002 810 | 0.11080225000000038 811 | 0.4639421000000003 812 | 0.8576950899999993 813 | 0.9701606699999998 814 | 0.33115829000000035 815 | 0.03117955000000036 816 | 0.62833859 817 | 0.5422583999999999 818 | 0.7055974599999999 819 | 0.3935749200000004 820 | 0.32310645000000016 821 | 0.18548693000000038 822 | 0.41493990000000014 823 | 0.8301903000000002 824 | 0.23077047000000037 825 | 0.48625361000000017 826 | 0.8562723799999998 827 | 0.14106706000000027 828 | 0.25558331000000023 829 | 0.9876018199999996 830 | 0.4533762900000001 831 | 0.8032106699999995 832 | 0.2589010700000001 833 | 0.7393925399999999 834 | 0.3454331400000003 835 | 0.6889709799999997 836 | 0.5084526 837 | 0.00703375000000038 838 | 0.6195386800000002 839 | 0.3060821100000001 840 | 0.8409611800000003 841 | 0.7266322799999996 842 | 0.9728205499999991 843 | 0.1685203600000003 844 | 0.003988600000000387 845 | 0.5930057400000002 846 | 0.6883978600000003 847 | 0.9759108299999997 848 | 0.72553994 849 | 0.5369182700000001 850 | 0.09859475000000034 851 | 0.23170636000000025 852 | 0.19045600000000013 853 | 0.14114258000000032 854 | 0.6073889099999998 855 | 0.47577198000000015 856 | 0.20346161000000018 857 | 0.42960825000000036 858 | 0.3625445700000002 859 | 0.6547998399999999 860 | 0.008453700000000388 861 | 0.3066760500000001 862 | 0.8083057600000008 863 | 0.8318170099999995 864 | 0.8636088299999998 865 | 0.41056225999999973 866 | 0.9024182099999998 867 | 0.06975441000000034 868 | 0.7911163000000001 869 | 0.20531694000000014 870 | 0.35999702999999994 871 | 0.4831399700000002 872 | 0.03940008000000036 873 | 0.94854434 874 | 0.8779692799999994 875 | 0.6481469899999999 876 | 0.6869091999999999 877 | 0.92346057 878 | 0.3750356100000002 879 | 0.14953660000000035 880 | 0.22374038000000032 881 | 0.02484204000000038 882 | 0.6927068299999997 883 | 0.7473093999999998 884 | 0.6389609799999998 885 | 0.5036296900000008 886 | 0.060118270000000355 887 | 0.4011236800000002 888 | 0.16567908000000034 889 | 0.45570715000000034 890 | 0.6055042899999998 891 | 0.2536141500000003 892 | 0.5005372800000003 893 | 0.85288557 894 | 0.3861451900000004 895 | 0.2420686400000003 896 | 0.04437820000000037 897 | 0.8238260899999996 898 | 0.8162971799999998 899 | 0.43612751000000016 900 | 0.018103370000000372 901 | 0.12410169000000025 902 | 0.8689700600000001 903 | 0.10304389000000036 904 | 0.5069226799999997 905 | 0.03113127000000036 906 | 0.2585843100000003 907 | 0.3968403599999999 908 | 0.12432122000000019 909 | 0.4899759900000003 910 | 0.07287710000000036 911 | 0.4097765800000002 912 | 0.38116873999999984 913 | 0.9499371999999999 914 | 0.9768273899999997 915 | 0.9412118399999989 916 | 0.7036240499999997 917 | 0.5365351999999999 918 | 0.34064975000000014 919 | 0.9189743200000002 920 | 0.19647676000000014 921 | 0.17489361000000028 922 | 0.4494502700000001 923 | 0.32389241000000024 924 | 0.1280276700000002 925 | 0.6818494799999999 926 | 0.7103337299999994 927 | 0.7570007999999995 928 | 0.7638640600000004 929 | 0.4302394200000001 930 | 0.68588304 931 | 0.02384607000000037 932 | 0.3896708600000003 933 | 0.39718500000000023 934 | 0.3292891300000004 935 | 0.29059043000000023 936 | 0.09273677000000034 937 | 0.35813649999999997 938 | 0.36102646000000027 939 | 0.14540810000000015 940 | 0.8549591000000001 941 | 0.6278721499999995 942 | 0.37168371000000017 943 | 0.35858265 944 | 0.6912087600000005 945 | 0.8729160699999998 946 | 0.7114065999999999 947 | 0.2533737600000004 948 | 0.3578358499999999 949 | 0.31766086000000016 950 | 0.3807663100000001 951 | 0.4998148800000002 952 | 0.1424875800000003 953 | 0.1010933200000003 954 | 0.4900545300000002 955 | 0.027631720000000363 956 | 0.23295564000000019 957 | 0.2393126600000001 958 | 0.26253404000000036 959 | 0.1317086100000003 960 | 0.8881471999999999 961 | 0.7395044300000002 962 | 0.7425061399999993 963 | 0.05406044000000035 964 | 0.07372072000000034 965 | 0.18072408000000034 966 | 0.21136252000000025 967 | 0.6452988499999996 968 | 0.7676330399999993 969 | 0.89839066 970 | 0.6676552199999997 971 | 0.42005833000000015 972 | 0.5617552900000002 973 | 0.6185365099999998 974 | 0.1489011600000003 975 | 0.8011703000000006 976 | 0.7945218500000004 977 | 0.8418127199999994 978 | 0.6481012399999997 979 | 0.9294152500000004 980 | 0.71088773 981 | 0.42276151000000006 982 | 0.026414270000000354 983 | 0.53593852 984 | 0.5505815700000001 985 | 0.14772960000000016 986 | 0.75673046 987 | 0.9185908699999998 988 | 0.7036476699999996 989 | 0.39142877000000015 990 | 0.5985120199999998 991 | 0.6130672700000002 992 | 0.42606165000000024 993 | 0.24575067000000037 994 | 0.6991729999999996 995 | 0.9875575400000001 996 | 0.9568327100000003 997 | 0.47580052000000034 998 | 0.8511516100000001 999 | 0.2045517600000002 1000 | 0.42364493000000014 1001 | -------------------------------------------------------------------------------- /200.Разминка/Разминка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Честно говоря, не знаю почему у данной задачи сложность \"средняя\". Просто берем и обучаем линейную регрессию из библиотеки sklearn. Как можно видеть качество на отложенной выборке 2*10^-31^ , что значительно меньше 10^-8^. Не потребовалось ни EDA, да вообще ничего не потребовалось, поэтому не знаю какие комментарии ещё давать по этой задаче)" 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import pandas as pd" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 13, 26 | "outputs": [], 27 | "source": [ 28 | "data = pd.read_table('train.tsv',header=None,index_col=None)" 29 | ], 30 | "metadata": { 31 | "collapsed": false 32 | } 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 14, 37 | "outputs": [], 38 | "source": [ 39 | "X,y = data.drop(100,axis=1),data[100]" 40 | ], 41 | "metadata": { 42 | "collapsed": false 43 | } 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 19, 48 | "outputs": [], 49 | "source": [ 50 | "from sklearn.model_selection import train_test_split\n", 51 | "\n", 52 | "X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)" 53 | ], 54 | "metadata": { 55 | "collapsed": false 56 | } 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 20, 61 | "outputs": [], 62 | "source": [ 63 | "from sklearn.linear_model import LinearRegression" 64 | ], 65 | "metadata": { 66 | "collapsed": false 67 | } 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 24, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/plain": "LinearRegression()", 76 | "text/html": "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" 77 | }, 78 | "execution_count": 24, 79 | "metadata": {}, 80 | "output_type": "execute_result" 81 | } 82 | ], 83 | "source": [ 84 | "reg = LinearRegression()\n", 85 | "\n", 86 | "reg.fit(X_train,y_train)" 87 | ], 88 | "metadata": { 89 | "collapsed": false 90 | } 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 25, 95 | "outputs": [], 96 | "source": [ 97 | "pred = reg.predict(X_test)" 98 | ], 99 | "metadata": { 100 | "collapsed": false 101 | } 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 26, 106 | "outputs": [ 107 | { 108 | "data": { 109 | "text/plain": "1.7212929467370493e-31" 110 | }, 111 | "execution_count": 26, 112 | "metadata": {}, 113 | "output_type": "execute_result" 114 | } 115 | ], 116 | "source": [ 117 | "from sklearn.metrics import mean_squared_error\n", 118 | "\n", 119 | "mean_squared_error(y_test,pred)" 120 | ], 121 | "metadata": { 122 | "collapsed": false 123 | } 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 28, 128 | "outputs": [ 129 | { 130 | "data": { 131 | "text/plain": "LinearRegression()", 132 | "text/html": "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" 133 | }, 134 | "execution_count": 28, 135 | "metadata": {}, 136 | "output_type": "execute_result" 137 | } 138 | ], 139 | "source": [ 140 | "reg = LinearRegression()\n", 141 | "reg.fit(X,y)" 142 | ], 143 | "metadata": { 144 | "collapsed": false 145 | } 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 29, 150 | "outputs": [], 151 | "source": [ 152 | "test_data = pd.read_table('test.tsv',header=None,index_col=None)" 153 | ], 154 | "metadata": { 155 | "collapsed": false 156 | } 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 30, 161 | "outputs": [], 162 | "source": [ 163 | "pred = reg.predict(test_data)" 164 | ], 165 | "metadata": { 166 | "collapsed": false 167 | } 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 37, 172 | "outputs": [], 173 | "source": [ 174 | "pd.Series(pred).to_csv('output.csv',index=None,header=None)" 175 | ], 176 | "metadata": { 177 | "collapsed": false 178 | } 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 38, 183 | "outputs": [ 184 | { 185 | "data": { 186 | "text/plain": "array([0.25822782, 0.24118709, 0.29665102, 0.95457741, 0.02334326,\n 0.36751454, 0.19707804, 0.77752913, 0.90686134, 0.88359344,\n 0.05308194, 0.9794771 , 0.9556584 , 0.19200866, 0.55479525,\n 0.91739903, 0.32006895, 0.88116225, 0.90938282, 0.66715939,\n 0.29230975, 0.1894403 , 0.05936055, 0.83756917, 0.00705595,\n 0.64750468, 0.51855683, 0.02772997, 0.79370339, 0.93098786,\n 0.73718601, 0.42713718, 0.75573011, 0.17523983, 0.5954301 ,\n 0.23293957, 0.14870587, 0.23601125, 0.62775053, 0.03232687,\n 0.38919323, 0.47757061, 0.81279451, 0.58803419, 0.46969869,\n 0.99210591, 0.18528047, 0.57142602, 0.96803368, 0.20562342,\n 0.36481873, 0.18083921, 0.99709891, 0.69368137, 0.71839136,\n 0.47077571, 0.77205416, 0.42473482, 0.70205747, 0.85289158,\n 0.14177051, 0.84029226, 0.92966331, 0.5872018 , 0.85674237,\n 0.28510851, 0.88856574, 0.2781505 , 0.31797955, 0.05942245,\n 0.86865348, 0.02476375, 0.40348742, 0.20373752, 0.51836794,\n 0.91556976, 0.64671124, 0.20153746, 0.86081981, 0.6885718 ,\n 0.72462942, 0.40296886, 0.4970238 , 0.40252282, 0.95984985,\n 0.23917527, 0.51115594, 0.55975923, 0.66975523, 0.58244288,\n 0.66263239, 0.25326148, 0.25268276, 0.30068069, 0.39033178,\n 0.82724532, 0.82451912, 0.147146 , 0.32184459, 0.11815692,\n 0.65511274, 0.58877321, 0.38013301, 0.68870968, 0.47225867,\n 0.00497802, 0.19873764, 0.78963871, 0.13540441, 0.57884288,\n 0.86518122, 0.35548584, 0.8744858 , 0.01443809, 0.60697375,\n 0.48492216, 0.5332006 , 0.15614877, 0.12800308, 0.74129159,\n 0.66850128, 0.99086818, 0.58906737, 0.34908302, 0.22308006,\n 0.84802267, 0.40604482, 0.38622723, 0.16773564, 0.14118602,\n 0.47590806, 0.57716051, 0.09794928, 0.25550949, 0.09965527,\n 0.34170139, 0.62390496, 0.80368098, 0.39123605, 0.49964181,\n 0.22661662, 0.66642085, 0.23497739, 0.27248467, 0.17280947,\n 0.24102548, 0.12595522, 0.474779 , 0.65625516, 0.78127045,\n 0.14597808, 0.20882929, 0.8927037 , 0.47478625, 0.66495326,\n 0.49652678, 0.34925912, 0.82307181, 0.42059124, 0.75400144,\n 0.40070504, 0.81216791, 0.99525409, 0.59299426, 0.33306324,\n 0.6113156 , 0.40595381, 0.1338694 , 0.86371226, 0.88230394,\n 0.29234458, 0.5868152 , 0.22128891, 0.98764617, 0.74225264,\n 0.37437778, 0.69428955, 0.56820175, 0.18840517, 0.10048354,\n 0.07451487, 0.07795955, 0.18456657, 0.3071105 , 0.58049925,\n 0.92072058, 0.32271557, 0.79954986, 0.22110999, 0.82397386,\n 0.18654807, 0.19468438, 0.95487592, 0.49824012, 0.70992096,\n 0.65532568, 0.19712381, 0.84882049, 0.8763819 , 0.37680002,\n 0.57823764, 0.09118738, 0.88642345, 0.51982569, 0.86497609,\n 0.31218642, 0.04656165, 0.16292389, 0.159745 , 0.56831286,\n 0.79661496, 0.94724328, 0.99190758, 0.88674348, 0.19340995,\n 0.07328428, 0.33157542, 0.11528037, 0.6358603 , 0.66129613,\n 0.07746465, 0.75176885, 0.96756216, 0.39241471, 0.05482484,\n 0.33910202, 0.89889274, 0.09662986, 0.92334715, 0.09156402,\n 0.92210856, 0.82533738, 0.29441636, 0.02811883, 0.62740217,\n 0.24287143, 0.16433238, 0.4397925 , 0.97687025, 0.79111157,\n 0.12491159, 0.08146671, 0.84584767, 0.66325749, 0.54030807,\n 0.44684526, 0.18001768, 0.71410221, 0.10093047, 0.08534957,\n 0.48870831, 0.5673521 , 0.69317774, 0.61022114, 0.0705047 ,\n 0.42662052, 0.81033382, 0.92557244, 0.7228513 , 0.48794733,\n 0.49700294, 0.82041591, 0.79628667, 0.00622614, 0.55607949,\n 0.77752715, 0.83438355, 0.1283153 , 0.68096484, 0.57713821,\n 0.16534738, 0.50823984, 0.51946354, 0.77950996, 0.14743431,\n 0.19380547, 0.97881929, 0.30611571, 0.80836308, 0.26409781,\n 0.48750225, 0.88531887, 0.87463438, 0.0364126 , 0.79585348,\n 0.22528494, 0.77140552, 0.04044754, 0.44842432, 0.4690644 ,\n 0.11296907, 0.83950233, 0.14347427, 0.86611318, 0.25457489,\n 0.17166218, 0.36009425, 0.43585734, 0.43945535, 0.46177779,\n 0.44078225, 0.42225713, 0.7013373 , 0.4185684 , 0.96236728,\n 0.84910501, 0.24249241, 0.16112603, 0.42654383, 0.91574556,\n 0.44990077, 0.58300205, 0.68752424, 0.0266504 , 0.11857097,\n 0.49918982, 0.32648122, 0.82964047, 0.92170623, 0.85218877,\n 0.85865297, 0.0593072 , 0.85215765, 0.42577862, 0.23449917,\n 0.86148305, 0.43415913, 0.91094756, 0.63331374, 0.70796456,\n 0.0141155 , 0.26927192, 0.10971666, 0.23437613, 0.65256878,\n 0.62690504, 0.28835683, 0.44569378, 0.60040809, 0.64560717,\n 0.50708784, 0.94450662, 0.41290526, 0.64194982, 0.32914514,\n 0.79205891, 0.76571622, 0.25163612, 0.82685765, 0.0757173 ,\n 0.58025408, 0.58480618, 0.73975409, 0.35749578, 0.2273631 ,\n 0.73776603, 0.95434009, 0.76863724, 0.54716731, 0.32562265,\n 0.2510993 , 0.3803304 , 0.90721685, 0.53293683, 0.43892748,\n 0.77827044, 0.08058224, 0.64447749, 0.89874508, 0.7136539 ,\n 0.04656238, 0.2195072 , 0.89752178, 0.87065354, 0.50443069,\n 0.01603068, 0.94637398, 0.73408405, 0.13202302, 0.19296865,\n 0.06409771, 0.5298547 , 0.07856688, 0.17563513, 0.06371073,\n 0.48459217, 0.44817064, 0.28794725, 0.23391446, 0.56714478,\n 0.23535836, 0.02153924, 0.63952867, 0.81437665, 0.44825826,\n 0.39433751, 0.58849036, 0.77523016, 0.00953387, 0.48624816,\n 0.74100949, 0.95156227, 0.51516392, 0.01253288, 0.53003034,\n 0.74425156, 0.06142693, 0.7770952 , 0.13745432, 0.53849091,\n 0.06334966, 0.0868861 , 0.17277355, 0.78657817, 0.74400639,\n 0.05888313, 0.13941254, 0.81699921, 0.51801378, 0.41802032,\n 0.53768277, 0.12166673, 0.62944898, 0.51783893, 0.96393001,\n 0.27769273, 0.77190042, 0.50364336, 0.27217846, 0.86456987,\n 0.34533627, 0.12154835, 0.25569402, 0.74894923, 0.71645932,\n 0.69981925, 0.03043682, 0.17218116, 0.10681627, 0.38440403,\n 0.10465067, 0.24151618, 0.23955954, 0.43178142, 0.36464848,\n 0.31240926, 0.65730081, 0.86812724, 0.66061412, 0.75337553,\n 0.64291913, 0.25212137, 0.55212423, 0.43591538, 0.43565239,\n 0.72089518, 0.58426028, 0.94755466, 0.96839931, 0.09764578,\n 0.5348542 , 0.25704089, 0.43959967, 0.67960635, 0.08101658,\n 0.39651958, 0.91914086, 0.43623328, 0.13831425, 0.14806927,\n 0.45569735, 0.12604741, 0.05015749, 0.01155658, 0.00379356,\n 0.13212879, 0.92105801, 0.68329587, 0.26091206, 0.0951247 ,\n 0.1688419 , 0.49454183, 0.74207426, 0.41071607, 0.0461983 ,\n 0.56671504, 0.34264862, 0.04655458, 0.15157741, 0.47792298,\n 0.09650417, 0.81868689, 0.78767919, 0.69106249, 0.04879102,\n 0.01994597, 0.47656324, 0.25922461, 0.28802041, 0.49011362,\n 0.82136299, 0.44364771, 0.83379122, 0.84062847, 0.92897566,\n 0.56692188, 0.06377927, 0.57897219, 0.88195617, 0.00951887,\n 0.47470694, 0.93654723, 0.45493159, 0.61834142, 0.7857716 ,\n 0.70980378, 0.27442883, 0.2554173 , 0.58248339, 0.29496856,\n 0.1335133 , 0.78371036, 0.45073831, 0.70443983, 0.59443135,\n 0.18819345, 0.83863542, 0.10869418, 0.74187919, 0.78331518,\n 0.43110686, 0.81339864, 0.40531214, 0.95758421, 0.46101495,\n 0.58234544, 0.78991714, 0.42369012, 0.28091857, 0.30513171,\n 0.1532242 , 0.94574731, 0.82547792, 0.91795552, 0.53616737,\n 0.98792337, 0.17914597, 0.41651151, 0.59519751, 0.92770611,\n 0.24521573, 0.02859793, 0.07423392, 0.61465987, 0.22081151,\n 0.79635441, 0.7528895 , 0.19952826, 0.71386444, 0.19032682,\n 0.91486431, 0.03796037, 0.87838499, 0.95521148, 0.87612298,\n 0.87277546, 0.35383521, 0.68264226, 0.72532116, 0.98212482,\n 0.8328778 , 0.93385965, 0.14714944, 0.24844705, 0.77346984,\n 0.27380568, 0.26376853, 0.77942748, 0.29641228, 0.20867181,\n 0.32884174, 0.24173494, 0.26267497, 0.06391755, 0.89816346,\n 0.61304985, 0.2107668 , 0.15502741, 0.41656212, 0.82572748,\n 0.67750405, 0.42150726, 0.77907567, 0.93275281, 0.1750869 ,\n 0.46116303, 0.09601908, 0.97295596, 0.7795555 , 0.95814257,\n 0.49158256, 0.45986117, 0.54372262, 0.3855532 , 0.73011707,\n 0.59571651, 0.94591548, 0.49721817, 0.57265764, 0.38765614,\n 0.02366638, 0.07088055, 0.45112944, 0.67241614, 0.36744585,\n 0.19853792, 0.66725377, 0.82693924, 0.28487561, 0.95645706,\n 0.89031248, 0.27765994, 0.0912065 , 0.18939801, 0.26775718,\n 0.38073998, 0.14124108, 0.10598886, 0.18038155, 0.06863203,\n 0.46890222, 0.73498292, 0.05198657, 0.70030749, 0.5485778 ,\n 0.26702259, 0.33144152, 0.95970517, 0.43403613, 0.56984305,\n 0.11843756, 0.02356682, 0.95024484, 0.93727187, 0.71769355,\n 0.24557432, 0.24146602, 0.73797635, 0.08988986, 0.49822309,\n 0.92328352, 0.00751518, 0.81479648, 0.39145154, 0.91886126,\n 0.08922778, 0.85658165, 0.95418633, 0.57108335, 0.1365652 ,\n 0.12146868, 0.35868628, 0.81124531, 0.22689175, 0.84210562,\n 0.95395319, 0.36460036, 0.06287733, 0.47452646, 0.28174767,\n 0.05514117, 0.98586744, 0.31630159, 0.41604397, 0.57838296,\n 0.81289806, 0.05143617, 0.32397256, 0.40262573, 0.62781852,\n 0.73982887, 0.77890616, 0.03498096, 0.0497787 , 0.98033486,\n 0.63428281, 0.35944951, 0.71602327, 0.363447 , 0.88534235,\n 0.04766235, 0.94973096, 0.45885246, 0.23216889, 0.68981091,\n 0.28403307, 0.43748872, 0.73179319, 0.76696505, 0.35439823,\n 0.59727898, 0.04063478, 0.23833544, 0.9316845 , 0.09936358,\n 0.27224626, 0.34819334, 0.62030311, 0.77914572, 0.24674787,\n 0.18135368, 0.4628169 , 0.43745133, 0.61908446, 0.78517936,\n 0.29477169, 0.81515084, 0.57594838, 0.51360519, 0.01506485,\n 0.11722539, 0.19815032, 0.51894266, 0.72461453, 0.14369867,\n 0.53377177, 0.84213207, 0.70220758, 0.48405049, 0.41656826,\n 0.75965756, 0.18134297, 0.6416412 , 0.65234699, 0.28547867,\n 0.65001918, 0.11182185, 0.88834605, 0.0748161 , 0.93225857,\n 0.33245026, 0.57645023, 0.33507225, 0.36075396, 0.20227202,\n 0.25209734, 0.13106345, 0.53138957, 0.0885551 , 0.05326242,\n 0.77925076, 0.67797887, 0.36674826, 0.92417222, 0.65292806,\n 0.08907328, 0.57419449, 0.78623015, 0.54341405, 0.63331787,\n 0.72214237, 0.42102695, 0.50466479, 0.67611003, 0.59129193,\n 0.80714966, 0.95596088, 0.53027641, 0.25200851, 0.65511513,\n 0.55653099, 0.88401673, 0.62015906, 0.51923584, 0.20505476,\n 0.07712636, 0.66581181, 0.0635528 , 0.91974177, 0.97756245,\n 0.87489237, 0.2582789 , 0.88017839, 0.78201035, 0.37106234,\n 0.74229722, 0.69138829, 0.27225734, 0.38316845, 0.9273676 ,\n 0.0312405 , 0.84637355, 0.77341581, 0.55625586, 0.36563387,\n 0.46771671, 0.65868211, 0.08083961, 0.89014244, 0.44515536,\n 0.51586711, 0.57272307, 0.5846906 , 0.03005422, 0.42837031,\n 0.89084336, 0.15504901, 0.93815112, 0.27531841, 0.11080225,\n 0.4639421 , 0.85769509, 0.97016067, 0.33115829, 0.03117955,\n 0.62833859, 0.5422584 , 0.70559746, 0.39357492, 0.32310645,\n 0.18548693, 0.4149399 , 0.8301903 , 0.23077047, 0.48625361,\n 0.85627238, 0.14106706, 0.25558331, 0.98760182, 0.45337629,\n 0.80321067, 0.25890107, 0.73939254, 0.34543314, 0.68897098,\n 0.5084526 , 0.00703375, 0.61953868, 0.30608211, 0.84096118,\n 0.72663228, 0.97282055, 0.16852036, 0.0039886 , 0.59300574,\n 0.68839786, 0.97591083, 0.72553994, 0.53691827, 0.09859475,\n 0.23170636, 0.190456 , 0.14114258, 0.60738891, 0.47577198,\n 0.20346161, 0.42960825, 0.36254457, 0.65479984, 0.0084537 ,\n 0.30667605, 0.80830576, 0.83181701, 0.86360883, 0.41056226,\n 0.90241821, 0.06975441, 0.7911163 , 0.20531694, 0.35999703,\n 0.48313997, 0.03940008, 0.94854434, 0.87796928, 0.64814699,\n 0.6869092 , 0.92346057, 0.37503561, 0.1495366 , 0.22374038,\n 0.02484204, 0.69270683, 0.7473094 , 0.63896098, 0.50362969,\n 0.06011827, 0.40112368, 0.16567908, 0.45570715, 0.60550429,\n 0.25361415, 0.50053728, 0.85288557, 0.38614519, 0.24206864,\n 0.0443782 , 0.82382609, 0.81629718, 0.43612751, 0.01810337,\n 0.12410169, 0.86897006, 0.10304389, 0.50692268, 0.03113127,\n 0.25858431, 0.39684036, 0.12432122, 0.48997599, 0.0728771 ,\n 0.40977658, 0.38116874, 0.9499372 , 0.97682739, 0.94121184,\n 0.70362405, 0.5365352 , 0.34064975, 0.91897432, 0.19647676,\n 0.17489361, 0.44945027, 0.32389241, 0.12802767, 0.68184948,\n 0.71033373, 0.7570008 , 0.76386406, 0.43023942, 0.68588304,\n 0.02384607, 0.38967086, 0.397185 , 0.32928913, 0.29059043,\n 0.09273677, 0.3581365 , 0.36102646, 0.1454081 , 0.8549591 ,\n 0.62787215, 0.37168371, 0.35858265, 0.69120876, 0.87291607,\n 0.7114066 , 0.25337376, 0.35783585, 0.31766086, 0.38076631,\n 0.49981488, 0.14248758, 0.10109332, 0.49005453, 0.02763172,\n 0.23295564, 0.23931266, 0.26253404, 0.13170861, 0.8881472 ,\n 0.73950443, 0.74250614, 0.05406044, 0.07372072, 0.18072408,\n 0.21136252, 0.64529885, 0.76763304, 0.89839066, 0.66765522,\n 0.42005833, 0.56175529, 0.61853651, 0.14890116, 0.8011703 ,\n 0.79452185, 0.84181272, 0.64810124, 0.92941525, 0.71088773,\n 0.42276151, 0.02641427, 0.53593852, 0.55058157, 0.1477296 ,\n 0.75673046, 0.91859087, 0.70364767, 0.39142877, 0.59851202,\n 0.61306727, 0.42606165, 0.24575067, 0.699173 , 0.98755754,\n 0.95683271, 0.47580052, 0.85115161, 0.20455176, 0.42364493])" 187 | }, 188 | "execution_count": 38, 189 | "metadata": {}, 190 | "output_type": "execute_result" 191 | } 192 | ], 193 | "source": [ 194 | "pred" 195 | ], 196 | "metadata": { 197 | "collapsed": false 198 | } 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "outputs": [], 204 | "source": [], 205 | "metadata": { 206 | "collapsed": false 207 | } 208 | } 209 | ], 210 | "metadata": { 211 | "kernelspec": { 212 | "display_name": "Python 3", 213 | "language": "python", 214 | "name": "python3" 215 | }, 216 | "language_info": { 217 | "codemirror_mode": { 218 | "name": "ipython", 219 | "version": 2 220 | }, 221 | "file_extension": ".py", 222 | "mimetype": "text/x-python", 223 | "name": "python", 224 | "nbconvert_exporter": "python", 225 | "pygments_lexer": "ipython2", 226 | "version": "2.7.6" 227 | } 228 | }, 229 | "nbformat": 4, 230 | "nbformat_minor": 0 231 | } 232 | -------------------------------------------------------------------------------- /207.ОбобщенныйAUC/input.txt: -------------------------------------------------------------------------------- 1 | 7 2 | 0 0 3 | 0 1 4 | 1 2 5 | 0 3 6 | 1 4 7 | 1 5 8 | 1 6 -------------------------------------------------------------------------------- /207.ОбобщенныйAUC/output.txt: -------------------------------------------------------------------------------- 1 | 0.5384615384615384 -------------------------------------------------------------------------------- /207.ОбобщенныйAUC/ОбобщенныйAUC.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче у меня представлены два решения за O(N^2^), в которых квадрат достигается при определенных условиях. [Ссылка на решение для ML Blitz 2018](https://github.com/stas-sl/yandex-blitz-ml-2018), в котором он описал ход своих мыслей. Объясняя код, скажу, что мы итерируемся по элементам и удаляем те y, для которых t[i]=t[j], иными словами они лежат на одной прямой по t. Во втором же цикле мы считаем числитель и знаменатель, так как массив отсортирован, то мы можем использовать бинарный поиск, соответственно, все элементы, что лежат слева добавляют 1 (левый бинарный поиск), а все что лежат между левой и правой границей (между левым и правым бинарным поиском) добавляют по 0.5 в числитель.\n", 7 | "\n", 8 | "Объяснение разницы левого и правого бинарного поиска.\n", 9 | "Задан отсортированный массив [1,2,2,2,2,3,5,8,9,11], x=2\n", 10 | "Правосторонний поиск двойки выдаст в результате 4, в то время как левосторонний выдаст 1 (нумерация с нуля).\n", 11 | "\n", 12 | "Отсюда следует, что количество подряд идущих двоек равно длине отрезка [1;4], то есть 4." 13 | ], 14 | "metadata": { 15 | "collapsed": false 16 | } 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": null, 21 | "outputs": [], 22 | "source": [ 23 | "import bisect\n", 24 | "\n", 25 | "with open('input.txt','r') as f:\n", 26 | " n = int(f.readline())\n", 27 | " t, y = zip(*sorted(list(map(float, f.readline().split())) for i in range(n)))\n", 28 | "\n", 29 | "y_sorted = sorted(y)\n", 30 | "num = 0\n", 31 | "denom = 0\n", 32 | "i = n - 1\n", 33 | "\n", 34 | "while i >= 0:\n", 35 | " j = i\n", 36 | " while j >= 0 and t[i] == t[j]:\n", 37 | " l = bisect.bisect_left(y_sorted, y[j])\n", 38 | " y_sorted.pop(l)\n", 39 | " j -= 1\n", 40 | " for k in range(j + 1, i + 1):\n", 41 | " l = bisect.bisect_left(y_sorted, y[k])\n", 42 | " r = bisect.bisect(y_sorted, y[k])\n", 43 | " num += l + (r - l) / 2\n", 44 | " denom += j + 1\n", 45 | " i = j\n", 46 | "\n", 47 | "with open('output.txt','w') as f:\n", 48 | " f.write(str(num/denom))" 49 | ], 50 | "metadata": { 51 | "collapsed": false 52 | } 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "source": [ 57 | "Решение через Бинарное дерево. Его проблема в том, что оно не сбалансированное и в худшем случае сложность будет N^2^. Можно попробовать использовать дерево Фенвика, но до него у меня уже у руки не дошли, потому что в итоге было принято решение за N^2^." 58 | ], 59 | "metadata": { 60 | "collapsed": false 61 | } 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "outputs": [], 67 | "source": [ 68 | "class Node:\n", 69 | " def __init__(self, x):\n", 70 | " self.x = x\n", 71 | " self.left_count = 0\n", 72 | " self.right_count = 0\n", 73 | " self.n = 1\n", 74 | " self.left = None\n", 75 | " self.right = None\n", 76 | "\n", 77 | "\n", 78 | "class BinaryTree:\n", 79 | " def __init__(self):\n", 80 | " self.root = None\n", 81 | "\n", 82 | " def add(self, x):\n", 83 | " if self.root is None:\n", 84 | " self.root = Node(x)\n", 85 | " else:\n", 86 | " cur = self.root\n", 87 | " while True:\n", 88 | " if x == cur.x:\n", 89 | " cur.n += 1\n", 90 | " break\n", 91 | " elif x < cur.x:\n", 92 | " cur.left_count += 1\n", 93 | " if cur.left is None:\n", 94 | " cur.left = Node(x)\n", 95 | " break\n", 96 | " else:\n", 97 | " cur = cur.left\n", 98 | " else:\n", 99 | " cur.right_count += 1\n", 100 | " if cur.right is None:\n", 101 | " cur.right = Node(x)\n", 102 | " break\n", 103 | " else:\n", 104 | " cur = cur.right\n", 105 | "\n", 106 | " def count_less_and_eq(self, x):\n", 107 | " less = 0\n", 108 | " eq = 0\n", 109 | " cur = self.root\n", 110 | " while cur:\n", 111 | " if x == cur.x:\n", 112 | " less += cur.left_count\n", 113 | " eq = cur.n\n", 114 | " break\n", 115 | " elif x < cur.x:\n", 116 | " cur = cur.left\n", 117 | " else:\n", 118 | " less += cur.left_count + cur.n\n", 119 | " cur = cur.right\n", 120 | " return less, eq\n", 121 | "\n", 122 | "\n", 123 | "\n", 124 | "with open('input.txt', 'r') as file:\n", 125 | " n = int(file.readline())\n", 126 | " arr = []\n", 127 | " for _ in range(n):\n", 128 | " true_val, prev_val = map(float, file.readline().split())\n", 129 | " arr.append((true_val, prev_val))\n", 130 | "\n", 131 | "arr.sort(key=lambda x: x[0])\n", 132 | "\n", 133 | "tree = BinaryTree()\n", 134 | "num = 0\n", 135 | "denom = 0\n", 136 | "\n", 137 | "i = 0\n", 138 | "while i < n:\n", 139 | " j = i\n", 140 | " while j < n and arr[i][0] == arr[j][0]:\n", 141 | " r = tree.count_less_and_eq(arr[j][1])\n", 142 | " num += r[0] + r[1] / 2\n", 143 | " denom += i\n", 144 | " j += 1\n", 145 | "\n", 146 | " for k in range(i, j):\n", 147 | " tree.add(arr[k][1])\n", 148 | "\n", 149 | " i = j\n", 150 | "\n", 151 | "print(num / denom)" 152 | ], 153 | "metadata": { 154 | "collapsed": false 155 | } 156 | } 157 | ], 158 | "metadata": { 159 | "kernelspec": { 160 | "display_name": "Python 3", 161 | "language": "python", 162 | "name": "python3" 163 | }, 164 | "language_info": { 165 | "codemirror_mode": { 166 | "name": "ipython", 167 | "version": 2 168 | }, 169 | "file_extension": ".py", 170 | "mimetype": "text/x-python", 171 | "name": "python", 172 | "nbconvert_exporter": "python", 173 | "pygments_lexer": "ipython2", 174 | "version": "2.7.6" 175 | } 176 | }, 177 | "nbformat": 4, 178 | "nbformat_minor": 0 179 | } 180 | -------------------------------------------------------------------------------- /209.Перестановки/out.txt: -------------------------------------------------------------------------------- 1 | 66 2 | 106 3 | 119 4 | 91 5 | 199 6 | 184 7 | 164 8 | 186 9 | 74 10 | 31 11 | 137 12 | 14 13 | 172 14 | 81 15 | 114 16 | 157 17 | 162 18 | 150 19 | 170 20 | 32 21 | 88 22 | 53 23 | 48 24 | 167 25 | 113 26 | 70 27 | 42 28 | 174 29 | 104 30 | 145 31 | 71 32 | 6 33 | 176 34 | 60 35 | 120 36 | 190 37 | 115 38 | 82 39 | 41 40 | 173 41 | 126 42 | 64 43 | 43 44 | 110 45 | 193 46 | 183 47 | 67 48 | 50 49 | 192 50 | 62 51 | 5 52 | 149 53 | 131 54 | 55 55 | 117 56 | 51 57 | 134 58 | 17 59 | 144 60 | 92 61 | 125 62 | 33 63 | 57 64 | 111 65 | 132 66 | 34 67 | 140 68 | 29 69 | 47 70 | 19 71 | 118 72 | 44 73 | 168 74 | 141 75 | 2 76 | 15 77 | 39 78 | 68 79 | 147 80 | 0 81 | 10 82 | 179 83 | 79 84 | 18 85 | 189 86 | 26 87 | 152 88 | 90 89 | 37 90 | 136 91 | 3 92 | 63 93 | 96 94 | 185 95 | 4 96 | 197 97 | 158 98 | 139 99 | 161 100 | 121 101 | 105 102 | 151 103 | 28 104 | 128 105 | 73 106 | 187 107 | 75 108 | 153 109 | 1 110 | 138 111 | 129 112 | 16 113 | 52 114 | 146 115 | 122 116 | 36 117 | 22 118 | 94 119 | 24 120 | 195 121 | 191 122 | 181 123 | 58 124 | 23 125 | 99 126 | 100 127 | 86 128 | 97 129 | 59 130 | 194 131 | 25 132 | 148 133 | 166 134 | 95 135 | 9 136 | 13 137 | 178 138 | 76 139 | 11 140 | 108 141 | 89 142 | 69 143 | 87 144 | 78 145 | 21 146 | 175 147 | 7 148 | 72 149 | 101 150 | 35 151 | 8 152 | 93 153 | 109 154 | 65 155 | 61 156 | 133 157 | 98 158 | 77 159 | 127 160 | 27 161 | 135 162 | 12 163 | 165 164 | 156 165 | 85 166 | 84 167 | 107 168 | 83 169 | 80 170 | 56 171 | 30 172 | 142 173 | 103 174 | 112 175 | 169 176 | 45 177 | 177 178 | 49 179 | 38 180 | 198 181 | 46 182 | 143 183 | 196 184 | 124 185 | 130 186 | 40 187 | 20 188 | 54 189 | 182 190 | 116 191 | 180 192 | 159 193 | 188 194 | 102 195 | 154 196 | 155 197 | 123 198 | 163 199 | 171 200 | 160 201 | -------------------------------------------------------------------------------- /221.ЛинейноРазделимаяВыборка/input.txt: -------------------------------------------------------------------------------- 1 | 5 5 2 | 1.7826 4.68275 6.10123 7.32859 7.38209 1 3 | 4.27658 4.67522 4.81731 5.19996 3.11343 1 4 | 7.91009 0.640944 6.30974 6.36116 0.81165 1 5 | 1.05574 8.23438 6.05421 7.44865 1.25079 1 6 | 1.43015 6.27736 4.77795 5.68318 0.370549 1 -------------------------------------------------------------------------------- /221.ЛинейноРазделимаяВыборка/ЛинейноРазделимаяВыборка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче надо построить разделяющую плоскость, а какой алгоритм машинного обучения строит разделяющие плоскости? Правильно, SVM и его производные, в данном случае SVR, а точнее LinearSVR, потому что sklearn для него обещает больше возможностей и масштабирование на большое количество значений (вдруг в тестах будет что-то большое). Смещения у нас нет, поэтому fit_intercept=False, а количество итераций выбрано, чтобы не было TL.\n", 7 | "\n", 8 | "P.S. На момент сдачи в этой задаче нельзя было считывать из input.txt, поэтому ввод через sys.stdin" 9 | ], 10 | "metadata": { 11 | "collapsed": false 12 | } 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": null, 17 | "outputs": [], 18 | "source": [ 19 | "from sklearn.svm import LinearSVR\n", 20 | "import sys\n", 21 | "\n", 22 | "n,m = map(int,sys.stdin.readline().split())\n", 23 | "x = []\n", 24 | "y = []\n", 25 | "for _ in range(n):\n", 26 | " inp = list(map(float,sys.stdin.readline().split()))\n", 27 | " x.append(inp[:m])\n", 28 | " y.append([inp[-1]])\n", 29 | "\n", 30 | "cls = LinearSVR(fit_intercept=False,max_iter=500)\n", 31 | "cls.fit(x,y)\n", 32 | "print(*cls.coef_)" 33 | ], 34 | "metadata": { 35 | "collapsed": false 36 | } 37 | } 38 | ], 39 | "metadata": { 40 | "kernelspec": { 41 | "display_name": "Python 3", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 2 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython2", 55 | "version": "2.7.6" 56 | } 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 0 60 | } 61 | -------------------------------------------------------------------------------- /224.УникальныеЗапросы/УникальныеЗапросы.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче необходимо оценить мощность множества затратив на это небольшое количество памяти и времени (до 5с, до 5 мб). Я использовал алгоритм LinearCounting, поскольку он подходит для условий задачи, а именно, что мощность множества до 500 000. У HyperLogLog, например, на таких значениях получается большая ошибка, за допустимыми границами, и мои попытки решения с ним не увенчались успехом. Более подробно про HyperLogLog и LinearCounting можно почитать [тут](https://habr.com/ru/companies/vk/articles/711126/), свои идеи я черпал из этой же статьи." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import sys\n", 21 | "import hashlib\n", 22 | "import math\n", 23 | "\n", 24 | "n = int(sys.stdin.readline())\n", 25 | "m = 2 ** 14\n", 26 | "M = [0] * m\n", 27 | "\n", 28 | "\n", 29 | "for i in range(n):\n", 30 | " x = hashlib.sha256(str.encode(sys.stdin.readline().strip())).digest()[:4]\n", 31 | " idx = int.from_bytes(x, byteorder='little') % m\n", 32 | " M[idx] = 1\n", 33 | "\n", 34 | "\n", 35 | "print(m * math.log(m / M.count(0)))" 36 | ] 37 | } 38 | ], 39 | "metadata": { 40 | "kernelspec": { 41 | "display_name": "Python 3", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 2 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython2", 55 | "version": "2.7.6" 56 | } 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 0 60 | } 61 | -------------------------------------------------------------------------------- /233.РанжированиеПоПарам/РанжированиеПоПарам.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче я сошлюсь на органичное решение и описание решения для ML Blitz 2018, представленное [тут](https://github.com/stas-sl/yandex-blitz-ml-2018#m-pairwise-ranking)." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "\n", 22 | "with open('input.txt','r') as f:\n", 23 | " n,m = map(int,f.readline().split())\n", 24 | " data = []\n", 25 | " for i in range(m):\n", 26 | " a1,a2 = map(int,f.readline().split())\n", 27 | " data.append([a1,a2])\n", 28 | "\n", 29 | "data = np.array(data)\n", 30 | "w = np.ones(n)\n", 31 | "x = np.zeros((m, n))\n", 32 | "if m >= 1:\n", 33 | " x[np.arange(m), data[:, 0] - 1] = 1\n", 34 | " x[np.arange(m), data[:, 1] - 1] = -1\n", 35 | "v = np.zeros_like(w)\n", 36 | "for i in range(1000):\n", 37 | " z = w @ x.T\n", 38 | " h = 1 / (1 + np.exp(-z))\n", 39 | " gradient = x.T @ (h - 1) / m\n", 40 | " v = 0.99 * v + gradient\n", 41 | " w -= v\n", 42 | "\n", 43 | "print(*(w.argsort()[::-1] + 1),sep='\\n')" 44 | ] 45 | } 46 | ], 47 | "metadata": { 48 | "kernelspec": { 49 | "display_name": "Python 3", 50 | "language": "python", 51 | "name": "python3" 52 | }, 53 | "language_info": { 54 | "codemirror_mode": { 55 | "name": "ipython", 56 | "version": 2 57 | }, 58 | "file_extension": ".py", 59 | "mimetype": "text/x-python", 60 | "name": "python", 61 | "nbconvert_exporter": "python", 62 | "pygments_lexer": "ipython2", 63 | "version": "2.7.6" 64 | } 65 | }, 66 | "nbformat": 4, 67 | "nbformat_minor": 0 68 | } 69 | -------------------------------------------------------------------------------- /240.Монетки/Монетки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче необходимо оценить вероятность выпадения орла, но привычная нам формула $\\frac{k}{n}$ в данном случае не сработает.\n", 7 | "В данном случае нам необходимо использовать формулу $$\\frac{k+1}{n+2}$$, которая базируется на априорном предположении о двух дополнительных случаях: один, в котором выпадет орел, и другой, в котором выпадет решка. Это [правило последовательности Лапласа](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C).\n", 8 | "В итоге получаем, что данная формула лучше оценивает вероятности, когда надо сравнить две монетки. Например, в первом случае выпало 5 орлов из 10 бросков, во втором 500 из 1000, по первой формуле получаем, что вероятность и там, и там 0.5, однако, мы понимаем, что во втором случае реальная вероятность ближе к 0.5, чем в первом, и формула $\\frac{k+1}{n+2}$ это учитывает.\n", 9 | "Также можно почитать про проверку честности монетки [следующую ссылку](https://en.wikipedia.org/wiki/Checking_whether_a_coin_is_fair). Также решение через предположения о распределении, которое ведет к такому же ответу представлено [по этой ссылке](https://github.com/stas-sl/yandex-blitz-ml-2018#n-coins)." 10 | ], 11 | "metadata": { 12 | "collapsed": false 13 | } 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 17, 18 | "metadata": { 19 | "collapsed": true 20 | }, 21 | "outputs": [], 22 | "source": [ 23 | "import pandas as pd" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 20, 29 | "outputs": [], 30 | "source": [ 31 | "data = pd.read_csv('coins.in',sep=' ',header=None).rename({0:'n',1:'k'},axis=1)" 32 | ], 33 | "metadata": { 34 | "collapsed": false 35 | } 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 10, 40 | "outputs": [], 41 | "source": [ 42 | "data['new_col'] = data[1]/data[0]" 43 | ], 44 | "metadata": { 45 | "collapsed": false 46 | } 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 22, 51 | "outputs": [], 52 | "source": [ 53 | "data.k = data.k+1\n", 54 | "data.n = data.n+2" 55 | ], 56 | "metadata": { 57 | "collapsed": false 58 | } 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 23, 63 | "outputs": [], 64 | "source": [ 65 | "data['new_col'] = data.k/data.n" 66 | ], 67 | "metadata": { 68 | "collapsed": false 69 | } 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 24, 74 | "outputs": [], 75 | "source": [ 76 | "data = data.sort_values('new_col').reset_index()" 77 | ], 78 | "metadata": { 79 | "collapsed": false 80 | } 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 25, 85 | "outputs": [], 86 | "source": [ 87 | "data['index'].to_csv('output.txt',index=None,sep=' ')" 88 | ], 89 | "metadata": { 90 | "collapsed": false 91 | } 92 | } 93 | ], 94 | "metadata": { 95 | "kernelspec": { 96 | "display_name": "Python 3", 97 | "language": "python", 98 | "name": "python3" 99 | }, 100 | "language_info": { 101 | "codemirror_mode": { 102 | "name": "ipython", 103 | "version": 2 104 | }, 105 | "file_extension": ".py", 106 | "mimetype": "text/x-python", 107 | "name": "python", 108 | "nbconvert_exporter": "python", 109 | "pygments_lexer": "ipython2", 110 | "version": "2.7.6" 111 | } 112 | }, 113 | "nbformat": 4, 114 | "nbformat_minor": 0 115 | } 116 | -------------------------------------------------------------------------------- /243.РекомендательнаяСистемаSVD/input.txt: -------------------------------------------------------------------------------- 1 | 10 3 3 5 4 2 | 0 0 9 3 | 0 1 8 4 | 1 1 4 5 | 1 2 6 6 | 2 2 7 7 | 0 2 8 | 1 0 9 | 2 0 10 | 2 1 -------------------------------------------------------------------------------- /243.РекомендательнаяСистемаSVD/РекомендательнаяСистемаSVD.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче нас буквально просят реализовать рекомендательную систему SVD, представленную Simon Funk во время легендарного соревнования от Netflix. Реализация алгоритма представлена в библиотеке [surprise](https://surprise.readthedocs.io/en/stable/matrix_factorization.html#surprise.prediction_algorithms.matrix_factorization.SVD). Однако, в рамках соревнований эта библиотека недоступна, а иными методами через scipy у меня реализовать не вышло, поэтому пришлось реализовывать представленные формулы собственными силами. В остальном, все как всегда, градиентный спуск, 5 эпох, learning rate и так далее. В моей реализации u = user, m = movie = item = i, в остальном формулы 1 в 1, как в исходной библиотеке." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "outputs": [], 16 | "source": [ 17 | "import numpy as np\n", 18 | "\n", 19 | "f = open('input.txt','r')\n", 20 | "k,U,M,D,T = map(int,f.readline().split())\n", 21 | "u_data = []\n", 22 | "m_data = []\n", 23 | "r_data = []\n", 24 | "for i in range(D):\n", 25 | " u,m,r = map(int,f.readline().split())\n", 26 | " u_data.append(u)\n", 27 | " m_data.append(m)\n", 28 | " r_data.append(r)\n", 29 | "\n", 30 | "train = np.array(list(zip(u_data,m_data,r_data)))\n", 31 | "mu = train[:,2].mean()\n", 32 | "\n", 33 | "bu = np.zeros(U)\n", 34 | "bm = np.zeros(M)\n", 35 | "pu = np.random.normal(0, 0.1, (U, 20))\n", 36 | "qm = np.random.normal(0, 0.1, (M, 20))\n", 37 | "\n", 38 | "for _ in range(5):\n", 39 | " for u, m, r in train:\n", 40 | " err = r - (mu + bu[u] + bm[m] + qm[m] @ pu[u])\n", 41 | "\n", 42 | " bu[u] += 0.02 * (err - 0.03 * bu[u])\n", 43 | " bm[m] += 0.02 * (err - 0.03 * bm[m])\n", 44 | " pu[u] += 0.02 * (err * qm[m] - 0.03 * pu[u])\n", 45 | " qm[m] += 0.02 * (err * pu[u] - 0.03 * qm[m])\n", 46 | "\n", 47 | "for i in range(T):\n", 48 | " u,m = map(int,f.readline().split())\n", 49 | " r = mu + bu[u] + bm[m] + qm[m] @ pu[u]\n", 50 | " print(r)" 51 | ], 52 | "metadata": { 53 | "collapsed": false 54 | } 55 | } 56 | ], 57 | "metadata": { 58 | "kernelspec": { 59 | "display_name": "Python 3", 60 | "language": "python", 61 | "name": "python3" 62 | }, 63 | "language_info": { 64 | "codemirror_mode": { 65 | "name": "ipython", 66 | "version": 2 67 | }, 68 | "file_extension": ".py", 69 | "mimetype": "text/x-python", 70 | "name": "python", 71 | "nbconvert_exporter": "python", 72 | "pygments_lexer": "ipython2", 73 | "version": "2.7.6" 74 | } 75 | }, 76 | "nbformat": 4, 77 | "nbformat_minor": 0 78 | } 79 | -------------------------------------------------------------------------------- /262.ЛентаРекомендаций/input.txt: -------------------------------------------------------------------------------- 1 | 10 2 2 | 1 3 | 1 4 | 1 5 | 0 6 | 0 7 | 1 8 | 0 9 | 1 10 | 1 11 | 1 -------------------------------------------------------------------------------- /262.ЛентаРекомендаций/ЛентаРекомендаций.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Данную задачу можно решить, выбирая наиболее релевантный объект из возможных, что и реализовано в коде ниже. Т.е. пока мы можем мы добавляем объект и переходим к следующему, а если не можем добавить, то добавляем очередной объект в лист ожидания (repeat), из которого достаем как только появляется возможность, а на текущем шаге переходим к следующему" 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 17, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [ 19 | { 20 | "name": "stdout", 21 | "output_type": "stream", 22 | "text": [ 23 | "0 3 1 4 2 6 5\n" 24 | ] 25 | } 26 | ], 27 | "source": [ 28 | "from collections import deque\n", 29 | "with open('input.txt') as f:\n", 30 | " n,m = map(int, f.readline().split())\n", 31 | " inp_arr = [int(f.readline()) for _ in range(n)]\n", 32 | "\n", 33 | "res = []\n", 34 | "repeat = deque()\n", 35 | "for i in range(n):\n", 36 | " if len(res) == 0 or inp_arr[res[-1]] != inp_arr[i]:\n", 37 | " res.append(i)\n", 38 | " if len(repeat) != 0 and inp_arr[repeat[0]] != inp_arr[res[-1]]:\n", 39 | " res.append(repeat[0])\n", 40 | " repeat.popleft()\n", 41 | " else:\n", 42 | " repeat.append(i)\n", 43 | "\n", 44 | "print(' '.join([str(i) for i in res]))" 45 | ] 46 | } 47 | ], 48 | "metadata": { 49 | "kernelspec": { 50 | "display_name": "Python 3", 51 | "language": "python", 52 | "name": "python3" 53 | }, 54 | "language_info": { 55 | "codemirror_mode": { 56 | "name": "ipython", 57 | "version": 2 58 | }, 59 | "file_extension": ".py", 60 | "mimetype": "text/x-python", 61 | "name": "python", 62 | "nbconvert_exporter": "python", 63 | "pygments_lexer": "ipython2", 64 | "version": "2.7.6" 65 | } 66 | }, 67 | "nbformat": 4, 68 | "nbformat_minor": 0 69 | } 70 | -------------------------------------------------------------------------------- /266.КластеризацияСимвольныхПоследовательностей/input.txt: -------------------------------------------------------------------------------- 1 | 100 3 2 | ab 3 | a 4 | a 5 | aa 6 | a 7 | aaa 8 | a 9 | aaaaaa 10 | aa 11 | a 12 | a 13 | a 14 | aaa 15 | a 16 | a 17 | aaa 18 | aa 19 | aaaa 20 | aaa 21 | a 22 | aaaaa 23 | aa 24 | a 25 | aaaa 26 | a 27 | a 28 | a 29 | a 30 | a 31 | a 32 | aa 33 | aaaa 34 | aaa 35 | a 36 | aa 37 | aaaa 38 | a 39 | a 40 | a 41 | a 42 | a 43 | a 44 | a 45 | a 46 | a 47 | a 48 | aa 49 | aaa 50 | aaa 51 | a 52 | a 53 | bbb 54 | bb 55 | bb 56 | bbbbbbb 57 | bb 58 | bbb 59 | b 60 | bbbbbbb 61 | bbbb 62 | bbb 63 | bb 64 | bbb 65 | bb 66 | bb 67 | bbb 68 | bbbbbb 69 | bbb 70 | b 71 | bbbbbb 72 | b 73 | bbbbb 74 | b 75 | b 76 | bb 77 | b 78 | bb 79 | bb 80 | b 81 | b 82 | b 83 | b 84 | bb 85 | bb 86 | bb 87 | b 88 | b 89 | b 90 | bb 91 | b 92 | bbb 93 | bb 94 | b 95 | bbbbbb 96 | b 97 | bb 98 | bb 99 | bb 100 | b 101 | bb 102 | bbb -------------------------------------------------------------------------------- /266.КластеризацияСимвольныхПоследовательностей/КластеризацияСимвольныхПоследовательностей.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче, к сожалению, не сработали никакие из методов кластеризации, представленные в sklearn, а также не были найдены какие-либо способы кластеризации цепей Маркова, да и в целом не были найдены никакие зацепки, кроме алгоритма, представленного в [данной статье](https://habr.com/ru/companies/yandex/articles/461273/)." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "outputs": [], 16 | "source": [ 17 | "import math\n", 18 | "import random\n", 19 | "\n", 20 | "with open('input.txt') as f:\n", 21 | " N, K = list(map(int, f.readline().split()))\n", 22 | " data = []\n", 23 | " alphabet = list(f.readline()) + ['']\n", 24 | " for _ in range(N):\n", 25 | " data.append(f.readline())\n", 26 | "\n", 27 | "alphabet_len = len(alphabet)\n", 28 | "data_len = len(data)\n", 29 | "samples = [tuple([alphabet.index(token) for token in s] + [alphabet_len - 1, alphabet_len - 1]) for s in data]\n", 30 | "probs = [random.random() for _ in range(data_len)]\n", 31 | "\n", 32 | "def normalized_row(row):\n", 33 | " row_sum = sum(row) + 1e-9\n", 34 | " return [x / row_sum for x in row]\n", 35 | "\n", 36 | "def normalized_matrix(matrix):\n", 37 | " return [normalized_row(row) for row in matrix]\n", 38 | "\n", 39 | "for _ in range(150):\n", 40 | " old_probs = probs[:]\n", 41 | " p0, A = [0] * alphabet_len, [[0 for _ in range(alphabet_len)] for _ in range(alphabet_len)]\n", 42 | " q0, B = [0] * alphabet_len, [[0 for _ in range(alphabet_len)] for _ in range(alphabet_len)]\n", 43 | " for prob, sample in zip(probs, samples):\n", 44 | " p0[sample[0]] += prob\n", 45 | " q0[sample[0]] += 1 - prob\n", 46 | " for t1, t2 in zip(sample[:-1], sample[1:]):\n", 47 | " A[t1][t2] += prob\n", 48 | " B[t1][t2] += 1 - prob\n", 49 | "\n", 50 | " A, p0 = normalized_matrix(A), normalized_row(p0)\n", 51 | " B, q0 = normalized_matrix(B), normalized_row(q0)\n", 52 | "\n", 53 | " log_diff = [[math.log(b + 1e-9) - math.log(a + 1e-9) for b, a in zip(B_r, A_r)] for B_r, A_r in zip(B, A)]\n", 54 | "\n", 55 | " probs = [0] * data_len\n", 56 | " for i, sample in enumerate(samples):\n", 57 | " value = math.log(q0[sample[0]] + 1e-9) - math.log(p0[sample[0]] + 1e-9)\n", 58 | " for t1, t2 in zip(sample[:-1], sample[1:]):\n", 59 | " value += log_diff[t1][t2]\n", 60 | " probs[i] = 1.0 / (1.0 + math.exp(value))\n", 61 | "\n", 62 | "\n", 63 | "for res in probs:\n", 64 | " print(int(res >= 0.5))" 65 | ], 66 | "metadata": { 67 | "collapsed": false 68 | } 69 | } 70 | ], 71 | "metadata": { 72 | "kernelspec": { 73 | "display_name": "Python 3", 74 | "language": "python", 75 | "name": "python3" 76 | }, 77 | "language_info": { 78 | "codemirror_mode": { 79 | "name": "ipython", 80 | "version": 2 81 | }, 82 | "file_extension": ".py", 83 | "mimetype": "text/x-python", 84 | "name": "python", 85 | "nbconvert_exporter": "python", 86 | "pygments_lexer": "ipython2", 87 | "version": "2.7.6" 88 | } 89 | }, 90 | "nbformat": 4, 91 | "nbformat_minor": 0 92 | } 93 | -------------------------------------------------------------------------------- /271.Интерполяция/Интерполяция.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче нам предстоит подобрать коэффициента для многочлена 2 степени от 5 переменных, чтобы это сделать можно воспользоваться PolynomialFeatures, который сгенерирует необходимые комбинации переменных (на основе входного набора значений переменных), которые соответствуют элементам (одночленам) многочлена 2 степени, а LinearRegression подберет коэффициенты для каждого элемента (одночлена).\n", 7 | "\n", 8 | "Как работает PolynomialFeatures для 2 степени для 2-ух переменных:\n", 9 | "На вход подаются значения [x,y]\n", 10 | "На выходе получаете [1, x, y, x^2^, xy, xy^2^]" 11 | ], 12 | "metadata": { 13 | "collapsed": false 14 | } 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": { 20 | "collapsed": true 21 | }, 22 | "outputs": [], 23 | "source": [ 24 | "import numpy as np\n", 25 | "from sklearn.preprocessing import PolynomialFeatures\n", 26 | "from sklearn.linear_model import LinearRegression\n", 27 | "\n", 28 | "degree = 2\n", 29 | "\n", 30 | "data = []\n", 31 | "test_data = []\n", 32 | "with open('input.txt', 'r') as f:\n", 33 | " for _ in range(1000):\n", 34 | " data.append([float(x) for x in f.readline().split('\\t')])\n", 35 | " for _ in range(1000):\n", 36 | " test_data.append([float(x) for x in f.readline().split('\\t')])\n", 37 | "\n", 38 | "data = np.array(data)\n", 39 | "test_data = np.array(test_data)\n", 40 | "xdata = data[:, :-1]\n", 41 | "ydata = data[:, -1]\n", 42 | "\n", 43 | "poly_model = PolynomialFeatures(degree=degree)\n", 44 | "poly_x_values = poly_model.fit_transform(xdata)\n", 45 | "\n", 46 | "regression_model = LinearRegression()\n", 47 | "regression_model.fit(poly_x_values, ydata)\n", 48 | "\n", 49 | "y_pred = regression_model.predict(poly_model.transform(test_data))\n", 50 | "\n", 51 | "np.savetxt('output.txt', y_pred)" 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "codemirror_mode": { 63 | "name": "ipython", 64 | "version": 2 65 | }, 66 | "file_extension": ".py", 67 | "mimetype": "text/x-python", 68 | "name": "python", 69 | "nbconvert_exporter": "python", 70 | "pygments_lexer": "ipython2", 71 | "version": "2.7.6" 72 | } 73 | }, 74 | "nbformat": 4, 75 | "nbformat_minor": 0 76 | } 77 | -------------------------------------------------------------------------------- /282.D-CoV-3999/D-CoV-3999.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче основная идея была в том, чтобы представить встречи в виде словаря, где ключ - это порядковый номер встречи, а значение - множество работников, которые присутствуют на встрече.\n", 7 | " Далее мы сортируем встречи по их порядку, а затем от встречи к встрече проверяем есть ли на текущей встрече заболевший сотрудник, если такой сотрудник есть, то мы всех участников записываем в больные и переходим к следующей встрече, на которой алгоритм повторяется." 8 | ], 9 | "metadata": { 10 | "collapsed": false 11 | } 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 14, 16 | "metadata": { 17 | "collapsed": true 18 | }, 19 | "outputs": [ 20 | { 21 | "name": "stdout", 22 | "output_type": "stream", 23 | "text": [ 24 | "1 1 0 1\n" 25 | ] 26 | } 27 | ], 28 | "source": [ 29 | "with open('input.txt','r') as f:\n", 30 | " n = int(f.readline())\n", 31 | " tests = list(map(int,f.readline().split()))\n", 32 | " ill = set()\n", 33 | " for index,val in enumerate(tests):\n", 34 | " if val:\n", 35 | " ill.add(index)\n", 36 | " meetings = {}\n", 37 | " for i in range(n):\n", 38 | " row = list(map(int,f.readline().split()))\n", 39 | " for meet in row[1:]:\n", 40 | " if meet in meetings:\n", 41 | " meetings[meet].add(i)\n", 42 | " else:\n", 43 | " meetings[meet] = set([i])\n", 44 | "\n", 45 | "for key in sorted(meetings.keys()):\n", 46 | " if meetings[key]&ill:\n", 47 | " ill.update(meetings[key])\n", 48 | "res = []\n", 49 | "for i in range(n):\n", 50 | " if i in ill:\n", 51 | " res.append(1)\n", 52 | " else:\n", 53 | " res.append(0)\n", 54 | "print(' '.join([str(i) for i in res]))" 55 | ] 56 | } 57 | ], 58 | "metadata": { 59 | "kernelspec": { 60 | "display_name": "Python 3", 61 | "language": "python", 62 | "name": "python3" 63 | }, 64 | "language_info": { 65 | "codemirror_mode": { 66 | "name": "ipython", 67 | "version": 2 68 | }, 69 | "file_extension": ".py", 70 | "mimetype": "text/x-python", 71 | "name": "python", 72 | "nbconvert_exporter": "python", 73 | "pygments_lexer": "ipython2", 74 | "version": "2.7.6" 75 | } 76 | }, 77 | "nbformat": 4, 78 | "nbformat_minor": 0 79 | } 80 | -------------------------------------------------------------------------------- /282.D-CoV-3999/input.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 1 0 0 1 3 | 1 1 4 | 1 1 5 | 0 6 | 0 -------------------------------------------------------------------------------- /283.КанатнаяДорога/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 2 2 3 | 3 1 4 | 4 2 5 | 5 2 6 | 6 3 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 8 18 | 2 2 19 | 4 2 20 | 6 2 21 | 8 1 22 | 10 4 23 | 12 2 24 | 14 2 25 | 16 6 26 | 27 | 28 | -------------------------------------------------------------------------------- /283.КанатнаяДорога/КанатнаяДорога.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "По моим личным ощущениям основная сложность данной задачи в том, чтобы корректно понять условие. Поэтому повторим:\n", 7 | "1. Все подряд идущие вершины соединены друг с другом (не важно больше следующая вершина или меньше, они соединены)\n", 8 | "2. Дополнительно каждая вершина соединена со следующей НЕ меньшей по высоте, то есть большей либо равной по высоте. То есть у нас есть вершины 1-2-3, 1 вершина больше 2, но меньше 3. Получается впадина с вершиной 2 внизу. Мы соединяем последовательно вершины 1-2-3, а также дополнительно соединяем вершины 1 и 3.\n", 9 | "\n", 10 | "Собственно далее в алгоритме именно это и реализовано, мы идем от вершины к вершине, считаем это расстояние, а также считаем дополнительно для тех вершин, которые больше предыдущих, но учитываем, чтобы это были не подряд идущие вершины (если это подряд идущие вершины, то мы вычитаем лишнее)." 11 | ], 12 | "metadata": { 13 | "collapsed": false 14 | } 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "outputs": [], 20 | "source": [ 21 | "import sys\n", 22 | "\n", 23 | "n = int(sys.stdin.readline())\n", 24 | "x_arr,y_arr = [],[]\n", 25 | "for _ in range(n):\n", 26 | " a,b = map(int,sys.stdin.readline().split())\n", 27 | " x_arr.append(a)\n", 28 | " y_arr.append(b)\n", 29 | "\n", 30 | "def fast(x_arr,y_arr):\n", 31 | " x_prev = 0\n", 32 | " y_prev = 0\n", 33 | " res = 0\n", 34 | " stack = []\n", 35 | " stack.append((x_arr[0],y_arr[0],0))\n", 36 | " for i in range(len(x_arr)):\n", 37 | " sled = (x_arr[i],y_arr[i],i)\n", 38 | " if len(stack)!=0:\n", 39 | " element = stack.pop()\n", 40 | " while element[1]<=sled[1]:\n", 41 | " res += ((element[0]-sled[0])**2+(element[1]-sled[1])**2)**0.5\n", 42 | " if sled[2]-element[2] == 1:\n", 43 | " res -= ((element[0]-sled[0])**2+(element[1]-sled[1])**2)**0.5\n", 44 | " if len(stack) == 0:\n", 45 | " break\n", 46 | " element = stack.pop()\n", 47 | " if element[1]>sled[1]:\n", 48 | " stack.append(element)\n", 49 | " stack.append(sled)\n", 50 | " x = x_arr[i]\n", 51 | " y = y_arr[i]\n", 52 | " res += ((x-x_prev)**2+(y-y_prev)**2)**0.5\n", 53 | " x_prev = x\n", 54 | " y_prev = y\n", 55 | "\n", 56 | "\n", 57 | " return res\n", 58 | "\n", 59 | "\n", 60 | "print(fast(x_arr,y_arr))" 61 | ], 62 | "metadata": { 63 | "collapsed": false 64 | } 65 | } 66 | ], 67 | "metadata": { 68 | "kernelspec": { 69 | "display_name": "Python 3", 70 | "language": "python", 71 | "name": "python3" 72 | }, 73 | "language_info": { 74 | "codemirror_mode": { 75 | "name": "ipython", 76 | "version": 2 77 | }, 78 | "file_extension": ".py", 79 | "mimetype": "text/x-python", 80 | "name": "python", 81 | "nbconvert_exporter": "python", 82 | "pygments_lexer": "ipython2", 83 | "version": "2.7.6" 84 | } 85 | }, 86 | "nbformat": 4, 87 | "nbformat_minor": 0 88 | } 89 | -------------------------------------------------------------------------------- /288.ОптимальнаяКонстанта/input.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 1 3 | 2 4 | 3 -------------------------------------------------------------------------------- /288.ОптимальнаяКонстанта/output.txt: -------------------------------------------------------------------------------- 1 | 1.521 -------------------------------------------------------------------------------- /288.ОптимальнаяКонстанта/ОптимальнаяКонстанта.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Константы для MSE и MAE - это некоторая база, которую любят спрашивать на тестах, собеседованиях и прочем, а также использовать как совсем базовое решение для задачи с данными метриками. В связи с чем найти ответы про наилучшее константное значение для этих метрик не составит труда. А именно, для MSE - среднее выборки, для MAE - медиана выборки.\n", 7 | "С MAPE все сложнее.\n", 8 | "MAPE - это MAE, взвешенная по значениям y, это легко можно увидеть взглянув на их формулы. Таким образом, в то время, когда для MAE наилучшее константное предскание - медиана, для MAPE - наилучшее константное предсказание - это взвешенная медиана." 9 | ], 10 | "metadata": { 11 | "collapsed": false 12 | } 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": null, 17 | "outputs": [], 18 | "source": [ 19 | "import sys\n", 20 | "import numpy as np\n", 21 | "\n", 22 | "n = int(sys.stdin.readline())\n", 23 | "arr = []\n", 24 | "\n", 25 | "for _ in range(n):\n", 26 | " arr.append(int(sys.stdin.readline()))\n", 27 | "\n", 28 | "\n", 29 | "def weighted_median(data, weights):\n", 30 | " data, weights = np.array(data).squeeze(), np.array(weights).squeeze()\n", 31 | " s_data, s_weights = map(np.array, zip(*sorted(zip(data, weights))))\n", 32 | " midpoint = 0.5 * sum(s_weights)\n", 33 | " if any(weights > midpoint):\n", 34 | " w_median = (data[weights == np.max(weights)])[0]\n", 35 | " else:\n", 36 | " cs_weights = np.cumsum(s_weights)\n", 37 | " idx = np.where(cs_weights <= midpoint)[0][-1]\n", 38 | " if cs_weights[idx] == midpoint:\n", 39 | " w_median = np.mean(s_data[idx:idx+2])\n", 40 | " else:\n", 41 | " w_median = s_data[idx+1]\n", 42 | " return w_median\n", 43 | "\n", 44 | "\n", 45 | "arr = np.array(arr)\n", 46 | "weights = 1/arr\n", 47 | "weights = weights/sum(weights)\n", 48 | "\n", 49 | "print(np.mean(arr))\n", 50 | "print(np.median(arr))\n", 51 | "if len(arr) == 1:\n", 52 | " print(np.median(arr))\n", 53 | "else:\n", 54 | " print(weighted_median(arr,weights))" 55 | ], 56 | "metadata": { 57 | "collapsed": false 58 | } 59 | } 60 | ], 61 | "metadata": { 62 | "kernelspec": { 63 | "display_name": "Python 3", 64 | "language": "python", 65 | "name": "python3" 66 | }, 67 | "language_info": { 68 | "codemirror_mode": { 69 | "name": "ipython", 70 | "version": 2 71 | }, 72 | "file_extension": ".py", 73 | "mimetype": "text/x-python", 74 | "name": "python", 75 | "nbconvert_exporter": "python", 76 | "pygments_lexer": "ipython2", 77 | "version": "2.7.6" 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 0 82 | } 83 | -------------------------------------------------------------------------------- /297.Исчезнувшая/bad_in.txt: -------------------------------------------------------------------------------- 1 | 12 12 2 | 3 | # 4 | ### 5 | ##### 6 | ### 7 | ##### 8 | ####### 9 | ######### 10 | ########### 11 | ### 12 | ### 13 | 14 | 12 12 15 | 16 | ### 17 | ### 18 | ########### 19 | ######### 20 | ####### 21 | ##### 22 | ### 23 | ##### 24 | ### 25 | # 26 | -------------------------------------------------------------------------------- /297.Исчезнувшая/bad_in12.txt: -------------------------------------------------------------------------------- 1 | 12 12 2 | 3 | # 4 | ### 5 | ##### 6 | ### 7 | ##### 8 | ####### 9 | ######### 10 | ########### 11 | ### 12 | ### 13 | 14 | 12 12 15 | 16 | ### 17 | ### 18 | ########### 19 | ######### 20 | ####### 21 | ##### 22 | ### 23 | ##### 24 | ### 25 | # 26 | -------------------------------------------------------------------------------- /297.Исчезнувшая/in-search-of-kitty_test-2.txt: -------------------------------------------------------------------------------- 1 | 12 12 2 | # 3 | ### 4 | ##### 5 | ### 6 | ##### 7 | ####### 8 | ######### 9 | ########### 10 | ### 11 | ### 12 | 13 | 12 12 14 | 15 | ### 16 | ### 17 | ########### 18 | ######### 19 | ####### 20 | ##### 21 | ### 22 | ##### 23 | ### 24 | # 25 | -------------------------------------------------------------------------------- /297.Исчезнувшая/Исчезнувшая.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче нам необходимо найти матрицу внутри другой матрицы, они могут быть равны по размерам, могут быть не равны, а также могут быть повернуты на 0,90,180,270 градусов, т.е. нам будет необходимо рассмотреть 4 случая.\n", 7 | "Можно проверять каждый элемент по отдельности, но возникнет сложность N^4^ и мы получим TL на одном из последних тестов.\n", 8 | "Чтобы ускорить алгоритм я поступил следующим образом:\n", 9 | "1. Каждый искомый ряд символов был сохранен в виде строки и хэширован, получился вектор длины n1\n", 10 | "2. Далее последовательность длины m1 по столбцам в матрице 2 (по которой происходит поиск) преобразовывалась в строку, строка хэшировалась. Затем хэш сравнивался с первым хэшем вектора из 1 пункта.\n", 11 | "3. Если хэши равны, то мы переходим во второй цикл, где сравниваем все остальные хэши аналогично второму пункту двигаясь вниз по рядам, но не двигаясь по столбцам. Если хэши не равны, то сдвигаемся по столбцу и переходим к пункту 2.\n", 12 | "4. Если по столбцу сдвигаться уже некуда, то сдвигаемся по ряду.\n", 13 | "5. Если по ряду сдвигаться некуда, то выходим из цикла и возвращаем False\n", 14 | "6. Повторяем пункты 1-5 для всех вариантов поворотов искомой матрицы, если не находим выводим No, если находим выводим Yes" 15 | ], 16 | "metadata": { 17 | "collapsed": false 18 | } 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "outputs": [], 24 | "source": [ 25 | "with open(\"input.txt\", \"r\") as f:\n", 26 | " image = f.read().splitlines()\n", 27 | "\n", 28 | "n,_ = map(int,image[0].split())\n", 29 | "arr1 = image[1:n+1]\n", 30 | "n2,_ = map(int,image[n+1].split())\n", 31 | "arr2 = image[n+2:n+1+n2+1]\n", 32 | "rot_90 = []\n", 33 | "for i in range(len(arr1[0])):\n", 34 | " li = list(map(lambda x: x[i], arr1))\n", 35 | " li.reverse()\n", 36 | " rot_90.append(''.join(li))\n", 37 | "\n", 38 | "rot_180 = []\n", 39 | "for i in range(len(arr1)):\n", 40 | " li = list(map(lambda x: x[i], rot_90))\n", 41 | " li.reverse()\n", 42 | " rot_180.append(''.join(li))\n", 43 | "\n", 44 | "rot_270 = [''.join(c) for c in list(zip(*arr1))[::-1]]\n", 45 | "\n", 46 | "def is_subarray(sub, arr):\n", 47 | " rows_sub, cols_sub = len(sub), len(sub[0])\n", 48 | " rows_arr, cols_arr = len(arr), len(arr[0])\n", 49 | " sub_hashes = [hash(i) for i in sub]\n", 50 | " for i in range(rows_arr - rows_sub + 1):\n", 51 | " isMatch= False\n", 52 | " cntr = 0\n", 53 | " for j in range(cols_arr - cols_sub + 1):\n", 54 | " if hash(arr[i][j:j+cols_sub]) == sub_hashes[0]:\n", 55 | " isMatch = True\n", 56 | " last_j = j\n", 57 | " cntr += 1\n", 58 | " break\n", 59 | " if isMatch:\n", 60 | " for k in range(i+1,i+rows_sub):\n", 61 | " if hash(arr[k][last_j:last_j+cols_sub])==sub_hashes[cntr]:\n", 62 | " cntr += 1\n", 63 | " else:\n", 64 | " break\n", 65 | " else:\n", 66 | " return True\n", 67 | " return False\n", 68 | "\n", 69 | "if is_subarray(arr1,arr2):\n", 70 | " print('Yes')\n", 71 | "elif is_subarray(rot_90,arr2):\n", 72 | " print('Yes')\n", 73 | "elif is_subarray(rot_180,arr2):\n", 74 | " print('Yes')\n", 75 | "elif is_subarray(rot_270,arr2):\n", 76 | " print('Yes')\n", 77 | "else:\n", 78 | " print('No')" 79 | ], 80 | "metadata": { 81 | "collapsed": false 82 | } 83 | } 84 | ], 85 | "metadata": { 86 | "kernelspec": { 87 | "display_name": "Python 3", 88 | "language": "python", 89 | "name": "python3" 90 | }, 91 | "language_info": { 92 | "codemirror_mode": { 93 | "name": "ipython", 94 | "version": 2 95 | }, 96 | "file_extension": ".py", 97 | "mimetype": "text/x-python", 98 | "name": "python", 99 | "nbconvert_exporter": "python", 100 | "pygments_lexer": "ipython2", 101 | "version": "2.7.6" 102 | } 103 | }, 104 | "nbformat": 4, 105 | "nbformat_minor": 0 106 | } 107 | -------------------------------------------------------------------------------- /301.БутылкиРома/output.txt: -------------------------------------------------------------------------------- 1 | 1 -------------------------------------------------------------------------------- /301.БутылкиРома/БутылкиРома.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Для решения это задачи необходимо знать формулу как из набора с повторениями получить всевозможные наборы длины n, где n - суммарное количество элементов в наборе.\n", 7 | "Формула:\n", 8 | "\n", 9 | "$$\\frac{n!}{n_1!*n_2!...n_k!}$$\n", 10 | "\n", 11 | "Далее нам необходимо из первоначального набора получить всевозможные комбинации заданных длин, а именно от 1 до len(исходный набор), в этом нам поможет combinations из itertools.\n", 12 | "Далее нам необходимо в этих наборах выделить уникальные, то есть отсортировать каждый набор и добавить в set.\n", 13 | "Дальше только остается применить вышеупомянутую формулу для каждого набора и получить ответ." 14 | ], 15 | "metadata": { 16 | "collapsed": false 17 | } 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "outputs": [], 23 | "source": [ 24 | "from itertools import combinations\n", 25 | "from collections import Counter\n", 26 | "import math\n", 27 | "\n", 28 | "in_s = input()\n", 29 | "\n", 30 | "dct = {}\n", 31 | "for i in range(1,len(in_s) + 1):\n", 32 | " dct[i] = list(combinations(in_s,i))\n", 33 | "res_set = set()\n", 34 | "for v in dct.values():\n", 35 | " for elem in v:\n", 36 | " res_set.add(tuple(sorted(elem)))\n", 37 | "\n", 38 | "res = 0\n", 39 | "for elem in res_set:\n", 40 | " denom = 1\n", 41 | " n = math.factorial(len(elem))\n", 42 | " cntr = Counter(elem)\n", 43 | " for v in cntr.values():\n", 44 | " denom *= math.factorial(v)\n", 45 | " res += n/denom\n", 46 | "print(int(res))" 47 | ], 48 | "metadata": { 49 | "collapsed": false 50 | } 51 | } 52 | ], 53 | "metadata": { 54 | "kernelspec": { 55 | "display_name": "Python 3", 56 | "language": "python", 57 | "name": "python3" 58 | }, 59 | "language_info": { 60 | "codemirror_mode": { 61 | "name": "ipython", 62 | "version": 2 63 | }, 64 | "file_extension": ".py", 65 | "mimetype": "text/x-python", 66 | "name": "python", 67 | "nbconvert_exporter": "python", 68 | "pygments_lexer": "ipython2", 69 | "version": "2.7.6" 70 | } 71 | }, 72 | "nbformat": 4, 73 | "nbformat_minor": 0 74 | } 75 | -------------------------------------------------------------------------------- /312.ИннокентийИДрузья/ИннокентийИДрузья.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче нам необходимо реализовать маленькую, не сильно требовательную рекомендательную систему. В качестве решения, по моему, можно использовать ту же библиотеку surprise, или код, написанный для задачи 243. РекомендательнаяСистемаSVD, или любую другую библиотеку для рекомендательных систем по типу implicit, lightFM. Большинство этих решений пройдет, проверено)\n", 7 | "В итоге, нам на основе существующих оценок необходимо составить матрицу user-item (в которой содержатся id-пользователя, id-заведения и оценки на пересечениях строк и столбцов), а затем с помощью любой библиотеки провести факторизацию и рекомендовать каждому пользователю от 1 до 100 заведений из города, в котором он НЕ живет.\n", 8 | "Я в коде ниже выбрал библиотеку implicit и каждому пользователю рекомендовал 40 заведений.\n", 9 | "\n", 10 | "P.S. Когда я пытался сделать эту задачу у меня не проходило огромное количество решений из-за того, что был сломан чекер, поэтому я углублялся все дальше, а тетрадка засорялась все сильнее и плодились ее копии с разными библиотеками. Каково же было мое удивление, когда я зашёл отправить очередное решение и увидел, что задача зачтена, а вместе с тем 80% отправленных решений также зачтены. В итоге, в качестве примера я выбрал не самое сложное, но и не самое легкое в понимании решение, для которого у меня сохранилась тетрадка в +- адекватном виде.\n", 11 | "P.P.S. Задача настолько не требовательное, что ходят слухи, что можно рекомендовать просто самые популярные заведения в городе или около того, что в целом и логично, но )))" 12 | ], 13 | "metadata": { 14 | "collapsed": false 15 | } 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": { 21 | "collapsed": true 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "import pandas as pd\n", 26 | "import numpy as np\n", 27 | "from tqdm.notebook import tqdm" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 2, 33 | "outputs": [], 34 | "source": [ 35 | "reviews = pd.read_csv('reviews.csv', index_col=0)\n", 36 | "reviews['rating'] = np.array(reviews.rating.fillna(0) + 1)\n", 37 | "orgs = pd.read_csv('organisations.csv')\n", 38 | "users = pd.read_csv('users.csv')\n", 39 | "\n", 40 | "# encode users ids as numeric\n", 41 | "reviews = reviews.merge(users, on='user_id')\n", 42 | "reviews = reviews.rename({'city': 'user_city'}, axis=1)\n", 43 | "\n", 44 | "# # encode orgs ids as numeric\n", 45 | "reviews = reviews.merge(orgs[['org_id', 'city','rubrics_id','features_id','rating','average_bill']], on='org_id')\n", 46 | "reviews = reviews.rename({'city': 'org_city'}, axis=1)" 47 | ], 48 | "metadata": { 49 | "collapsed": false 50 | } 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 4, 55 | "outputs": [], 56 | "source": [ 57 | "import scipy\n", 58 | "\n", 59 | "rows, r_pos = np.unique(reviews.values[:,1], return_inverse=True)\n", 60 | "cols, c_pos = np.unique(reviews.values[:,0], return_inverse=True)" 61 | ], 62 | "metadata": { 63 | "collapsed": false 64 | } 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 5, 69 | "outputs": [], 70 | "source": [ 71 | "interactions_sparse = scipy.sparse.csr_matrix((np.array(reviews['rating_x'],dtype=np.float64),(r_pos, c_pos)))" 72 | ], 73 | "metadata": { 74 | "collapsed": false 75 | } 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 7, 80 | "outputs": [], 81 | "source": [ 82 | "from implicit.evaluation import train_test_split\n", 83 | "\n", 84 | "train, test_set = train_test_split(interactions_sparse,0.99)" 85 | ], 86 | "metadata": { 87 | "collapsed": false 88 | } 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 8, 93 | "outputs": [ 94 | { 95 | "data": { 96 | "text/plain": " 0%| | 0/10 [00:00\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
source
0до АВГУСТА , я думаю , должно что проясниться .
1заседание перенесли на шестнадцатое АВГУСТА .
2АВГУСТА - женское имя латинского происхождения .
3бабушка невилла АВГУСТА поддерживала переписку...
4АДОНИС
\n" 23 | }, 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "output_type": "execute_result" 27 | } 28 | ], 29 | "source": [ 30 | "import pandas as pd\n", 31 | "\n", 32 | "train = pd.read_json('train.json')\n", 33 | "test = pd.read_json('test.json')\n", 34 | "test.head()" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 4, 40 | "outputs": [], 41 | "source": [ 42 | "vowels = set('аоуыэеёиюя')\n", 43 | "def get_stress_num(row):\n", 44 | " text = row['target'].split()\n", 45 | " cntr = 0\n", 46 | " for word in text:\n", 47 | " if sum(map(str.isupper,word)) == 1:\n", 48 | " for c in word:\n", 49 | " if c.isupper():\n", 50 | " return cntr\n", 51 | " if c.lower() in vowels:\n", 52 | " cntr += 1\n", 53 | "\n", 54 | "def get_word(row):\n", 55 | " text = row['source']\n", 56 | " text = text.split()\n", 57 | " for word in text:\n", 58 | " if word.isupper():\n", 59 | " return word\n" 60 | ], 61 | "metadata": { 62 | "collapsed": false 63 | } 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 5, 68 | "outputs": [], 69 | "source": [ 70 | "train['word'] = train.apply(get_word,axis=1)\n", 71 | "train['vowel_num'] = train.apply(get_stress_num,axis=1)" 72 | ], 73 | "metadata": { 74 | "collapsed": false 75 | } 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 6, 80 | "outputs": [], 81 | "source": [ 82 | "train = train.drop('target',axis=1)" 83 | ], 84 | "metadata": { 85 | "collapsed": false 86 | } 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 10, 91 | "outputs": [ 92 | { 93 | "data": { 94 | "text/plain": "0 60932\n1 57992\n2 18707\n3 2938\n4 298\n5 87\nName: vowel_num, dtype: int64" 95 | }, 96 | "execution_count": 10, 97 | "metadata": {}, 98 | "output_type": "execute_result" 99 | } 100 | ], 101 | "source": [ 102 | "train.vowel_num.value_counts()" 103 | ], 104 | "metadata": { 105 | "collapsed": false 106 | } 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 11, 111 | "outputs": [], 112 | "source": [ 113 | "from lightautoml.automl.presets.text_presets import TabularNLPAutoML\n", 114 | "from lightautoml.tasks import Task\n", 115 | "\n", 116 | "roles = {\n", 117 | " 'text': ['source','word'],\n", 118 | " 'target': 'vowel_num'\n", 119 | "}\n", 120 | "\n", 121 | "task = Task('multiclass',metric='crossentropy')\n", 122 | "\n", 123 | "automl = TabularNLPAutoML(\n", 124 | " task=task,\n", 125 | " timeout=30000,\n", 126 | " cpu_limit=8,\n", 127 | " general_params={\n", 128 | " 'nested_cv': False,\n", 129 | " 'use_algos': [['nn']],\n", 130 | " },\n", 131 | " nested_cv_params = {\n", 132 | " 'cv': 3\n", 133 | " },\n", 134 | " text_params={\n", 135 | " 'lang': 'ru',\n", 136 | " 'bert_model': 'DeepPavlov/rubert-base-cased-conversational'\n", 137 | " },\n", 138 | " nn_params={\n", 139 | " 'opt_params': {'lr': 1e-5},\n", 140 | " 'max_length': 150,\n", 141 | " 'bs': 32,\n", 142 | " 'n_epochs': 4,\n", 143 | " },\n", 144 | ")" 145 | ], 146 | "metadata": { 147 | "collapsed": false 148 | } 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 12, 153 | "outputs": [ 154 | { 155 | "name": "stderr", 156 | "output_type": "stream", 157 | "text": [ 158 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 159 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 160 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 161 | "train (loss=0.703459): 100%|██████████| 2937/2937 [15:07<00:00, 3.23it/s]\n", 162 | "val: 100%|██████████| 1469/1469 [04:26<00:00, 5.51it/s]\n", 163 | "train (loss=0.321353): 100%|██████████| 2937/2937 [14:53<00:00, 3.29it/s]\n", 164 | "val: 100%|██████████| 1469/1469 [04:26<00:00, 5.51it/s]\n", 165 | "train (loss=0.183352): 100%|██████████| 2937/2937 [14:50<00:00, 3.30it/s]\n", 166 | "val: 100%|██████████| 1469/1469 [04:30<00:00, 5.43it/s]\n", 167 | "train (loss=0.126085): 100%|██████████| 2937/2937 [14:50<00:00, 3.30it/s]\n", 168 | "val: 100%|██████████| 1469/1469 [04:26<00:00, 5.52it/s]\n", 169 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 170 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 171 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 172 | "train (loss=0.728785): 100%|██████████| 2937/2937 [14:49<00:00, 3.30it/s]\n", 173 | "val: 100%|██████████| 1469/1469 [04:29<00:00, 5.45it/s]\n", 174 | "train (loss=0.322142): 100%|██████████| 2937/2937 [17:19<00:00, 2.83it/s]\n", 175 | "val: 100%|██████████| 1469/1469 [04:56<00:00, 4.96it/s]\n", 176 | "train (loss=0.186867): 100%|██████████| 2937/2937 [15:30<00:00, 3.16it/s]\n", 177 | "val: 100%|██████████| 1469/1469 [04:35<00:00, 5.34it/s]\n", 178 | "train (loss=0.129547): 100%|██████████| 2937/2937 [16:10<00:00, 3.03it/s]\n", 179 | "val: 100%|██████████| 1469/1469 [04:26<00:00, 5.52it/s]\n", 180 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 181 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 182 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 183 | "train (loss=0.778425): 100%|██████████| 2937/2937 [14:38<00:00, 3.34it/s]\n", 184 | "val: 100%|██████████| 1469/1469 [04:43<00:00, 5.18it/s]\n", 185 | "train (loss=0.353069): 100%|██████████| 2937/2937 [15:39<00:00, 3.13it/s]\n", 186 | "val: 100%|██████████| 1469/1469 [04:54<00:00, 4.98it/s]\n", 187 | "train (loss=0.193831): 100%|██████████| 2937/2937 [16:01<00:00, 3.05it/s]\n", 188 | "val: 100%|██████████| 1469/1469 [05:15<00:00, 4.65it/s]\n", 189 | "train (loss=0.130507): 100%|██████████| 2937/2937 [15:42<00:00, 3.12it/s]\n", 190 | "val: 100%|██████████| 1469/1469 [04:46<00:00, 5.13it/s]\n" 191 | ] 192 | } 193 | ], 194 | "source": [ 195 | "oof_pred = automl.fit_predict(train, roles=roles)" 196 | ], 197 | "metadata": { 198 | "collapsed": false 199 | } 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 13, 204 | "outputs": [], 205 | "source": [ 206 | "test['word'] = test.apply(get_word,axis=1)" 207 | ], 208 | "metadata": { 209 | "collapsed": false 210 | } 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 14, 215 | "outputs": [ 216 | { 217 | "name": "stderr", 218 | "output_type": "stream", 219 | "text": [ 220 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 221 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 222 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 223 | "test: 100%|██████████| 534/534 [01:42<00:00, 5.20it/s]\n", 224 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 225 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 226 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 227 | "test: 100%|██████████| 534/534 [01:42<00:00, 5.22it/s]\n", 228 | "Some weights of the model checkpoint at DeepPavlov/rubert-base-cased-conversational were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.bias']\n", 229 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 230 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 231 | "test: 100%|██████████| 534/534 [01:41<00:00, 5.24it/s]\n" 232 | ] 233 | } 234 | ], 235 | "source": [ 236 | "res = automl.predict(test)" 237 | ], 238 | "metadata": { 239 | "collapsed": false 240 | } 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 16, 245 | "outputs": [ 246 | { 247 | "data": { 248 | "text/plain": "array([0, 1, 2, 3], dtype=int64)" 249 | }, 250 | "execution_count": 16, 251 | "metadata": {}, 252 | "output_type": "execute_result" 253 | } 254 | ], 255 | "source": [ 256 | "import numpy as np\n", 257 | "np.unique(res.to_numpy().data.argmax(axis=1))" 258 | ], 259 | "metadata": { 260 | "collapsed": false 261 | } 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 18, 266 | "outputs": [], 267 | "source": [ 268 | "test['pred'] = res.to_numpy().data.argmax(axis=1)" 269 | ], 270 | "metadata": { 271 | "collapsed": false 272 | } 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 19, 277 | "outputs": [], 278 | "source": [ 279 | "def prediction(row):\n", 280 | " word = row['word']\n", 281 | " vowel_num = row['pred']\n", 282 | " cntr = 0\n", 283 | " for indx,c in enumerate(word):\n", 284 | " if c.lower() in vowels:\n", 285 | " if cntr == vowel_num:\n", 286 | " new_word = word.lower()\n", 287 | " new_word = new_word[:indx] + new_word[indx].upper() + new_word[indx+1:]\n", 288 | " return new_word\n", 289 | " cntr += 1" 290 | ], 291 | "metadata": { 292 | "collapsed": false 293 | } 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "source": [], 298 | "metadata": { 299 | "collapsed": false 300 | } 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": 22, 305 | "outputs": [], 306 | "source": [ 307 | "test['predicted_word'] = test.apply(prediction,axis=1)" 308 | ], 309 | "metadata": { 310 | "collapsed": false 311 | } 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": 24, 316 | "outputs": [], 317 | "source": [ 318 | "test['predicted_word'].to_csv('word.csv',index=None,header=None)" 319 | ], 320 | "metadata": { 321 | "collapsed": false 322 | } 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": null, 327 | "outputs": [], 328 | "source": [], 329 | "metadata": { 330 | "collapsed": false 331 | } 332 | } 333 | ], 334 | "metadata": { 335 | "kernelspec": { 336 | "display_name": "Python 3", 337 | "language": "python", 338 | "name": "python3" 339 | }, 340 | "language_info": { 341 | "codemirror_mode": { 342 | "name": "ipython", 343 | "version": 2 344 | }, 345 | "file_extension": ".py", 346 | "mimetype": "text/x-python", 347 | "name": "python", 348 | "nbconvert_exporter": "python", 349 | "pygments_lexer": "ipython2", 350 | "version": "2.7.6" 351 | } 352 | }, 353 | "nbformat": 4, 354 | "nbformat_minor": 0 355 | } 356 | -------------------------------------------------------------------------------- /382.ПредсказаниеПогоды/input.txt: -------------------------------------------------------------------------------- 1 | 366 2 | 32.0 3 | 39.0 4 | 45.0 5 | 50.0 6 | 37.0 7 | 37.0 8 | 36.0 9 | 41.0 10 | 39.0 11 | 43.0 12 | 30.0 13 | 36.0 14 | 34.0 15 | 34.0 16 | 36.0 17 | 34.0 18 | 39.0 19 | 36.0 20 | 43.0 21 | 43.0 22 | 41.0 23 | 43.0 24 | 48.0 25 | 39.0 26 | 43.0 27 | 39.0 28 | 43.0 29 | 45.0 30 | 48.0 31 | 45.0 32 | 50.0 33 | 43.0 34 | 39.0 35 | 37.0 36 | 36.0 37 | 25.0 38 | 25.0 39 | 36.0 40 | 45.0 41 | 48.0 42 | 54.0 43 | 52.0 44 | 54.0 45 | 46.0 46 | 46.0 47 | 32.0 48 | 39.0 49 | 50.0 50 | 52.0 51 | 48.0 52 | 41.0 53 | 54.0 54 | 52.0 55 | 50.0 56 | 48.0 57 | 52.0 58 | 48.0 59 | 43.0 60 | 48.0 61 | 37.0 62 | 52.0 63 | 48.0 64 | 46.0 65 | 45.0 66 | 48.0 67 | 52.0 68 | 59.0 69 | 43.0 70 | 54.0 71 | 52.0 72 | 59.0 73 | 57.0 74 | 54.0 75 | 63.0 76 | 64.0 77 | 54.0 78 | 72.0 79 | 77.0 80 | 64.0 81 | 77.0 82 | 66.0 83 | 72.0 84 | 72.0 85 | 66.0 86 | 72.0 87 | 59.0 88 | 59.0 89 | 57.0 90 | 63.0 91 | 64.0 92 | 66.0 93 | 61.0 94 | 70.0 95 | 79.0 96 | 66.0 97 | 64.0 98 | 75.0 99 | 66.0 100 | 61.0 101 | 57.0 102 | 64.0 103 | 75.0 104 | 81.0 105 | 81.0 106 | 81.0 107 | 75.0 108 | 68.0 109 | 72.0 110 | 73.0 111 | 72.0 112 | 61.0 113 | 55.0 114 | 61.0 115 | 68.0 116 | 86.0 117 | 73.0 118 | 73.0 119 | 79.0 120 | 84.0 121 | 81.0 122 | 91.0 123 | 93.0 124 | 90.0 125 | 77.0 126 | 68.0 127 | 77.0 128 | 77.0 129 | 66.0 130 | 61.0 131 | 70.0 132 | 81.0 133 | 86.0 134 | 82.0 135 | 88.0 136 | 88.0 137 | 72.0 138 | 72.0 139 | 72.0 140 | 82.0 141 | 88.0 142 | 88.0 143 | 75.0 144 | 84.0 145 | 79.0 146 | 86.0 147 | 73.0 148 | 84.0 149 | 86.0 150 | 93.0 151 | 84.0 152 | 90.0 153 | 82.0 154 | 90.0 155 | 91.0 156 | 99.0 157 | 90.0 158 | 88.0 159 | 88.0 160 | 97.0 161 | 100.0 162 | 82.0 163 | 93.0 164 | 88.0 165 | 95.0 166 | 91.0 167 | 97.0 168 | 100.0 169 | 99.0 170 | 90.0 171 | 90.0 172 | 93.0 173 | 91.0 174 | 97.0 175 | 93.0 176 | 88.0 177 | 86.0 178 | 82.0 179 | 84.0 180 | 93.0 181 | 90.0 182 | 82.0 183 | 95.0 184 | 95.0 185 | 86.0 186 | 82.0 187 | 88.0 188 | 93.0 189 | 91.0 190 | 95.0 191 | 91.0 192 | 81.0 193 | 77.0 194 | 79.0 195 | 82.0 196 | 88.0 197 | 93.0 198 | 95.0 199 | 95.0 200 | 86.0 201 | 79.0 202 | 93.0 203 | 95.0 204 | 93.0 205 | 91.0 206 | 91.0 207 | 100.0 208 | 95.0 209 | 84.0 210 | 75.0 211 | 86.0 212 | 86.0 213 | 93.0 214 | 91.0 215 | 86.0 216 | 93.0 217 | 97.0 218 | 99.0 219 | 86.0 220 | 90.0 221 | 91.0 222 | 88.0 223 | 95.0 224 | 91.0 225 | 97.0 226 | 88.0 227 | 91.0 228 | 95.0 229 | 88.0 230 | 82.0 231 | 79.0 232 | 79.0 233 | 79.0 234 | 82.0 235 | 84.0 236 | 82.0 237 | 84.0 238 | 93.0 239 | 95.0 240 | 84.0 241 | 88.0 242 | 90.0 243 | 86.0 244 | 86.0 245 | 77.0 246 | 93.0 247 | 82.0 248 | 86.0 249 | 86.0 250 | 88.0 251 | 86.0 252 | 90.0 253 | 88.0 254 | 88.0 255 | 75.0 256 | 79.0 257 | 81.0 258 | 82.0 259 | 81.0 260 | 72.0 261 | 79.0 262 | 82.0 263 | 82.0 264 | 84.0 265 | 81.0 266 | 79.0 267 | 81.0 268 | 66.0 269 | 75.0 270 | 79.0 271 | 79.0 272 | 81.0 273 | 79.0 274 | 70.0 275 | 72.0 276 | 68.0 277 | 72.0 278 | 73.0 279 | 68.0 280 | 70.0 281 | 70.0 282 | 72.0 283 | 68.0 284 | 72.0 285 | 73.0 286 | 68.0 287 | 66.0 288 | 72.0 289 | 59.0 290 | 66.0 291 | 68.0 292 | 73.0 293 | 72.0 294 | 73.0 295 | 63.0 296 | 63.0 297 | 63.0 298 | 64.0 299 | 68.0 300 | 66.0 301 | 75.0 302 | 63.0 303 | 70.0 304 | 64.0 305 | 64.0 306 | 66.0 307 | 64.0 308 | 55.0 309 | 57.0 310 | 57.0 311 | 61.0 312 | 66.0 313 | 64.0 314 | 54.0 315 | 61.0 316 | 63.0 317 | 57.0 318 | 70.0 319 | 61.0 320 | 54.0 321 | 55.0 322 | 55.0 323 | 52.0 324 | 43.0 325 | 46.0 326 | 48.0 327 | 37.0 328 | 39.0 329 | 45.0 330 | 46.0 331 | 45.0 332 | 43.0 333 | 43.0 334 | 37.0 335 | 43.0 336 | 39.0 337 | 39.0 338 | 36.0 339 | 39.0 340 | 37.0 341 | 41.0 342 | 43.0 343 | 34.0 344 | 36.0 345 | 37.0 346 | 48.0 347 | 43.0 348 | 39.0 349 | 32.0 350 | 30.0 351 | 32.0 352 | 37.0 353 | 37.0 354 | 32.0 355 | 37.0 356 | 41.0 357 | 43.0 358 | 43.0 359 | 43.0 360 | 39.0 361 | 46.0 362 | 39.0 363 | 45.0 364 | 32.0 365 | 23.0 366 | 21.0 367 | 34.0 368 | 365 369 | 34.0 370 | 34.0 371 | 28.0 372 | 30.0 373 | 28.0 374 | 19.0 375 | 19.0 376 | 25.0 377 | 34.0 378 | 36.0 379 | 34.0 380 | 41.0 381 | 46.0 382 | 37.0 383 | 37.0 384 | 32.0 385 | 37.0 386 | 43.0 387 | 27.0 388 | 34.0 389 | 43.0 390 | 41.0 391 | 39.0 392 | 39.0 393 | 34.0 394 | 48.0 395 | 37.0 396 | 30.0 397 | 32.0 398 | 45.0 399 | 34.0 400 | 37.0 401 | 36.0 402 | 45.0 403 | 50.0 404 | 59.0 405 | 61.0 406 | 46.0 407 | 45.0 408 | 48.0 409 | 61.0 410 | 52.0 411 | 59.0 412 | 48.0 413 | 41.0 414 | 43.0 415 | 34.0 416 | 34.0 417 | 45.0 418 | 64.0 419 | 68.0 420 | 79.0 421 | 61.0 422 | 36.0 423 | 41.0 424 | 48.0 425 | 52.0 426 | 52.0 427 | 43.0 428 | 43.0 429 | 39.0 430 | 45.0 431 | 50.0 432 | 52.0 433 | 41.0 434 | 46.0 435 | 50.0 436 | 59.0 437 | 61.0 438 | 63.0 439 | 57.0 440 | 59.0 441 | 54.0 442 | 54.0 443 | 59.0 444 | 57.0 445 | 48.0 446 | 50.0 447 | 57.0 448 | 55.0 449 | 68.0 450 | 73.0 451 | 72.0 452 | 72.0 453 | 59.0 454 | 64.0 455 | 66.0 456 | 68.0 457 | 70.0 458 | 79.0 459 | 66.0 460 | 61.0 461 | 66.0 462 | 68.0 463 | 68.0 464 | 72.0 465 | 68.0 466 | 68.0 467 | 64.0 468 | 68.0 469 | 68.0 470 | 64.0 471 | 61.0 472 | 73.0 473 | 70.0 474 | 63.0 475 | 70.0 476 | 77.0 477 | 84.0 478 | 82.0 479 | 72.0 480 | 63.0 481 | 72.0 482 | 73.0 483 | 70.0 484 | 72.0 485 | 73.0 486 | 73.0 487 | 72.0 488 | 59.0 489 | 72.0 490 | 72.0 491 | 75.0 492 | 77.0 493 | 82.0 494 | 79.0 495 | 81.0 496 | 81.0 497 | 79.0 498 | 77.0 499 | 75.0 500 | 82.0 501 | 73.0 502 | 73.0 503 | 68.0 504 | 81.0 505 | 91.0 506 | 93.0 507 | 90.0 508 | 84.0 509 | 90.0 510 | 93.0 511 | 81.0 512 | 75.0 513 | 82.0 514 | 82.0 515 | 81.0 516 | 86.0 517 | 82.0 518 | 81.0 519 | 66.0 520 | 82.0 521 | 84.0 522 | 84.0 523 | 88.0 524 | 95.0 525 | 93.0 526 | 86.0 527 | 86.0 528 | 79.0 529 | 93.0 530 | 99.0 531 | 99.0 532 | 93.0 533 | 77.0 534 | 86.0 535 | 73.0 536 | 91.0 537 | 95.0 538 | 99.0 539 | 100.0 540 | 99.0 541 | 91.0 542 | 81.0 543 | 81.0 544 | 79.0 545 | 79.0 546 | 93.0 547 | 88.0 548 | 82.0 549 | 88.0 550 | 84.0 551 | 86.0 552 | 82.0 553 | 93.0 554 | 90.0 555 | 84.0 556 | 90.0 557 | 95.0 558 | 90.0 559 | 88.0 560 | 86.0 561 | 77.0 562 | 88.0 563 | 88.0 564 | 90.0 565 | 88.0 566 | 84.0 567 | 84.0 568 | 86.0 569 | 88.0 570 | 86.0 571 | 84.0 572 | 90.0 573 | 91.0 574 | 91.0 575 | 90.0 576 | 81.0 577 | 84.0 578 | 79.0 579 | 84.0 580 | 93.0 581 | 93.0 582 | 91.0 583 | 88.0 584 | 88.0 585 | 91.0 586 | 90.0 587 | 91.0 588 | 90.0 589 | 88.0 590 | 93.0 591 | 86.0 592 | 84.0 593 | 84.0 594 | 82.0 595 | 81.0 596 | 82.0 597 | 88.0 598 | 84.0 599 | 77.0 600 | 86.0 601 | 91.0 602 | 86.0 603 | 90.0 604 | 84.0 605 | 81.0 606 | 88.0 607 | 88.0 608 | 82.0 609 | 84.0 610 | 82.0 611 | 82.0 612 | 88.0 613 | 88.0 614 | 88.0 615 | 75.0 616 | 77.0 617 | 77.0 618 | 82.0 619 | 84.0 620 | 81.0 621 | 84.0 622 | 88.0 623 | 75.0 624 | 84.0 625 | 79.0 626 | 77.0 627 | 77.0 628 | 82.0 629 | 75.0 630 | 68.0 631 | 72.0 632 | 81.0 633 | 86.0 634 | 82.0 635 | 70.0 636 | 77.0 637 | 68.0 638 | 81.0 639 | 77.0 640 | 82.0 641 | 73.0 642 | 75.0 643 | 70.0 644 | 72.0 645 | 66.0 646 | 61.0 647 | 55.0 648 | 68.0 649 | 70.0 650 | 59.0 651 | 66.0 652 | 70.0 653 | 70.0 654 | 70.0 655 | 68.0 656 | 70.0 657 | 55.0 658 | 61.0 659 | 66.0 660 | 57.0 661 | 59.0 662 | 68.0 663 | 64.0 664 | 64.0 665 | 63.0 666 | 66.0 667 | 73.0 668 | 72.0 669 | 66.0 670 | 66.0 671 | 70.0 672 | 64.0 673 | 54.0 674 | 54.0 675 | 59.0 676 | 55.0 677 | 54.0 678 | 55.0 679 | 34.0 680 | 43.0 681 | 52.0 682 | 57.0 683 | 54.0 684 | 61.0 685 | 63.0 686 | 61.0 687 | 52.0 688 | 54.0 689 | 55.0 690 | 48.0 691 | 50.0 692 | 48.0 693 | 45.0 694 | 39.0 695 | 46.0 696 | 55.0 697 | 55.0 698 | 55.0 699 | 50.0 700 | 48.0 701 | 45.0 702 | 43.0 703 | 50.0 704 | 55.0 705 | 55.0 706 | 55.0 707 | 50.0 708 | 54.0 709 | 50.0 710 | 43.0 711 | 39.0 712 | 48.0 713 | 52.0 714 | 37.0 715 | 39.0 716 | 46.0 717 | 37.0 718 | 41.0 719 | 30.0 720 | 41.0 721 | 48.0 722 | 57.0 723 | 45.0 724 | 43.0 725 | 30.0 726 | 28.0 727 | 23.0 728 | 32.0 729 | 46.0 730 | 43.0 731 | 41.0 732 | 45.0 733 | 39.0 -------------------------------------------------------------------------------- /382.ПредсказаниеПогоды/ПредсказаниеПогоды.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "В данной задаче мы пытаемся предсказывать временные ряды. Я, к сожалению, не настолько осведомлен в них, насколько хотелось бы, поэтому далее я выскажу некоторые предположения полученные в поисках решения. Я немного знаком с авторегрессионными моделями и с удовольствием бы применил одну из библиотек в этой задаче, но ни одной из них не представлено в предоставляемом комплияторе. В связи с чем для предсказания погоды в следующий день использовались данные с лагом в два дня (т.е. за два предыдущих дня) с различными весами. А затем полученные значения корректировались с учетом \"сезонности\" в 365 дня, т.е. полученное значение использовалось с весом 0.9, а значение, которое было год назад с весом 0.1. Это позволило достичь необходимого качества модели." 7 | ], 8 | "metadata": { 9 | "collapsed": false 10 | } 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "outputs": [], 16 | "source": [ 17 | "n = int(input())\n", 18 | "\n", 19 | "data = []\n", 20 | "for i in range(n):\n", 21 | " data.append(float(input()))\n", 22 | "\n", 23 | "m = int(input())\n", 24 | "\n", 25 | "for i in range(m):\n", 26 | " alpha = 0.95\n", 27 | " betta = 0.9\n", 28 | " new_temp = data[-1] * alpha + (1 - alpha) * data[-2]\n", 29 | " new_temp = betta * new_temp + (1 - betta) * data[i]\n", 30 | " print(new_temp)\n", 31 | " real_temp = float(input())\n", 32 | " data.append(real_temp)" 33 | ], 34 | "metadata": { 35 | "collapsed": false 36 | } 37 | } 38 | ], 39 | "metadata": { 40 | "kernelspec": { 41 | "display_name": "Python 3", 42 | "language": "python", 43 | "name": "python3" 44 | }, 45 | "language_info": { 46 | "codemirror_mode": { 47 | "name": "ipython", 48 | "version": 2 49 | }, 50 | "file_extension": ".py", 51 | "mimetype": "text/x-python", 52 | "name": "python", 53 | "nbconvert_exporter": "python", 54 | "pygments_lexer": "ipython2", 55 | "version": "2.7.6" 56 | } 57 | }, 58 | "nbformat": 4, 59 | "nbformat_minor": 0 60 | } 61 | -------------------------------------------------------------------------------- /384.ЗвездныеКарты2.0/ЗвездныеКарты2.0.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "source": [ 6 | "Данная задача чем-то похожа на CBIR, если говорить понятным языком, то на поиск в Яндексе по картинке других похожих изображений, или текста связанного с изображением. Подобные задачи решаются с помощью представления исходного изображения в виде вектора в некотором пространстве меньшей размерности, так называемый embedding. Затем эмбеддинги сравниваются и находят ближайшие к нему, это и будут похожие изображения.\n", 7 | "В нашем случае изображения кодируются с помощью CLIP от OpenAI, а затем полученные эмбеддинги кластеризуются с помощью AgglomerativeClustering из sklearn. Можно попробовать другие методы кодирования и кластеризации, они тоже работают. (но не все, старушка VGG-19 у меня не сработала, то ли вектора взял большие 4000 признаков, то ли в целом сеть старовата и не смогла)" 8 | ], 9 | "metadata": { 10 | "collapsed": false 11 | } 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "outputs": [ 17 | { 18 | "name": "stderr", 19 | "output_type": "stream", 20 | "text": [ 21 | "E:\\anaconda3\\envs\\with_torch_cuda\\lib\\site-packages\\torch\\serialization.py:799: UserWarning: 'torch.load' received a zip file that looks like a TorchScript archive dispatching to 'torch.jit.load' (call 'torch.jit.load' directly to silence this warning)\n", 22 | " warnings.warn(\"'torch.load' received a zip file that looks like a TorchScript archive\"\n" 23 | ] 24 | } 25 | ], 26 | "source": [ 27 | "import torch\n", 28 | "import clip\n", 29 | "from PIL import Image\n", 30 | "\n", 31 | "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", 32 | "model, preprocess = clip.load(\"ViT-B/32\", device=device, download_root='E:\\clip')" 33 | ], 34 | "metadata": { 35 | "collapsed": false 36 | } 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 2, 41 | "outputs": [ 42 | { 43 | "name": "stderr", 44 | "output_type": "stream", 45 | "text": [ 46 | "100%|██████████| 9605/9605 [02:00<00:00, 79.74it/s] \n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "import torch\n", 52 | "import clip\n", 53 | "from PIL import Image\n", 54 | "\n", 55 | "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", 56 | "model, preprocess = clip.load(\"ViT-B/32\", device=device, download_root='E:\\clip')\n", 57 | "\n", 58 | "import os\n", 59 | "\n", 60 | "images = [i for i in os.listdir('dataset')]\n", 61 | "from tqdm import tqdm\n", 62 | "features_2 = []\n", 63 | "for i in tqdm(range(len(images))):\n", 64 | " path = images[i]\n", 65 | " image = preprocess(Image.open('dataset/'+path)).unsqueeze(0).to(device)\n", 66 | " with torch.no_grad():\n", 67 | " image_features = model.encode_image(image)\n", 68 | " features_2.append(image_features.detach().cpu().numpy())\n", 69 | "\n", 70 | "from sklearn.decomposition import PCA\n", 71 | "import numpy as np\n", 72 | "\n", 73 | "pca = PCA(n_components=300)\n", 74 | "X = pca.fit_transform(np.array(features_2).squeeze())\n", 75 | "\n", 76 | "\n", 77 | "from sklearn.cluster import AgglomerativeClustering\n", 78 | "\n", 79 | "clf = AgglomerativeClustering(n_clusters=983)\n", 80 | "clf.fit(X)\n", 81 | "\n", 82 | "import pandas as pd\n", 83 | "\n", 84 | "res = pd.DataFrame(columns=['filename','label'])\n", 85 | "res['filename'] = images\n", 86 | "res['label'] = clf.labels_\n", 87 | "res.to_csv('submit.csv',index=None)" 88 | ], 89 | "metadata": { 90 | "collapsed": false 91 | } 92 | } 93 | ], 94 | "metadata": { 95 | "kernelspec": { 96 | "display_name": "Python 3", 97 | "language": "python", 98 | "name": "python3" 99 | }, 100 | "language_info": { 101 | "codemirror_mode": { 102 | "name": "ipython", 103 | "version": 2 104 | }, 105 | "file_extension": ".py", 106 | "mimetype": "text/x-python", 107 | "name": "python", 108 | "nbconvert_exporter": "python", 109 | "pygments_lexer": "ipython2", 110 | "version": "2.7.6" 111 | } 112 | }, 113 | "nbformat": 4, 114 | "nbformat_minor": 0 115 | } 116 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CodeRun ML-track 1st season solutions 2 | 3 | Этот репозиторий содержит решения всех задач ML-трека 1 сезона CodeRun, а также небольшие текстовые разборы решений и подсказки к решениям. 4 | 5 | Мне довелось поучаствовать в данном соревновании и достичь неплохих результатов. Топ-5, в котором мой результат выделен зеленым: 6 | ml_results 7 | 8 | 9 | Ниже я постарался написать небольшие подсказки/темы для изучения, которые помогут в решении и понимании конкретной задачи. Сами решения и их короткие описания вы сможете найти в jupyter-блокнотах внутри соответствующих папок. 10 | Нумерация задач в репозитории соответствует нумерации в системе CodeRun на момент создания репозитория. 11 | 12 | Хочу отдельно поблагодарить всех, кто участвовал в обсуждениях задач, подсказывал и направлял, коллег и организаторов CodeRun. 13 | 14 | Быстрые переходы к подсказкам по задачам и ссылкам на решения: 15 | 16 | - [156. Опечатки (средняя)](#156-опечатки) 17 | - [161. Генератор точек в круге (средняя)](#161-генератор-точек-в-круге) 18 | - [163. Сумма на гранях (средняя)](#163-сумма-на-гранях) 19 | - [171. Коллекция статуэток (средняя)](#171-коллекция-статуэток) 20 | - [177. Тайна египетских пирамид (средняя)](#177-тайна-египетских-пирамид) 21 | - [178. Решающий пень (легкая)](#178-решающий-пень) 22 | - [184. Восстановление коэффициентов (легкая)](#184-восстановление-коэффициентов) 23 | - [200. Разминка (средняя)](#200-разминка) 24 | - [207. Обобщённый AUC (средняя)](#207-обобщённый-auc) 25 | - [209. Перестановки (средняя)](#209-перестановки) 26 | - [214-327. Рестораны и Рестораны 2.0 (сложная)](#214-327-рестораны) 27 | - [221. Линейно разделимая выборка (средняя)](#221-линейно-разделимая-выборка) 28 | - [224. Уникальные запросы (средняя)](#224-уникальные-запросы) 29 | - [233. Ранжирование по парам (средняя)](#233-ранжирование-по-парам) 30 | - [240. Монетки (средняя)](#240-монетки) 31 | - [243. Рекомендательная система SVD (средняя)](#243-рекомендательная-система-svd) 32 | - [262. Лента рекомендаций (сложная)](#262-лента-рекомендаций) 33 | - [266. Кластеризация символьных последовательностей (сложная)](#266-кластеризация-символьных-последовательностей) 34 | - [271. Интерполяция (средняя)](#271-интерполяция) 35 | - [282. D-Cov-3999 (средняя)](#282-d-cov-3999) 36 | - [283. Канатная дорога (легкая)](#283-канатная-дорога) 37 | - [288. Оптимальная константа (легкая)](#288-оптимальная-константа) 38 | - [297. Исчезнувшая (средняя)](#297-исчезнувшая) 39 | - [301. Бутылки рома (средняя)](#301-бутылки-рома) 40 | - [312. Иннокентий и друзья (сложная)](#312-иннокентий-и-друзья) 41 | - [314. Оптимальная константа 2.0 (легкая)](#314-оптимальная-константа-2-0) 42 | - [318. Многорукий бандит (сложная)](#318-многорукий-бандит) 43 | - [322. Безградиентная оптимизация функции (средняя)](#322-безградиентная-оптимизация-функции) 44 | - [373. Омографы (сложная)](#373-омографы) 45 | - [382. Предсказание погоды (средняя)](#382-предсказание-погоды) 46 | - [384. Звёздные карты 2.0 (средняя)](#384-звёздные-карты-20) 47 | 48 | # 156. Опечатки 49 | 50 | - Подумайте как получить одно слово из другого с заданным набором ошибок, если знаем, что ошибка только одна. 51 | - На втором шаге начальных слов просто больше чем было на первом этапе с 1 ошибкой. 52 | - Необязательно идти от одного слова к другому, можно заставить их идти навстречу друг другу. 53 | 54 | [Решение](156.Опечатки/Опечатки.ipynb) 55 | # 161. Генератор точек в-круге 56 | 57 | - Визуализируйте некоторое среднее количество точек (100 - мало, 100 000 - много) на двух разных графиках и посмотрите что различается. 58 | - Проверьте статистики выборок генерируемых 1 и 2 генераторами, можно попробовать построить доверительные интервалы для них. 59 | 60 | [Решение](161.ГенераторТочекВКруге/ГенераторТочекВКруге.ipynb) 61 | # 163. Сумма на гранях 62 | 63 | - Решение можно вывести аналитически. 64 | - Попробуйте порисовать решения для простых вариантов. Что меняется при усложнении? При увеличении k? Что если $a_1=a_2=...=a_6$, а в других случаях? 65 | 66 | [Решение](163.СуммаНаГранях\СуммаНаГранях.ipynb) 67 | # 171. Коллекция статуэток 68 | 69 | - Почитайте про скользящее окно. 70 | 71 | Вот несколько ссылок на задачи, которые могут помочь в решении: 72 | - [Самая длинная подстрока без повторения символов.](https://leetcode.com/problems/longest-substring-without-repeating-characters/) 73 | - [Подмассивы с K различными целыми числами.](https://leetcode.com/problems/subarrays-with-k-different-integers/) 74 | 75 | [Решение](171.КоллекцияСтатуэток/КоллекцияСтатуэток.ipynb) 76 | # 177. Тайна египетских пирамид 77 | 78 | - Внимательно изучите линейную регрессию для простейших случаев. Как там восстанавливаются коэффициенты? 79 | - Необязательно считать производные аналитически, когда существуют численные методы. 80 | - Посмотрите библиотеку scipy.optimize. 81 | 82 | [Решение](177.ТайнаЕгипетскихПирамид/ТайнаЕгипетскихПирамид.ipynb) 83 | # 178. Решающий пень 84 | 85 | - Какие значения считаются оптимальными, когда в лист решающего дерева для регрессии попадает несколько объектов (для MSE)? Тогда какие a и b? 86 | - Как быстро считать ошибку для левой и правой выборок (относительно C) при перемещении элемента из одной выборки в другую? 87 | - Остается пройтись по всем числам и выбрать параметры для минимальных значений ошибок. 88 | 89 | [Решение](178.РешающийПень\РешающийПень.ipynb) 90 | # 184. Восстановление коэффициентов 91 | 92 | - Внимательно изучите линейную регрессию для простейших случаев. Как там восстанавливаются коэффициенты? 93 | - Необязательно считать производные аналитически, когда существуют численные методы. 94 | - Посмотрите библиотеку scipy.optimize. 95 | 96 | [Решение](184.ВосстановлениеКоэффициентов/ВосстановлениеКоэффицентов.ipynb) 97 | # 200. Разминка 98 | 99 | - Линейная регрессия. 100 | 101 | [Решение](200.Разминка/Разминка.ipynb) 102 | # 207. Обобщённый AUC 103 | 104 | - Может пройти $O(N^2)$, но прямой полный перебор не пройдёт. Необходимо чуть "умнее" выбирать сколько элементов меньше, сколько равны. 105 | 106 | Подсказки от [Муравьева Вячелава](https://github.com/Slamur/) из команды организаторов (ожидавшееся авторское решение за O(Nlog(N))): 107 | 108 | В задаче требуется найти количество пар i, j таких, что 109 | - $t[i] < t[j]$ 110 | - $y[i] < y[j]$ или $y[i] = y[j]$ (отдельные вычисления) 111 | 112 | Сначала решим задачу про $y[i] = y[j]$ 113 | - Допустим, что все y равны между собой. Как найти количество пар эффективнее $O(N^2)$? 114 | - Пусть все $Т$ уникальны и отсортированы по неубыванию. Сколько элементов образуют пару с $t[i]$? Где расположены эти элементы? 115 | - А как изменяется задача, когда есть равные $Т$? 116 | - Как относится задача с одинаковыми $Y$ к оригинальной задаче? 117 | 118 | Теперь для $y[i] < y[j]$: 119 | - Заменим $y[i]$ на $-y[i]$ (теперь ищем $t[i] < t[j]$, $y[i] > y[j]$). Напоминает ли это какую-то известную задачу? 120 | - Допустим, что все $Т$ уникальны. Отсортируем пары $(T, Y)$ по неубыванию $Т$ и перенумеруем. 121 | В таком случае задача свелась к количеству пар ($i < j$, $y[i] > y[j]$) - инверсий в массиве. 122 | - Как изменить алгоритм поиска с учетом неуникальности $Т$? Может быть выбрать какое-то правило сравнения $Y$ при равенстве $T$? 123 | 124 | 125 | Немного про поиск количества инверсий: 126 | - Пусть у вас есть два отсортированных по возрастанию массива $А$ и $B$. Как за $O(N)$ получить отсортированный массив, являющийся объединением $А$ и $B$? 127 | - А как найти количество пар $(i, j)$ таких, что $A[i] > B[j]$ за $O(|A| + |B|)$ в процессе объединения? 128 | - Пусть $B[k] < A[i] <= B[k + 1]$. Сколько в таком случае пар $A[i] > B[j]$? 129 | - Пусть массивы $A$ и $B$ - левая и правая половины массива Y. Как решить задачу через сведение к подобным? 130 | 131 | [Решение](207.ОбобщенныйAUC/ОбобщенныйAUC.ipynb) 132 | # 209. Перестановки 133 | 134 | - Обычные статистики не сработают. 135 | - Частоты появлений символов важны, визуализация и heatmap. 136 | 137 | [Решение](209.Перестановки/Перестановки.ipynb) 138 | # 214-327. Рестораны 139 | 140 | - Достаточно минимизации функционала потерь известными методами. 141 | - Формы распределений признаков важны для высокого качества. 142 | 143 | [Решение](214-327.Рестораны-Рестораны2/Рестораны.ipynb) 144 | # 221. Линейно разделимая выборка 145 | 146 | - Какой алгоритм машинного обучения строит разделяющие гиперплоскости? 147 | - Будет достаточно известных реализаций этого алгоритма. 148 | 149 | [Решение](221.ЛинейноРазделимаяВыборка/ЛинейноРазделимаяВыборка.ipynb) 150 | # 224. Уникальные запросы 151 | 152 | - Эффективная оценка мощности большого множества 153 | - HyperLogLog для множеств бОльших размерностей, на заданном диапазоне у него большая ошибка. 154 | - [В этой статье хорошо описаны различные алгоритмы для оценки мощности множества.](https://habr.com/ru/companies/vk/articles/711126/) 155 | 156 | [Решение](224.УникальныеЗапросы/УникальныеЗапросы.ipynb) 157 | # 233. Ранжирование по парам 158 | 159 | - Метод максимального правдоподобия. 160 | - Логистическая регрессия через матричные представления. 161 | 162 | [Решение](233.РанжированиеПоПарам/РанжированиеПоПарам.ipynb) 163 | # 240. Монетки 164 | 165 | - Необходимо предсказывать не частоту, а вероятность, что следующее испытание закончится успехом 166 | - Правило Лапласа 167 | 168 | [Решение](240.Монетки/Монетки.ipynb) 169 | # 243. Рекомендательная система SVD 170 | 171 | - Simon Funk и его подход в ML соревновании от Netflix. 172 | - SVD для рекомендаций и градиентный спуск. 173 | - Библиотека surprise (в компиляторе её нет, но формулы внутри её документации полезны) 174 | 175 | [Решение](243.РекомендательнаяСистемаSVD/РекомендательнаяСистемаSVD.ipynb) 176 | # 262. Лента рекомендаций 177 | 178 | - Жадного подхода достаточно 179 | 180 | [Решение](262.ЛентаРекомендаций/ЛентаРекомендаций.ipynb) 181 | # 266. Кластеризация символьных последовательностей 182 | 183 | - EM-алгоритм 184 | - Цепи Маркова 185 | - Обычные методы кластеризации вряд ли сработают (у меня не сработали) 186 | 187 | [Решение](266.КластеризацияСимвольныхПоследовательностей/КластеризацияСимвольныхПоследовательностей.ipynb) 188 | # 271. Интерполяция 189 | 190 | - PolynomialFeatures 191 | - Линейной регрессии должно хватить 192 | 193 | [Решение](271.Интерполяция/Интерполяция.ipynb) 194 | # 282. D-CoV-3999 195 | 196 | - Представьте как бы вы это делали в реальной жизни, как бы вы организовали для себя эту задачу? 197 | - В каком формате было бы удобно иметь данные? 198 | - Правильная организация данных и выбор структур данных - ключ к решению 199 | 200 | [Решение](282.D-CoV-3999/D-CoV-3999.ipynb) 201 | # 283. Канатная дорога 202 | 203 | kanatnaya_doroga 204 | 205 | - Изображение выше должно помочь в понимании условия. Черным нарисован силуэт хребта, а зеленым все трассы, которые необходимо построить. 206 | 207 | !ВНИМАНИЕ ДАЛЬНЕЙШЕЕ ОБЪЯСНЕНИЕ НЕ СВЯЗАНО С РИСУНКОМ, НА РИСУНКЕ ЗАТРОНУТО БОЛЬШЕЕ КОЛИЧЕСТВО СЛУЧАЕВ ДЛЯ ЛУЧШЕГО ПОНИМАНИЯ ЗАДАЧИ 208 | 1. Все подряд идущие вершины соединены друг с другом (не важно больше следующая вершина или меньше, они соединены) 209 | 2. Дополнительно каждая вершина соединена со следующей НЕ меньшей по высоте, то есть большей либо равной по высоте. То есть у нас есть вершины 1-2-3, 1 вершина больше 2, но меньше 3. Получается впадина с вершиной 2 внизу. Мы соединяем последовательно вершины 1-2-3, а также дополнительно соединяем вершины 1 и 3. 210 | 211 | [Решение](283.КанатнаяДорога/КанатнаяДорога.ipynb) 212 | # 288. Оптимальная константа 213 | 214 | - Константы для MSE и MAE широко известны, в интернете много информации. 215 | - Что будет если вынести $\frac{1}{y_i}$ и представить в некотором другом виде? Заменить на $w_i$? Какая формула у нас получится? 216 | 217 | [Решение](288.ОптимальнаяКонстанта/ОптимальнаяКонстанта.ipynb) 218 | # 297. Исчезнувшая 219 | 220 | - Хэширование позволит быстрее сравнивать строки. 221 | - Полиномиальное хэширование (лично я не использовал, но знаю, что решение с оттенками полиномиального хэширования позволило обойти Time Limit). 222 | - $O(N^4)$ решение не пройдёт) 223 | 224 | [Решение](297.Исчезнувшая/Исчезнувшая.ipynb) 225 | # 301. Бутылки рома 226 | 227 | - Формула перестановок с повторениями. 228 | - Как теперь получить различные строки, которые удовлетворяют формуле из 1 пункта? Разных длин и так далее. 229 | 230 | Отдельно благодарю [Алексея Маслова](https://github.com/MaslovAleksey) за активное обсуждение данной задачи и идей её решения. 231 | 232 | [Решение](301.БутылкиРома/БутылкиРома.ipynb) 233 | # 312. Иннокентий и друзья 234 | 235 | - Задача на рекомендательные системы. 236 | - Проходит решение с использованием любых библиотек для рекомендательных систем, без каких-то сложностей. 237 | - Может пройти и простой вариант рекомендаций) Какие бы рестораны вы рекомендовали всем без какого-то особого индивидуального подхода? 238 | 239 | [Решение](312.ИннокентийИДрузья/ИннокентийИДрузья.ipynb) 240 | # 314. Оптимальная константа 2.0 241 | 242 | - Выделите самое важное в условиях, убрав всё лишнее. Попробуйте посмотреть на задачу, как на задачу 288. Оптимальная константа 243 | - Как минимизируется любая функция? 244 | - Функция потерь - это тоже функция, её также можно минимизировать и выразить оптимальную константу через элементы выборки. 245 | 246 | [Решение](314.ОптимальнаяКонстанта2/ОптимальнаяКонстанта2.ipynb) 247 | # 318. Многорукий бандит 248 | 249 | - Известная задача, её разборы представлены в статьях, в книгах и так далее. 250 | - Слова про бета-распределение намекают на Томпсоновское сэмплирование и Байесовскую статистику, но вроде бы могут пройти и более простые для понимания решения (я не проверял). 251 | - [Одна из статей, рассказывающая про задачу и варианты решения](https://habr.com/ru/articles/689364/) 252 | 253 | [Решение](318.МногорукийБандит/МногорукийБандит.ipynb) 254 | # 322. Безградиентная оптимизация функции 255 | 256 | - Максимум превращается в минимум добавлением минуса. 257 | - Минимизация функций есть в библиотеке scipy, остается правильно выбрать методы и правильно настроить, чтобы не нарушать условия задачи. 258 | 259 | [Решение](322.БезградиентнаяОптимизация/БезградиентнаяОптимизацияФункции.ipynb) 260 | # 373. Омографы 261 | 262 | transformers 263 | 264 | - Классификация под соусом NLP. 265 | - У меня без ruBERT не обошлось, но можно и (относительно) проще, работая только с эмбеддингами. 266 | 267 | [Решение](373.Омографы/Омографы.ipynb) 268 | # 382. Предсказание погоды 269 | 270 | - Я знаком со временными рядами лишь в общих красках, но именно на них необходимо делать упор в данной задаче. Регрессии и прочее работают хуже в тестах к данной задаче и дают Wrong Answer. 271 | - Пара лагов и память о далеком прошлом должны помочь. 272 | 273 | Отдельно благодарю [Евдакова Алексея](https://github.com/eae-rus/) за активное обсуждение данной задачи и идей её решения. 274 | 275 | [Решение](382.ПредсказаниеПогоды/ПредсказаниеПогоды.ipynb) 276 | # 384. Звёздные карты 2.0 277 | 278 | - Content-based image retrieval. 279 | - Image embeddings. 280 | - Лучше выбирать более свежие сетки для эмбеддингов. 281 | - Существуют предобученные энкодеры изображений. 282 | - Подойдет любой (или почти) алгоритм кластеризации. 283 | 284 | [Решение](384.ЗвездныеКарты2.0/ЗвездныеКарты2.0.ipynb) 285 | -------------------------------------------------------------------------------- /extra_data/kanat_explanation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Frow4s/coderun_ml_first_season/02e88d3b00e085e352ecfa6fce1b2a5871fcf315/extra_data/kanat_explanation.jpg -------------------------------------------------------------------------------- /extra_data/ml_coderun_result.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Frow4s/coderun_ml_first_season/02e88d3b00e085e352ecfa6fce1b2a5871fcf315/extra_data/ml_coderun_result.png -------------------------------------------------------------------------------- /extra_data/transformers.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Frow4s/coderun_ml_first_season/02e88d3b00e085e352ecfa6fce1b2a5871fcf315/extra_data/transformers.jpg --------------------------------------------------------------------------------