{"id":22939090,"url":"https://github.com/imtjl/fp-euler-project","last_synced_at":"2025-04-01T19:49:12.554Z","repository":{"id":257866207,"uuid":"868153714","full_name":"Imtjl/fp-euler-project","owner":"Imtjl","description":"Introduction to functional programming in Elixir","archived":false,"fork":false,"pushed_at":"2024-10-15T18:21:27.000Z","size":373,"stargazers_count":0,"open_issues_count":1,"forks_count":0,"subscribers_count":0,"default_branch":"master","last_synced_at":"2025-03-15T23:32:10.661Z","etag":null,"topics":["elixir","functional-programming"],"latest_commit_sha":null,"homepage":"","language":"Elixir","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Imtjl.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-10-05T16:03:30.000Z","updated_at":"2024-11-21T01:35:38.000Z","dependencies_parsed_at":"2024-10-16T20:38:24.326Z","dependency_job_id":null,"html_url":"https://github.com/Imtjl/fp-euler-project","commit_stats":null,"previous_names":["imtjl/fp-euler-project-lab1","imtjl/fp-euler-project"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Imtjl%2Ffp-euler-project","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Imtjl%2Ffp-euler-project/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Imtjl%2Ffp-euler-project/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Imtjl%2Ffp-euler-project/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Imtjl","download_url":"https://codeload.github.com/Imtjl/fp-euler-project/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":246706025,"owners_count":20820783,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["elixir","functional-programming"],"created_at":"2024-12-14T12:42:42.121Z","updated_at":"2025-04-01T19:49:12.531Z","avatar_url":"https://github.com/Imtjl.png","language":"Elixir","readme":"\u003cp align=\"center\"\u003e\n  \u003ca href=\"https://github.com/Imtjl/fp-euler-project-lab1\"\u003e\n    \u003cpicture\u003e\n      \u003cimg src=\"resources/logo.png\" height=\"200\"\u003e\n    \u003c/picture\u003e\n    \u003ch1 align=\"center\"\u003e\n        Лабораторная работа №1 (Проект Эйлера)\n    \u003c/h1\u003e   \n  \u003c/a\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\"\u003e  \n \u003ca aria-label=\"Elixir Version\" href=\"https://elixir-lang.org/\"\u003e\n  \u003cimg alt=\"Elixir Version\" src=\"https://img.shields.io/badge/Elixir-1.15.7-purple?style=for-the-badge\u0026labelColor=000000\u0026logo=elixir\u0026logoColor=white\"\u003e\n\u003c/a\u003e\n  \u003ca aria-label=\"Erlang/OTP Version\" href=\"https://www.erlang.org/\"\u003e\n    \u003cimg alt=\"Erlang/OTP Version\" src=\"https://img.shields.io/badge/Erlang%2FOTP-26.0-red?style=for-the-badge\u0026labelColor=000000\"\u003e\n  \u003c/a\u003e\n  \u003ca aria-label=\"Elixir CI\" href=\"https://github.com/Imtjl/fp-euler-project-lab1/actions\"\u003e\n    \u003cimg alt=\"Elixir CI\" src=\"https://img.shields.io/github/actions/workflow/status/Imtjl/fp-euler-project-lab1/ci.yml?branch=master\u0026style=for-the-badge\u0026logo=github-actions\u0026labelColor=000000\u0026color=brightgreen\"\u003e\n  \u003c/a\u003e\n  \u003ca aria-label=\"Repo size\" href=\"https://github.com/Imtjl/fp-euler-project-lab1\"\u003e\n    \u003cimg alt=\"\" src=\"https://img.shields.io/github/repo-size/Imtjl/fp-euler-project-lab1?style=for-the-badge\u0026logo=github\u0026labelColor=000000\u0026color=008080\"\u003e\n  \u003c/a\u003e\n\u003c/p\u003e\n  \n\u003cdetails open\u003e\n   \u003csummary\u003e\u003cb\u003eTable of Contents\u003c/b\u003e\u003c/summary\u003e\n\n- [Title](#title)\n- [Test coverage](#tc)\n- [Task 9](#task9)\n- [Task 21](#task21)\n- [Conclusion](#end)\n\n\u003c/details\u003e\n\n---\n\n\u003ca id=\"title\"\u003e\u003c/a\u003e\n\n- Студент: `Дворкин Борис Александрович`\n- Группа: `P3331`\n- ИСУ: `368090`\n- Функциональный язык программирования: `Elixir`\n\n---\n\n## Test coverage\n\n\u003ca id=\"tc\"\u003e\u003c/a\u003e\n\n```\n...........\nFinished in 26.6 seconds (0.00s async, 26.6s sync)\n11 tests, 0 failures\nRandomized with seed 71505\n----------------\nCOV    FILE                                        LINES RELEVANT   MISSED\n100.0% //lib/task21/inf_lists_lazy_collections.       38        9        0\n100.0% //lib/task21/modular.ex                        37        7        0\n100.0% //lib/task21/recursion.ex                      32       11        0\n100.0% //lib/task21/sequence.ex                       34        7        0\n100.0% //lib/task21/special_loops.ex                  43       10        0\n100.0% //lib/task21/tail_recursion.ex                 32       11        0\n100.0% //lib/task9/inf_lists_lazy_collections.e       20       10        0\n100.0% //lib/task9/modular.ex                         33        8        0\n 88.8% //lib/task9/recursion.ex                       25        9        1\n100.0% //lib/task9/special_loops.ex                   25        3        0\n 87.5% //lib/task9/tail_recursion.ex                  24        8        1\n[TOTAL]  97.8%\n----------------\n```\n\n\u003ca id=\"task9\"\u003e\u003c/a\u003e\n\n## Проблема №9\n\n---\n\n- Название: `Special Pythagorean Triplet`\n- Описание:  \n   A Pythagorean triplet is a set of three natural numbers, $a \u003c b \u003c c$, for which  \n  $$a^2 + b^2 = c^2$$  \n  For example, $3^2 + 4^2 = 9 + 16 = 25 = 5^2$.  \n  There exists exactly one Pythagorean triplet for which $a + b + c = 1000$.\n- Задание: `Find the product abc.`\n\n---\n\n### Основная идея решения\n\nКонечно, задачу можно банально решить полным перебором, как я и сделал на\nимперативном языке `Python`. Но в функциональных языках принято пользоваться\n_рекурсией_ и _функциями высшего порядка_, а также фильтрацией, генерацией и\nдругими концепциями, поэтому для различных ситуаций пришлось придумать другие\nрешения.\n\nДля рекурсии идея состоит в следующем:\n\nУстановим $a = 1$ и $b = 2$, как обычно вычислим $c = \\text{sum} - a - b$ и\nпроверим, удовлетворяют ли $a$, $b$, $c$ условию Пифагоровой тройки.\n\nТеперь заметим, что $a \u003c b \u003c c$ (по условию), а значит, можно записать условия\nперебора для каждой переменной, а потом просто рекурсивно вызывать функцию, либо\nувеличивая $b$, либо увеличивая $a$, при этом не забывая проверять, что\n$a \u003c b \u003c c$.\n\nА именно:\n\n- если $b \u003c c$, то можно безопасно увеличить $b$ на 1 и вызвать функцию для\n  этого значения.\n  - Так как $c = \\text{sum} - a - b$, то получаем условие\n    $b \u003c \\text{sum} - a - b$.\n- Иначе, это значит, что мы перебрали все возможные значения $b$ для данного\n  $a$, поэтому \"сбрасываем\" значение $b$, делая его на 1 больше, чем $a$, так\n  как $a \u003c b \u003c c$.\n\n### Рекурсивное решение\n\n```elixir\ndefmodule Euler9Recursion do\n@moduledoc \"\"\"\nModule handling recursive implementations for Euler problem 9.\n\"\"\"\ndef find_triplet(sum) do\n  do_find_triplet(1, 2, sum)\nend\n\ndefp do_find_triplet(a, b, sum) when a \u003c sum / 3 do\n  c = sum - a - b\n\n  cond do\n    a * a + b * b == c * c -\u003e\n      a * b * c\n\n    b \u003c sum - a - b -\u003e\n      do_find_triplet(a, b + 1, sum)\n\n    true -\u003e\n      do_find_triplet(a + 1, a + 2, sum)\n  end\nend\n\ndefp do_find_triplet(_, _, _), do: nil\nend\n```\n\n### Решение с хвостовой рекурсией\n\n- то есть особого вида рекурсией, где любой рекурсивный вызов - последний перед\n  возвратом из функции, что позволяет выполнять `tail call optimisation`\n\n```elixir\ndefmodule Euler9TailRecursion do\n  @moduledoc \"\"\"\n  Module handling tail-recursive implementations for Euler problem 9.\n  \"\"\"\n  def find_triplet(sum) do\n    do_find_triplet(1, 2, sum)\n  end\n\n  defp do_find_triplet(a, b, sum) when a \u003c sum / 3 do\n    c = sum - a - b\n\n    if a * a + b * b == c * c do\n      a * b * c\n    else\n      if b \u003c sum - a - b do\n        do_find_triplet(a, b + 1, sum)\n      else\n        do_find_triplet(a + 1, a + 2, sum)\n      end\n    end\n  end\n\n  defp do_find_triplet(_, _, _), do: nil\nend\n```\n\n### Модульная реализация (генерация, фильтрация, свёртка)\n\n- Генерация последовательности при помощи отображения (map)\n\n```elixir\ndefmodule Euler9Modular do\n  @moduledoc \"\"\"\n  Module handling Euler problem 9 with clear separation of generation, filtering, and folding.\n  \"\"\"\n\n  def find_triplet(sum) do\n    generate_triplets(sum)\n    |\u003e filter_triplets()\n    |\u003e fold_triplets()\n  end\n\n  defp generate_triplets(sum) do\n    1..(sum - 2)\n    |\u003e Enum.flat_map(fn a -\u003e\n      (a + 1)..(sum - a - 1)\n      |\u003e Enum.map(fn b -\u003e\n        c = sum - a - b\n        {a, b, c}\n      end)\n    end)\n  end\n\n  defp filter_triplets(triplets) do\n    triplets\n    |\u003e Enum.filter(fn {a, b, c} -\u003e a * a + b * b == c * c end)\n  end\n\n  defp fold_triplets(triplets) do\n    Enum.reduce(triplets, nil, fn {a, b, c}, _acc -\u003e\n      a * b * c\n    end)\n  end\nend\n```\n\n- зачем тут flat_map? Если сделать просто map, вот, что будет:\n\n```\n[\n  [{1, 2, 997}, {1, 3, 996}, {1, 4, 995}, ...],\n  [{2, 3, 995}, {2, 4, 994}, {2, 5, 993}, ...],\n  ...\n]\n```\n\nа `flat_map` _выпрямит_, чтобы далее было легко фильтровать каждый кортеж:\n\n```\n[\n  {1, 2, 997},\n  {1, 3, 996},\n  {1, 4, 995},\n  ...\n]\n```\n\n### Решение с использованием специального синтаксиса для циклов (Comprehensions)\n\n```elixir\ndefmodule Euler9ListComp do\n  @moduledoc \"\"\"\n  Provides list comprehension solutions for Project Euler Problem 9.\n  \"\"\"\n\n  @doc \"\"\"\n  Finds the product of the Pythagorean triplet where the sum equals `sum`.\n\n  ## Examples\n\n      iex\u003e Euler9ListComp.find_triplet(1000)\n      31875000\n\n  \"\"\"\n  def find_triplet(sum) do\n    for(\n      a \u003c- 1..(sum - 2),\n      b \u003c- (a + 1)..(sum - a - 1),\n      c = sum - a - b,\n      a * a + b * b == c * c,\n      do: a * b * c\n    )\n    |\u003e Enum.find(fn _product -\u003e true end)\n  end\nend\n```\n\n### Бесконечные потоки чисел, ленивые коллекции\n\n```elixir\ndefmodule Euler9Stream do\n  @moduledoc \"\"\"\n  Module handling lazy collections and infinite lists for Euler problem 9.\n  \"\"\"\n  def find_triplet(sum) do\n    Stream.iterate(1, \u0026(\u00261 + 1))\n    |\u003e Stream.take_while(\u0026(\u00261 \u003c sum / 3))\n    |\u003e Stream.flat_map(fn a -\u003e\n      Stream.iterate(a + 1, \u0026(\u00261 + 1))\n      |\u003e Stream.take_while(\u0026(\u00261 \u003c sum / 2))\n      |\u003e Stream.map(fn b -\u003e\n        c = sum - a - b\n        {a, b, c}\n      end)\n    end)\n    |\u003e Stream.filter(fn {a, b, c} -\u003e a * a + b * b == c * c end)\n    |\u003e Enum.map(fn {a, b, c} -\u003e a * b * c end)\n    |\u003e Enum.at(0)\n  end\nend\n```\n\n### Реализация на удобном императивном языке (Python)\n\n```elixir\ndef find_pyth_triplet(sum_):\n    for a in range(1, sum_):\n        for b in range(1, sum_):\n            c = 1000 - a - b\n            if a**2 + b**2 == c**2:\n                return a, b, c\n\n\na, b, c = find_pyth_triplet(1000)\nprint(f\"Pythagorean triplet: a = {a}. b = {b}, c = {c}\")\nprint(f\"Product abc = {a * b * c}\")\n```\n\n\u003ca id=\"task21\"\u003e\u003c/a\u003e\n\n## Проблема №21\n\n---\n\n- Название: `Amicable Numbers`\n- Описание:  \n   Let $d(n)$ be defined as the sum of proper divisors of $n$ (numbers less than\n  $n$ which divide evenly into $n$).  \n   If $d(a) = b$ and $d(b) = a$, where $a \\neq b$, then $a$ and $b$ are an\n  amicable pair and each of $a$ and $b$ are called amicable numbers.\n\n  For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44,\n  55, and 110; therefore  \n   $$d(220) = 284.$$  \n   The proper divisors of 284 are 1, 2, 4, 71, and 142; so  \n   $$d(284) = 220.$$\n\n- Задание: `Evaluate the sum of all the amicable numbers under 10000.`\n\n---\n\n### Основная идея решения\n\nВ этой задаче, как и в задаче №9, можно было бы записать большую часть решения,\nт.е. поиск делителей и a - **перебором**, что легко реализовывается на\nимперативном языке вроде Python. Но в функциональном стиле нужно решить задачу с\nиспользованием **рекурсии**, **функций высшего порядка** и различных методов, в\nрезультате чего приходилось придумывать решения в зависимости от подхода.\n\n#### Постановка задачи:\n\nНам нужно найти сумму всех **дружественных чисел** меньше $10000$. Два числа\nсчитаются дружественными, если для них выполняется:\n\n1. $d(a) = b$ — сумма собственных делителей $a$ равна $b$.\n2. $d(b) = a$ — сумма собственных делителей $b$ равна $a$, при этом\n   $a\n   \\neq b$.\n\n#### Общий алгоритм решения:\n\n1. **Функция для нахождения суммы делителей**:\n\n   - Для каждого числа $n$ мы должны найти его собственные делители и вычислить\n     их сумму.\n   - Здесь мы можем использовать подход, где сумма делителей считается с\n     использованием перебора до $\\frac{n}{2}$, так как все делители $n$ меньше\n     или равны половине числа $n$.\n\n2. **Перебор чисел от 2 до 10000**:\n   - Для каждого числа $a$ мы находим сумму его делителей $b = d(a)$.\n   - Если $d(b) = a$ и $a \\neq b$, то $a$ и $b$ — дружественная пара, и мы\n     добавляем оба числа в список дружественных чисел.\n3. **Рекурсивный подход**:\n   - Для рекурсии мы можем написать функцию, которая будет последовательно\n     увеличивать число $n$ от 2 до предела (в нашем случае $10000$), проверять\n     условие дружественности и накапливать сумму дружественных чисел.\n\n#### Рекурсивное решение:\n\nДля рекурсивного решения мы можем разделить задачу на несколько частей:\n\n1. **Основная функция `sum_amicable_numbers(limit)`**:\n\n   - Она инициализирует процесс и вызывает рекурсивную функцию для каждого числа\n     $n$ от 2 до предела $limit$.\n\n2. **Рекурсивная функция `do_sum/3`**:\n\n   - Эта функция принимает текущее число $n$, предел $limit$, и аккумулятор для\n     накопления суммы дружественных чисел.\n   - Если $n$ меньше предела, то:\n     - Вычисляем сумму делителей $d(n)$.\n     - Если $n$ и $d(n)$ образуют дружественную пару, добавляем $n$ в\n       аккумулятор и продолжаем рекурсию для следующего числа $n + 1$.\n   - Когда $n$ достигнет предела, рекурсия завершится и вернётся сумма всех\n     дружественных чисел.\n\n3. **Функция `sum_of_divisors(n)`**:\n   - Она рекурсивно находит сумму собственных делителей числа $n$, перебирая\n     числа от $\\frac{n}{2}$ до 1 и проверяя, делится ли число $n$ на каждый\n     делитель.\n\n### Рекурсивное решение\n\n```elixir\ndefmodule Euler21Recursion do\n  @moduledoc \"\"\"\n  Module handling recursive implementations for Euler problem 21.\n  \"\"\"\n  def sum_amicable_numbers(limit) do\n    do_sum(2, limit, [])\n  end\n\n  defp do_sum(n, limit, acc) when n \u003c limit do\n    sum_div = sum_of_divisors(n)\n\n    if sum_div != n and sum_of_divisors(sum_div) == n do\n      do_sum(n + 1, limit, [n | acc])\n    else\n      do_sum(n + 1, limit, acc)\n    end\n  end\n\n  defp do_sum(_, _, acc), do: Enum.sum(acc)\n\n  defp sum_of_divisors(n), do: sum_of_divisors(n, div(n, 2), 0)\n\n  defp sum_of_divisors(_, i, acc) when i \u003c= 0, do: acc\n\n  defp sum_of_divisors(n, i, acc) do\n    if rem(n, i) == 0 do\n      sum_of_divisors(n, i - 1, acc + i)\n    else\n      sum_of_divisors(n, i - 1, acc)\n    end\n  end\nend\n```\n\n### Решение с хвостовой рекурсией\n\n```elixir\ndefmodule Euler21TailRecursion do\n  @moduledoc \"\"\"\n  Module handling tail-recursive implementations for Euler problem 21.\n  \"\"\"\n  def sum_amicable_numbers(limit) do\n    do_sum(2, limit, 0)\n  end\n\n  defp do_sum(n, limit, acc) when n \u003c limit do\n    sum_div = sum_of_divisors(n)\n\n    if sum_div != n and sum_of_divisors(sum_div) == n do\n      do_sum(n + 1, limit, acc + n)\n    else\n      do_sum(n + 1, limit, acc)\n    end\n  end\n\n  defp do_sum(_, _, acc), do: acc\n\n  defp sum_of_divisors(n), do: sum_of_divisors(n, n - 1, 0)\n\n  defp sum_of_divisors(_, 0, acc), do: acc\n\n  defp sum_of_divisors(n, i, acc) do\n    if rem(n, i) == 0 do\n      sum_of_divisors(n, i - 1, acc + i)\n    else\n      sum_of_divisors(n, i - 1, acc)\n    end\n  end\nend\n```\n\n### Модульная реализация (генерация, фильтрация, свёртка)\n\n```elixir\ndefmodule Euler21Modular do\n  @moduledoc \"\"\"\n  Provides modular solutions for Project Euler Problem 21.\n  \"\"\"\n\n  @doc \"\"\"\n  Sums all amicable numbers below `limit` using modular functions.\n\n  ## Examples\n\n      iex\u003e Euler21Modular.sum_amicable_numbers(10000)\n      31626\n\n  \"\"\"\n  def sum_amicable_numbers(limit) do\n    2..(limit - 1)\n    |\u003e Enum.filter(\u0026amicable?/1)\n    |\u003e Enum.sum()\n  end\n\n  defp amicable?(n) do\n    sum_div = sum_of_divisors(n)\n    sum_div != n and sum_div \u003c limit() and sum_of_divisors(sum_div) == n\n  end\n\n  defp sum_of_divisors(n) do\n    if n \u003e 1 do\n      1..div(n, 2)\n      |\u003e Enum.filter(\u0026(rem(n, \u00261) == 0))\n      |\u003e Enum.sum()\n    else\n      0\n    end\n  end\n\n  defp limit, do: 10_000\nend\n```\n\n### Решение с использованием специального синтаксиса для циклов (Comprehensions)\n\n```elixir\ndefmodule Euler21ListComp do\n  @moduledoc \"\"\"\n  Provides list comprehension solutions for Project Euler Problem 21.\n  \"\"\"\n\n  @doc \"\"\"\n  Sums all amicable numbers below `limit`.\n\n  ## Examples\n\n      iex\u003e Euler21ListComp.sum_amicable_numbers(10000)\n      31626\n\n  \"\"\"\n  def sum_amicable_numbers(limit) do\n    for(\n      n \u003c- 2..(limit - 1),\n      amicable?(n),\n      do: n\n    )\n    |\u003e Enum.sum()\n  end\n\n  defp amicable?(n) do\n    sum_div = sum_of_divisors(n)\n    sum_div != n and sum_div \u003c limit() and sum_of_divisors(sum_div) == n\n  end\n\n  defp sum_of_divisors(n) do\n    if n \u003e 1 do\n      for(\n        i \u003c- 1..div(n, 2),\n        rem(n, i) == 0,\n        do: i\n      )\n      |\u003e Enum.sum()\n    else\n      0\n    end\n  end\n\n  defp limit, do: 10_000\nend\n```\n\n### Бесконечные потоки чисел, ленивые коллекции\n\n```elixir\ndefmodule Euler21Stream do\n  @moduledoc \"\"\"\n  Provides stream-based solutions for Project Euler Problem 21.\n  \"\"\"\n\n  @doc \"\"\"\n  Sums all amicable numbers below `limit` using streams.\n\n  ## Examples\n\n      iex\u003e Euler21Stream.sum_amicable_numbers(10000)\n      31626\n\n  \"\"\"\n  def sum_amicable_numbers(limit) do\n    Stream.iterate(2, \u0026(\u00261 + 1))\n    |\u003e Stream.take_while(\u0026(\u00261 \u003c limit))\n    |\u003e Stream.filter(\u0026amicable?/1)\n    |\u003e Enum.sum()\n  end\n\n  defp amicable?(n) do\n    sum_div = sum_of_divisors(n)\n    sum_div != n and sum_div \u003c limit() and sum_of_divisors(sum_div) == n\n  end\n\n  defp sum_of_divisors(n) do\n    if n \u003e 1 do\n      1..div(n, 2)\n      |\u003e Enum.filter(\u0026(rem(n, \u00261) == 0))\n      |\u003e Enum.sum()\n    else\n      0\n    end\n  end\n\n  defp limit, do: 10_000\nend\n```\n\n### Реализация на удобном императивном языке (Python)\n\n```elixir\ndef sum_div(n):\n    sum = 0\n    for i in range(1, int(n**0.5) + 1):\n        if n % i == 0:\n            sum += i\n            if i != 1 and i != n // i:\n                sum += n // i\n    return sum\n\n\ndef find_amicable_nums(limit):\n    nums = set()\n    for a in range(2, limit):\n        b = sum_div(a)\n        if a != b and sum_div(b) == a:\n            nums.add(a)\n            nums.add(b)\n    return sum(nums)\n\n\nlimit = 10_000\nprint(f\"Amicle numbers sum below {limit} is {find_amicable_nums(limit)}\")\n```\n\n\u003ca id=\"end\"\u003e\u003c/a\u003e\n\n## Вывод\n\nВ ходе данной лабораторной работы я изучил значительную часть документации по\nElixir, познакомился с его типами данных и структурами. Я узнал о разнице между\n`Stream` и `Enum` в контексте ленивых вычислений, а также познакомился с\nконцепцией бесконечных потоков. Меня приятно удивило, что в функциональном\nпрограммировании нет традиционных циклов `for`, и вместо них используются\nрекурсии, свёртывание и другие концепции, что может показаться сложным на первый\nвзгляд, но на самом деле приемлемо после знакомства с различными способами\nреализации, многие из которых мимикрируют под стандартные циклы императивных\nязыков. Я изучил условные операторы, структуру модулей и функций в Elixir, а\nтакже основы синтаксиса, анонимные функции, кложуры и оператор захвата. Решая\nзадачи из проекта Эйлера, я открыл для себя, насколько удобен и эффективен\nElixir.\n\nОсобенно понравилась работа с пайпами и генераторами, а также удобство\nобъявления анонимных функций. Модульная структура языка оказалась интуитивной и\nсистематизированной, глоток свежего воздуха после питона и js(ts), на которых\nпока работаю.\n\nПрочитав первые 100 страниц книги \"Elixir in Action\", я вдохновился не только\nязыком, но и всей инфраструктурой Erlang + OTP. BEAM VM оказалась впечатляющей:\nхотя в исходном коде встречаются \"магические\" числа и незадокументированные\nучастки, виртуальная машина работает гораздо лучше, чем интерпретаторы Python\nили даже Java.\n\nХотел автоматизировать test coverage, посидеть попрофилировать решения, но завяз\nна 100 часов за электротехникой, скажите студофису чтоб убрали 11 предметов\nблин.\n\nТакже если хотите порофлить, в `./common/` лежит демка отчёта в латехе, но чёт я\nподумал что маркдаун лучше проявит себя в долгосрочной перспективе в репозитории\nгитхаба. Это не электротехника :)\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fimtjl%2Ffp-euler-project","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fimtjl%2Ffp-euler-project","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fimtjl%2Ffp-euler-project/lists"}