はじめに
プログラミングのスキルを向上させるために、私は現在、AtCoderのABC問題に挑戦しています。AtCoderは、アルゴリズムやデータ構造を中心にした問題解決能力を磨く場であり、自分との闘いでもあります。挑戦を通じてアントニオ猪木さんがおっしゃった「闘魂とは己に打ち克つこと、そして闘いを通じて己の魂を磨いていくこと」を体現する一つの活動と捉えています。
今回の取り組みでは、得意なElixirを使って自力で正解を導き出すことを第一目標としています。そして、その解答を生成AIであるGitHub 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
今回は、トヨタ自動車プログラミングコンテスト2024#12（AtCoder Beginner Contest 384）に挑戦します。
A - aaaadaa
問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。
私の解答
Elixir
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
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
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));
}
B - ARC Division
問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。
私の解答
Elixir
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
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
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));
}
C - Perfect Standings
問題文はリンク先をご参照ください。
それでは解答です。Elixirは自力で書いて、PythonとRustは生成AIに作ってもらいました。
私の解答
Elixir
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
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
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);
}
}
まとめ
AtCoderのABC問題をElixirで解き、さらにPythonとRustで比較しながら学ぶ取り組みは、プログラミングスキルの向上だけでなく、それぞれの言語の特徴を理解する良い機会となります。今回の取り組みを通じて、以下のような成果や学びが得られました：
-
Elixirの強みを再確認
Elixirはそのシンプルで直感的な構文のおかげで、問題のロジックをわかりやすく表現できました。特にパターンマッチングや関数型プログラミングの特性が、問題解決の助けになりました。 -
Pythonの柔軟性と簡潔さ
Pythonでは、直感的にコードを記述できるため、素早く問題に取り組むことができました。また、データ処理や繰り返し構文の扱いやすさが際立っていました。 -
Rustの安全性と高パフォーマンス
Rustでは、型の厳格さとメモリ管理の明確さが求められる分、問題を解く過程で深い思考が必要でした。これにより、コードの安全性と効率を意識する良い訓練になりました。
また、この取り組みを通じて「闘魂とは己に打ち克つこと」という精神を再認識し、楽しみながら成長する姿勢を持つことの重要性を実感しました。Elixirを軸に据えることで、自分の得意分野を活かしつつ新しい言語に挑戦するという学びのプロセスは、非常に充実感のあるものでした。
これからもAtCoderを活用しながら、新しい言語や技術への挑戦を続けていきたいと思います。読者の皆様も、ぜひ自分自身のプログラミングの旅を楽しみながら、新しい挑戦に取り組んでみてください！