ElixirでAtCoder ABC384を楽しむ！PythonとRustと比較しながら学ぶ

# はじめに

プログラミングのスキルを向上させるために、私は現在、[AtCoder](https://atcoder.jp/)のABC問題に挑戦しています。AtCoderは、アルゴリズムやデータ構造を中心にした問題解決能力を磨く場であり、自分との闘いでもあります。挑戦を通じてアントニオ猪木さんがおっしゃった「闘魂とは己に打ち克つこと、そして闘いを通じて己の魂を磨いていくこと」を体現する一つの活動と捉えています。

今回の取り組みでは、得意な[Elixir](https://elixir-lang.org/)を使って自力で正解を導き出すことを第一目標としています。そして、その解答を生成AIである[GitHub Copilot](https://github.com/features/copilot)の助けを借りて、PythonとRustに変換し、それぞれの言語での書き方を比較しながら学んでいます。これにより、Elixirの強みを再確認すると同時に、PythonやRustの基本構文や考え方を吸収し、近々これらの言語を使用する場面に備えたいと考えています。

学習を続ける上で、単なる文法や基礎の勉強は退屈に感じることがあります。そのため、ABC問題という実践的な課題に取り組むことで、楽しさを感じながら知識を深める工夫をしています。繰り返し取り組むことで、最終的にPythonやRustでコードを書けるようになるのではないかという目論見を持っていますが、結果がどうなるかはまだわかりません。それでも「とりあえずやってみる」という精神で挑戦を続けています。

この取り組みを通じて、単にプログラミングスキルを磨くだけでなく、自分の成長を実感できる過程を楽しみたいと思っています。そのドラマにお付き合いください。

## AtCoderとは

AtCoderは、日本発のオンラインプログラミングコンテストプラットフォームで、競技プログラミングの学習や実力を試す場として多くのエンジニアや学生に利用されています。プラットフォーム上では、さまざまなレベルの問題が提供されており、初心者から上級者まで幅広く挑戦することができます。

AtCoderの主な特徴として、以下の点が挙げられます：
- **定期的なコンテスト**: 毎週開催される「AtCoder Beginner Contest (ABC)」や「AtCoder Regular Contest (ARC)」を通じて、問題解決能力を継続的に向上させることができます
- **多彩な問題**: アルゴリズム、データ構造、数学、最適化など、幅広い分野の問題が揃っています
- **ランキングとレーティング**: 参加者の成績に応じてレーティングが変動し、自分の成長を数値として確認することが可能です

特にABCは、初心者向けの問題が中心でありながら、後半の問題はやりごたえのあるものも多く、プログラミングスキルを基礎から応用まで段階的に磨けるのが魅力です。AtCoderは単なる練習の場ではなく、自己成長や目標達成のための重要なステップとして、国内外のエンジニアから高く評価されています。

## AtCoder Beginner Contest (ABC)

AtCoder Beginner Contest (ABC)についての個人の見解です。
順にレベルが上がります。

### A問題

順次、分岐で解けます。

### B問題

順次、分岐に加えて繰り返しを使います。

### C問題

順次、分岐、三重程度の多重繰り返しを使います。

---

コンテストによりその傾向は異なります。
D問題以降は競技プログラミングの訓練が必要です。訓練無しに解ける人は才能があります。うらやましいです。

何を「一般的」と定義するのかは諸説あると思いますが、数学的センスを必要とはしない「一般的な」プログラミングはC問題くらいまでできればなんとかなります。何の自慢にもなりませんが、私はそれで20年以上飯を喰ってきました。そして自分でも気づいている通り、それは何の自慢にもなりませんし、`html`のタグを手打ちするのが当たり前だった牧歌的な時代をだらっとすごしてきた人間の感傷かもしれません。若い人には高みを目指して欲しいと思っています。そしてそんな私を生温かい目で**鑑賞**していただければ幸いです。コラムです。



**ここで述べたのはあくまでも個人の見解です。**

---

# [AtCoder Beginner Contest 384](https://atcoder.jp/contests/abc384)

今回は、[トヨタ自動車プログラミングコンテスト2024#12（AtCoder Beginner Contest 384）](https://atcoder.jp/contests/abc384)に挑戦します。

## [A - aaaadaa](https://atcoder.jp/contests/abc384/tasks/abc384_a)

問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。

<details><summary>私の解答</summary>

### Elixir

```elixir:abc384_a.exs
defmodule Main do
  def main do
    {s, c1, c2} = input()

    solve(s, c1, c2)
    |> IO.puts()
  end

  defp solve(s, c1, c2) do
    s
    |> Enum.reduce([], fn c, acc ->
      do_solve(acc, c, c1, c2)
    end)
    |> Enum.reverse()
    |> List.to_string()
  end

  defp do_solve(list, c1, c1, _c2), do: [c1 | list]
  defp do_solve(list, _c, _c1, c2), do: [c2 | list]

  defp input do
    [_n, c1 ,c2] = IO.read(:line) |> String.trim() |> String.split(" ")
    s = IO.read(:line) |> String.trim()

    {String.to_charlist(s), to_char(c1), to_char(c2)}
  end

  defp to_char(str) do
    String.to_charlist(str) |> Enum.at(0)
  end
end
```

### Python

```python:abc384_a.py
def solve(s: str, c1: str, c2: str) -> str:
    return ''.join(c1 if c == c1 else c2 for c in s)

def main():
    _, c1, c2 = input().split()
    s = input().strip()
    print(solve(s, c1, c2))

main()
```

### Rust

```rust:hello_world/src/bin/abc384_a.rs
use proconio::input;

fn solve(s: &str, c1: char, c2: char) -> String {
    s.chars()
        .map(|c| if c == c1 { c1 } else { c2 })
        .collect()
}

fn main() {
    input! {
        _n: usize,
        c1: char,
        c2: char,
        s: String,
    }
    println!("{}", solve(&s, c1, c2));
}
```

</details>


## [B - ARC Division](https://atcoder.jp/contests/abc384/tasks/abc384_b)

問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。

<details><summary>私の解答</summary>

### Elixir

```elixir:abc384_b.exs
defmodule Main do
  def main do
    {r, list_of_lists} = input()

    solve(r, list_of_lists)
    |> IO.puts()
  end

  defp solve(r, list_of_lists) do
    list_of_lists
    |> Enum.reduce(r, fn [d, a], acc ->
      do_solve(acc, d, a)
    end)
  end

  defp do_solve(r, 1, a) when 1600 <= r and r <= 2799, do: r + a
  defp do_solve(r, 2, a) when 1200 <= r and r <= 2399, do: r + a
  defp do_solve(r, _, _), do: r

  defp input do
    [n, r] =
      IO.read(:line) |> String.trim() |> String.split(" ") |> Enum.map(&String.to_integer/1)

    {r, list_of_lists(n)}
  end

  defp list_of_lists(n) do
    for _ <- 1..n do
      IO.read(:line)
      |> String.trim()
      |> String.split(" ")
      |> Enum.map(&String.to_integer/1)
    end
  end
end
```

### Python

```python:abc384_b.py
def solve(r: int, contests: list) -> int:
    for d, a in contests:
        if (d == 1 and 1600 <= r <= 2799) or (d == 2 and 1200 <= r <= 2399):
            r += a
    return r

def main():
    n, r = map(int, input().split())
    contests = [tuple(map(int, input().split())) for _ in range(n)]
    print(solve(r, contests))


main()
```

### Rust

```rust:hello_world/src/bin/abc384_b.rs
use proconio::input;

fn solve(mut r: i32, contests: &Vec<(i32, i32)>) -> i32 {
    for &(d, a) in contests {
        match d {
            1 if (1600..=2799).contains(&r) => r += a,
            2 if (1200..=2399).contains(&r) => r += a,
            _ => (),
        }
    }
    r
}

fn main() {
    input! {
        n: usize,
        r: i32,
        contests: [(i32, i32); n],
    }
    println!("{}", solve(r, &contests));
}
```


</details>



## [C - Perfect Standings](https://atcoder.jp/contests/abc384/tasks/abc384_c)

問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。

<details><summary>私の解答</summary>

### Elixir

```elixir:abc384_c.exs
defmodule Main do
  def main do
    solve(input(), members())
    |> Enum.join("\n")
    |> IO.puts()
  end

  defp solve(map, members) do
    members
    |> Enum.sort_by(fn list ->
      Enum.reduce(list, 0, fn key, acc -> acc + Map.get(map, key) end)
    end, :desc)
    |> Enum.map(&Enum.join/1)
  end

  defp input do
    [a, b, c, d, e] = IO.read(:line) |> String.trim() |> String.split(" ") |> Enum.map(&String.to_integer/1)

    %{"A" => a, "B" => b, "C" => c, "D" => d, "E" => e}
  end

  defp members do
    5..1//-1
    |> Enum.reduce([], fn i, acc ->
      acc ++ Awesome.combination(["A", "B", "C", "D", "E"], i)
    end)
  end
end

defmodule Awesome do
  def combination(_, 0), do: [[]]
  def combination([], _), do: []

  def combination([x | xs], n) do
    for(y <- combination(xs, n - 1), do: [x | y]) ++ combination(xs, n)
  end
end
```

### Python

```python:abc384_c.py
from itertools import combinations
from typing import Dict, List

def get_all_combinations(elements: List[str]) -> List[List[str]]:
    result = []
    for r in range(len(elements), 0, -1):
        result.extend(combinations(elements, r))
    return result

def solve(values: Dict[str, int], member_combinations: List[List[str]]) -> List[str]:
    def get_sum(members):
        return sum(values[m] for m in members)
    
    return [''.join(members) 
            for members in sorted(member_combinations, 
                                key=get_sum, 
                                reverse=True)]

def main():
    a, b, c, d, e = map(int, input().split())
    values = {'A': a, 'B': b, 'C': c, 'D': d, 'E': e}
    members = get_all_combinations(['A', 'B', 'C', 'D', 'E'])
    
    result = solve(values, members)
    print('\n'.join(result))

main()
```



### Rust

```rust:hello_world/src/bin/abc384_c.rs
use proconio::input;
use std::collections::HashMap;

fn combinations<T: Clone>(elements: &[T], k: usize) -> Vec<Vec<T>> {
    if k == 0 {
        return vec![vec![]];
    }
    if elements.len() < k {
        return vec![];
    }

    let mut result = vec![];
    let mut rest = elements.to_vec();
    let first = rest.remove(0);

    for c in combinations(&rest, k - 1) {
        let mut combination = vec![first.clone()];
        combination.extend(c);
        result.push(combination);
    }
    result.extend(combinations(&rest, k));

    result
}

fn solve(values: HashMap<char, i32>) -> Vec<String> {
    let elements = vec!['A', 'B', 'C', 'D', 'E'];
    let mut all_combinations = vec![];
    
    for len in (1..=5).rev() {
        all_combinations.extend(combinations(&elements, len));
    }

    all_combinations.sort_by_key(|comb| {
        -(comb.iter().map(|c| values[c]).sum::<i32>())
    });

    all_combinations.into_iter()
        .map(|comb| comb.into_iter().collect::<String>())
        .collect()
}

fn main() {
    input! {
        a: i32,
        b: i32,
        c: i32,
        d: i32,
        e: i32,
    }

    let values = HashMap::from([
        ('A', a),
        ('B', b),
        ('C', c),
        ('D', d),
        ('E', e),
    ]);

    for result in solve(values) {
        println!("{}", result);
    }
}
```

</details>


---

# まとめ

AtCoderのABC問題をElixirで解き、さらにPythonとRustで比較しながら学ぶ取り組みは、プログラミングスキルの向上だけでなく、それぞれの言語の特徴を理解する良い機会となります。今回の取り組みを通じて、以下のような成果や学びが得られました：

- **Elixirの強みを再確認**  
  Elixirはそのシンプルで直感的な構文のおかげで、問題のロジックをわかりやすく表現できました。特にパターンマッチングや関数型プログラミングの特性が、問題解決の助けになりました。

- **Pythonの柔軟性と簡潔さ**  
  Pythonでは、直感的にコードを記述できるため、素早く問題に取り組むことができました。また、データ処理や繰り返し構文の扱いやすさが際立っていました。

- **Rustの安全性と高パフォーマンス**  
  Rustでは、型の厳格さとメモリ管理の明確さが求められる分、問題を解く過程で深い思考が必要でした。これにより、コードの安全性と効率を意識する良い訓練になりました。

また、この取り組みを通じて「闘魂とは己に打ち克つこと」という精神を再認識し、楽しみながら成長する姿勢を持つことの重要性を実感しました。Elixirを軸に据えることで、自分の得意分野を活かしつつ新しい言語に挑戦するという学びのプロセスは、非常に充実感のあるものでした。

これからもAtCoderを活用しながら、新しい言語や技術への挑戦を続けていきたいと思います。読者の皆様も、ぜひ自分自身のプログラミングの旅を楽しみながら、新しい挑戦に取り組んでみてください！