LeetCodeとは？使い方・料金・日本語での進め方と計算量の実測

LeetCode で1問を解く流れは、どの問題でもほぼ同じです。まず総当たりで正しい答えを出し、制約から計算量を見積もって、間に合わなければ改良します。

flowchart TD
    A[問題文と制約を読む] --> B[例を手で解く]
    B --> C[総当たりを書く]
    C --> D{制約の上限で<br>間に合う?}
    D -->|いいえ| E[パターンを当てはめて改良]
    E --> F[自分でテストケースを足す]
    D -->|はい| F
    F --> G[Run で確かめて Submit]

よく調べられることの答えを先にまとめます。

確認環境：Ubuntu 24.04.5 LTS（x86_64・2 CPU・メモリ 8GB、ほかの処理も同時に動いている共用の環境）で、Python 3.13.18 と OpenJDK 21.0.12.1 を使い、LeetCode の定番問題7問（問題文は自分の言葉で要約）を手元で解きました。LeetCode と同じ class Solution の形で書き、自作のテスト（固定18件と、総当たりと突き合わせるランダム2,000回）を通したうえで、総当たりと改良版の時間を time.perf_counter()・System.nanoTime() で測っています。LeetCode のサイトにはアカウント作成も提出もしていません。サイトの機能・言語の版・料金は LeetCode の公式ページとヘルプセンター、AtCoder・paiza・HackerRank は各社の公式ページで確かめました。図は mermaid 11.16.0 で描画を確かめています（確認日 2026年10月29日）。

LeetCodeとは（何ができるサイトか）

この節では、LeetCode が何をするサイトで、どんな人に向いているのかが分かります。

LeetCode（リートコード）は、プログラミングの問題を解いて、その場で自動採点してもらえる Web サービスです。2015年にアメリカで始まり、海外のソフトウェア企業のコーディング面接（その場でアルゴリズムの問題を解く選考）の練習場所として広く使われています。中国向けには別のサイト（leetcode.cn）があります。

問題はアルゴリズムが中心ですが、SQL（Database）、pandas、JavaScript、シェル、並行処理（Concurrency）のカテゴリもあります。問題数は増え続けており、英語版 Wikipedia は「2026年1月時点で3,816問」と書いています。一部の問題は有料の Premium 会員だけが解けます。

LeetCode が教えてくれるのは「決まった形の問題を、制限時間内に、効率よく解く力」です。文法をゼロから学ぶ教材ではないため、if・for・関数・配列・辞書（ハッシュマップ）を自分で書ける段階から使うと進めやすくなります。

LeetCodeの使い方（登録から最初の提出まで）

この節では、アカウントを作ってから最初の1問を提出するまでの流れと、画面のボタンの意味が分かります。

最初の1問は、Problems の一覧で難易度を Easy に絞り、「1. Two Sum」を開くのが定番です。手順は次のとおりです（公式の画面の説明の範囲。この記事の確認ではアカウントを作っていません）。

判定結果の読み方

提出すると、次のどれかが表示されます。表示の意味と、まず疑うところを並べます。

LeetCodeは日本語で使える？英語の問題文の読み方

この節では、日本語の画面があるかと、英語の問題文を無理なく読む方法が分かります。

LeetCode（leetcode.com）の画面と問題文は英語です。日本語の表示は用意されていません。ただ、問題文は短く、毎回同じ言い回しが出てくるため、決まった単語を覚えると読む負担はかなり減ります。

• 例（Example）と制約（Constraints）を先に読みます。 入力と出力の例を見ると、本文を全部読まなくても何を求めているか分かることが多くあります。
• 翻訳は「分からない1文だけ」に使います。 全文を機械翻訳すると「subarray」と「subsequence」の区別のような大事な違いが消えることがあります。
• 日本語で同じ種類の問題を練習したいときは、AtCoder や paiza を並行して使う方法があります（違いは後の節）。

LeetCodeの料金：無料版とPremiumの違い

この節では、無料でどこまで使えて、Premium（有料）で何が増えるのかが分かります。

アカウント作成と大半の問題は無料です。Premium は月額か年額で払う有料プランで、限定問題・企業別の問題・デバッガーなどが加わります。公式の購読ページ（leetcode.com/subscribe）に書かれている内容を、2026年10月29日時点で整理しました。

金額はセールや地域で変わることがあるため、買う直前に公式の購読ページの表示で確かめるのが確実です。Premium を検討する目安は、無料の Easy・Medium を数十問解いて「企業別の傾向を見たい」「Premium 限定の問題が学習計画に入っている」と感じたときです。それまでは無料の範囲で困ることは少ないはずです。

代表的な問題をPythonとJavaで解く

この節では、最初に解かれることが多い定番問題を、Python と Java で実際に解いたコードと結果で確かめます。

問題文は LeetCode の原文を写さず、要点だけを自分の言葉でまとめています。コードは LeetCode と同じ class Solution の形で書き、手元で動かして確かめました。

1. Two Sum（2つの数の和）

要約：整数の配列と目標の値が与えられる。足すと目標になる2つの要素の「位置」を返す。答えはちょうど1組あり、同じ要素を2回使ってはいけない。

from typing import List   # LeetCode の画面では自動で読み込まれる。手元では要る

class Solution:
    # 総当たり：すべての組を試す（O(n²)）
    def twoSumBrute(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []

    # 改良版：見た値を辞書に入れ、「足りない分」を1回で引く（O(n)）
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = {}                      # 値 -> 添字
        for i, x in enumerate(nums):
            if target - x in seen:
                return [seen[target - x], i]
            seen[x] = i
        return []

総当たりはすべての組を試すので、要素が n 個なら約 n²/2 回比べます。改良版は「目標 − 今の値」がすでに出てきたかを辞書で調べるので、1回なめるだけで済みます。Java では HashMap を使います。

import java.util.*;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> seen = new HashMap<>();   // 値 -> 添字
        for (int i = 0; i < nums.length; i++) {
            Integer j = seen.get(target - nums[i]);
            if (j != null) return new int[]{j, i};
            seen.put(nums[i], i);
        }
        return new int[0];
    }
}

よくある間違いは、辞書を使わずに if target - x in nums と書くことです。手元で試すと、[3, 2, 4]・目標6 に対して [0, 0]（同じ要素を2回使った答え）が返りました。先に調べてから辞書に入れる順番にすると、この間違いは起きません。

2. Valid Parentheses（括弧の対応）

要約：()[]{} だけからなる文字列が、正しく開いて閉じているかを判定する。

def isValid(self, s: str) -> bool:
    pair = {')': '(', ']': '[', '}': '{'}
    stack = []
    for ch in s:
        if ch in pair:                       # 閉じ括弧が来た
            if not stack or stack.pop() != pair[ch]:
                return False
        else:                                # 開き括弧は積む
            stack.append(ch)
    return not stack                         # 残っていたら閉じ忘れ

public boolean isValid(String s) {
    Deque<Character> stack = new ArrayDeque<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') { stack.push(c); continue; }
        if (stack.isEmpty()) return false;
        char open = stack.pop();
        if (c == ')' && open != '(' || c == ']' && open != '[' || c == '}' && open != '{') return false;
    }
    return stack.isEmpty();
}

開き括弧を積み、閉じ括弧が来たら一番上と対応するかを見る「スタック」の典型です。"]"（閉じだけ）と "(("（開きだけ）の2つの端のケースを忘れると Wrong Answer や Runtime Error になります。

3. Binary Search（二分探索）

要約：昇順に並んだ配列から目標の値を探し、あれば位置、なければ -1 を返す。O(log n) で解くことが求められる。

def search(self, nums: List[int], target: int) -> int:
    lo, hi = 0, len(nums) - 1
    while lo <= hi:                 # 「<=」にしないと要素1つのときに探さない
        mid = (lo + hi) // 2
        if nums[mid] == target:
            return mid
        if nums[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

public int search(int[] nums, int target) {
    int lo = 0, hi = nums.length - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;   // (lo + hi) / 2 は int があふれることがある
        if (nums[mid] == target) return mid;
        if (nums[mid] < target) lo = mid + 1; else hi = mid - 1;
    }
    return -1;
}

Java の (lo + hi) / 2 は、値が大きいと int の範囲（約21億）を超えて負の数になります。手元で確かめた結果です。

$ java Mid      # lo = 1_500_000_000, hi = 2_000_000_000
-397483648      # (lo + hi) / 2      … あふれて負の数になる
1750000000      # lo + (hi - lo) / 2 … 正しい
1750000000      # (lo + hi) >>> 1    … これも正しい

LeetCode の制約では配列の長さがそこまで大きくないことが多いものの、面接では lo + (hi - lo) / 2 と書けるかを見られることがあります。Python の整数はあふれないので、この問題は起きません。

4. Reverse Linked List（連結リストの反転）

要約：単方向の連結リストの先頭が与えられる。並びを逆にして、新しい先頭を返す。

class ListNode:                     # LeetCode では画面に用意されている
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
    prev = None
    while head:
        nxt = head.next      # 1. 次を覚える
        head.next = prev     # 2. 矢印を逆に向ける
        prev = head          # 3. prev を1つ進める
        head = nxt           # 4. head を1つ進める
    return prev

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

矢印を1本ずつ逆に向けるだけですが、「次を覚えてから矢印を変える」順番を間違えるとリストが途中で切れます。紙に3つの箱を描いて、4行の動きを1つずつ追うと分かりやすくなります。連結リストが配列より遅くなりやすい理由は、関連記事「データ構造の落とし穴8選｜LinkedListが遅い理由」で扱っています。

5〜7. 部分配列の最大和・階段の上り方・重複の無い最長部分文字列

要約：（5）配列の連続した部分の和の最大値を求める。（6）1段か2段ずつ上るとき、n 段の階段の上り方は何通りか。（7）文字列の中で、同じ文字を含まない連続部分の最長の長さを求める。

# 総当たり：始点と終点をすべて試す（O(n²)）
def maxSubArrayBrute(self, nums):
    best = nums[0]
    for i in range(len(nums)):
        s = 0
        for j in range(i, len(nums)):
            s += nums[j]
            best = max(best, s)
    return best

# 改良版：「ここで終わる最大和」だけを持ち歩く（O(n)。カダネのアルゴリズム）
def maxSubArray(self, nums):
    best = cur = nums[0]
    for x in nums[1:]:
        cur = max(x, cur + x)        # 前を捨てて x から始めるか、つなげるか
        best = max(best, cur)
    return best

# 素直な再帰：同じ計算を何度もする（O(2^n) に近い）
def climbNaive(self, n):
    if n <= 2:
        return n
    return self.climbNaive(n - 1) + self.climbNaive(n - 2)

# 改良版：直前の2つだけ覚えて下から積み上げる（O(n)・メモリ O(1)）
def climbStairs(self, n):
    if n == 1:
        return 1
    a, b = 1, 2
    for _ in range(n - 2):
        a, b = b, a + b
    return b

def lengthOfLongestSubstring(self, s: str) -> int:
    last = {}                 # 文字 -> 最後に見た位置
    left = best = 0
    for right, ch in enumerate(s):
        if ch in last and last[ch] >= left:   # 窓の中で重複したら
            left = last[ch] + 1               # 左端を重複の次まで縮める
        last[ch] = right
        best = max(best, right - left + 1)
    return best

Java 版も同じ考え方で書き、手元のテストを通しました。

$ javac -d out Main.java
$ java -cp out Main
OK  twoSum: got=[0, 1]
OK  twoSum 同じ値: got=[0, 1]
OK  isValid ()[]{}: got=true
OK  isValid ([)]: got=false
OK  search: got=4
OK  reverseList: got=[3, 2, 1]
OK  maxSubArray: got=6

総当たりと改良版の計算量を実測（入力の大きさを変えて比較）

この節では、計算量（入力が増えたときに時間がどれだけ増えるか）の違いが、実際の時間でどれだけ効くのかが分かります。

O(n²) の総当たりは、入力が2倍になると時間がほぼ4倍になります。O(n) の改良版は2倍のままです。Two Sum は答えが配列の最後の2つになる、総当たりにとって一番遅い入力で測りました（Python は3回のうち最短。総当たりの大きい n は1回）。

Python 3.13 での実測

Two Sum の n = 10,000 は同じ処理を4回測り、3.1秒から5.0秒までばらつきました。手元はほかの処理と CPU を分け合う環境なので、時間そのものより「n が2倍で約4倍」という増え方を見るのが確実です。階段の上り方の素直な再帰は、n が5増えるごとに約10倍（20→25→30 で 0.5ms→11.8ms→124.3ms）になりました。

Java 21 での実測（3回のうち最短）

同じ O(n²) の総当たりでも、Java は Python の100倍以上速く動きました（Two Sum の n = 10,000 で 12.86ms と約3秒）。Java は実行中にコードを機械語へ変換して最適化（JIT）するためです。それでも n が10倍になると時間は約100倍になり、増え方そのものは変わりません。言語の速さで O(n²) を通そうとするより、計算量を下げるほうが確実です。

制約から計算量を決める目安

手元の Python では、二重ループの単純な比較が1秒あたりおよそ1,000万〜2,000万回でした（n = 8,000 で約3,200万組を1.7〜2.5秒）。この数字から、制約の上限で間に合う計算量の目安をまとめます。

テストケースの作り方（Wrong Answerを提出前に見つける）

この節では、問題文の例だけでは見つからない間違いを、提出前に自分で見つける方法が分かります。

例が全部通っても正しいとは限りません。「重複の無い最長部分文字列」で、窓の外の位置を確かめる条件（last[ch] >= left）を忘れた版を作ったところ、問題ページにある3つの例はすべて正解しました。そこで、遅いが確実に正しい総当たりと、ランダムな入力で答えを突き合わせました。

def buggy(s):                       # last[ch] >= left の確認を忘れた版
    last = {}; left = best = 0
    for r, ch in enumerate(s):
        if ch in last:
            left = last[ch] + 1     # 窓の外の古い位置にも反応してしまう
        last[ch] = r
        best = max(best, r - left + 1)
    return best

# 問題ページの3つの例は全部通る
print(buggy("abcabcbb"), buggy("bbbbb"), buggy("pwwkew"))

# 総当たりと突き合わせる
random.seed(1)
for k in range(10000):
    s = "".join(random.choice("ab") for _ in range(random.randint(0, 6)))
    if buggy(s) != S.lengthBrute(s):
        print(f"{k+1}回目で不一致: s={s!r} buggy={buggy(s)} brute={S.lengthBrute(s)}")
        break

3 1 3
3回目で不一致: s='bbbaab' buggy=3 brute=2

3回目のランダム入力で食い違いが見つかりました。LeetCode の Testcase タブに "bbbaab" や、もっと短い "abba"（正しい答えは2）を足すと、提出前に直せます。手元では、この方法で7問すべてを確かめました。

OK  twoSum: got=[0, 1] expected=[0, 1]
OK  twoSum 同じ値: got=[0, 1] expected=[0, 1]
OK  twoSum 負の数: got=[0, 2] expected=[0, 2]
OK  isValid ()[]{}: got=True expected=True
OK  isValid ([)]: got=False expected=False
OK  isValid 閉じだけ ]: got=False expected=False
OK  isValid 開きだけ ((: got=False expected=False
OK  search 有る: got=4 expected=4
OK  search 無い: got=-1 expected=-1
OK  search 要素1つ: got=0 expected=0
OK  reverseList: got=[5, 4, 3, 2, 1] expected=[5, 4, 3, 2, 1]
OK  reverseList 空: got=[] expected=[]
OK  maxSubArray: got=6 expected=6
OK  maxSubArray 全部負: got=-1 expected=-1
OK  climbStairs 5: got=8 expected=8
OK  longest abcabcbb: got=3 expected=3
OK  longest 空文字: got=0 expected=0
OK  longest abba: got=2 expected=2
固定ケース 18 件中 NG 0 件／ランダム突き合わせ 2000 回 OK

足しておきたい端のケース

• 1空・1要素空文字・要素1つの配列・空のリスト。二分探索の while lo <= hi の「=」もここで分かる
• 2全部同じ値・重複[3, 3]・"bbbbb"。同じ要素を2回使っていないか
• 3負の数・0最大和で全部が負のとき（答えは0ではなく一番大きい負の数）
• 4制約の上限の値10^9 どうしの足し算は Java の int であふれる
• 5答えが端にある先頭・末尾・存在しない。総当たりの最悪の入力にもなる

LeetCode と同じ形式のテストを手元で流す

LeetCode の Testcase タブは「1行に1つの引数」を JSON に近い形で書きます。同じ形式のファイルを手元で読む小さなスクリプトを書くと、エディターで書いたコードをそのまま試せます。

[2,7,11,15]
9
[3,2,4]
6
[3,3]
6
[-1,-2,-3,-4,-5]
-8
[0,4,3,0]
0
[1000000000,-999999993,5]
7

import json, sys
from sol import Solution
# 1行に1引数（JSON）。2行で1ケース
lines = [l for l in open(sys.argv[1]).read().splitlines() if l.strip()]
S = Solution()
for k in range(0, len(lines), 2):
    nums, target = json.loads(lines[k]), json.loads(lines[k + 1])
    print(f"case {k//2+1}: nums={nums} target={target} -> {S.twoSum(nums, target)}")

case 1: nums=[2, 7, 11, 15] target=9 -> [0, 1]
case 2: nums=[3, 2, 4] target=6 -> [1, 2]
case 3: nums=[3, 3] target=6 -> [0, 1]
case 4: nums=[-1, -2, -3, -4, -5] target=-8 -> [2, 4]
case 5: nums=[0, 4, 3, 0] target=0 -> [0, 3]
case 6: nums=[1000000000, -999999993, 5] target=7 -> [0, 1]

パターン別の考え方（詰まったときの手がかり）

この節では、問題文のどこを見ればどの解き方を思い出せばよいのかが、パターン別に分かります。

LeetCode の問題の多くは、十数種類の決まったパターンのどれかに当てはまります。問題文の言葉と制約から、まず候補を絞ります。

解けないときの時間の使い方

1. 1最初の5分：例を手で解く紙に入力を書き、自分ならどう答えを出すかを言葉にする
2. 2次の10分：総当たりを書く遅くてよいので正しい答えを出す。後でテストの突き合わせに使える
3. 3次の10分：パターンを当てはめる上のカードの言葉と制約の表から候補を2つに絞る
4. 420〜30分で進まなければ解説を読むEditorial の考え方だけ読み、コードは見ずに自分で書く
5. 53日後と1週間後に解き直す何も見ずに書けたら身についている

生成 AI に聞くときも、答えのコードではなく「どのパターンを考えればよいか」だけを聞くと、自分で解く練習を残せます。聞き方の例は、関連記事「プログラミング学習での生成AIの使い方 答えを聞かないプロンプト集」で扱っています。

PythonとJavaどちらで解く？手元とLeetCodeの違い

この節では、LeetCode で使える言語と版、Python と Java の選び方、手元で同じコードを動かすときの違いが分かります。

LeetCode のヘルプセンターによると、Python3 は Python 3.14、Java は Java 25 で動きます（2026年10月29日時点）。ほかに C++（clang 19）、C、C#（.NET 10）、JavaScript（Node.js 22.14.0）、TypeScript、Go、Rust、Kotlin、Swift、Ruby、PHP、Scala、Dart など、SQL では MySQL・SQL Server・Oracle・PostgreSQL が選べます。

LeetCode の画面では collections や bisect などがあらかじめ読み込まれています（公式ヘルプの説明）。そのため、画面からコピーしたコードを手元でそのまま動かすと、次のエラーが出ます。

    def twoSum(self, nums: List[int], target: int) -> List[int]:
                           ^^^^
NameError: name 'List' is not defined. Did you mean: 'list'?

手元では先頭に from typing import List, Optional を書きます。Java では、LeetCode の class Solution に public を付けて別の名前のファイルに置くと、コンパイルで止まります。

Main.java:1: error: class Solution is public, should be declared in a file named Solution.java
public class Solution {
       ^
1 error

Java の配列の並べ替えは、関連記事「Java配列ソート|Arrays.sortで昇順・降順・文字列を並び替え」で扱っています。

AtCoder・paiza・HackerRankとの違い

この節では、似たサービスとの違いと、目的ごとの選び方が分かります（各社の公式ページで確かめた範囲。2026年10月29日時点）。

• AtCoder：初心者から上級者までが参加できるプログラミングコンテストのサイトです。たとえば ABC 400 は7問・100分で、誤答1回ごとに5分の加算がありました（公式のコンテストページ）。入力の読み込みから自分で書くため、LeetCode より「プログラム全体」を書く練習になります。
• paiza：公式ページでは865問（毎週木曜日に追加）、Java・Python3・C++ など15言語に対応し、提出は10個以上のテストケースで自動採点されると書かれています。受験には会員登録が要ります。
• HackerRank：面接対策の Interview Preparation Kit は配列・辞書・並べ替え・DP・グラフなど14分野に分かれています。Problem Solving（Basic・Intermediate）や Python・Java・SQL などの認定テストがあります。

面接対策としてのLeetCodeと、仕事のプログラミングとの違い

この節では、LeetCode で身につく力と身につかない力、面接対策としての使い方が分かります。

LeetCode で鍛えられるのは、小さな問題を正確に速く解く力と、計算量で考える習慣です。一方で、仕事のプログラミングの多くは、既にあるコードを読み、チームの決まりに合わせて変更し、テストとレビューを通す作業です。

面接の練習として使うなら、解きながら考えを声に出す練習を組み合わせるのが効果的です。コーディング面接では、正解のコードに加えて「総当たりから始めて、計算量を説明し、改良する」過程を見られることが多いためです。考えを言葉で説明できる力は、面接の形式がオンラインでも対面でも同じように役に立ちます。

再帰で解く問題で RecursionError が出たときの直し方は、関連記事「RecursionErrorの原因と直し方｜Pythonの再帰」で、Java の場合は関連記事「Java StackOverflowErrorの原因と対処｜再帰と-Xss早見表」で扱っています。

使うかどうかの判断表

LeetCodeを学ぶ順番

この節では、初めての人がどの順番でどのパターンを学ぶと進めやすいかが分かります。

前のパターンが次のパターンの部品になる順番で並べます。各段で Easy を3〜5問、慣れたら Medium を2〜3問解くのが目安です。

1. 1配列と文字列の基本操作ループ・添字・スライス。計算量 O(n) と O(n²) の違いを知る
2. 2ハッシュマップ・セットTwo Sum・重複の判定。二重ループを減らす最初の道具
3. 3二つのポインター・スライディングウィンドウ連続した部分・並べ替え済みの配列
4. 4スタック・キュー括弧の対応・次に大きい要素
5. 5二分探索境界の書き方（lo <= hi）を体で覚える
6. 6連結リスト反転・合併・循環の検出。ポインターの付け替え
7. 7木と再帰（DFS・BFS）二分木の深さ・左右反転・レベルごとの走査
8. 8ヒープ・グラフ上位 k 個・島の数・最短経路
9. 9動的計画法（DP）階段の上り方 → 最大和 → ナップサック型

LeetCode 75 などの Study Plan も、ほぼこの順番に沿っています。1日1問でも、同じ問題を間隔を空けて解き直すほうが、新しい問題を次々に解くより身につきやすくなります。

続けるための仕組み：Study Plan・Daily Question・コンテスト

学ぶ順番に沿って進めるときは、公式の3つの仕組みが使えます。

コンテストの問題数・時間・開始時刻は、各回のコンテストのページに表示されます。公式の計画のほかに、Blind 75・Grind 75・NeetCode 150 のように有志がまとめた問題リストもよく使われます。

LeetCodeでよくあるエラー・つまずき

この節では、LeetCode や手元で解くときに出やすいエラーの原文と、直し方が分かります（原文はすべて手元で出したもの）。

よくある質問

Q. LeetCode とは何ですか？ A. コーディング面接でよく出るアルゴリズムの問題をブラウザで解き、自動で採点してもらえる練習サイトです。Easy・Medium・Hard の問題があり、大半は無料で解けます。

Q. LeetCode は無料で使えますか？ A. アカウント作成と大半の問題、Study Plan、Daily Question、コンテストは無料です。Premium 限定の問題と、企業別の問題・デバッガーなどは有料です。

Q. Premium の料金はいくらですか？ A. 月額と年額のプランがあり、公式ページには年額が月額より62%以上お得と書かれています（2026年10月29日時点）。金額は購入前に公式の購読ページで確かめるのが確実です。

Q. LeetCode は日本語に対応していますか？ A. 画面と問題文は英語です。例と制約を先に読み、よく出る単語（indices・in-place・subarray など）を覚えると読みやすくなります。日本語で練習したいときは AtCoder や paiza を並行して使えます。

Q. 初心者でも使えますか？ A. if・for・関数・配列・辞書を自分で書けるなら、Easy から始められます。文法をまだ学んでいる段階なら、先に入門を終えるほうが進めやすくなります。

Q. 最初に解くべき問題はどれですか？ A. Two Sum、Valid Parentheses、Binary Search、Reverse Linked List が定番です。続けるなら Study Plan の LeetCode 75 を順に解くと、パターンを偏りなく学べます。

Q. Python と Java のどちらで解くのがよいですか？ A. 短く書けるのは Python です。仕事で Java を使っているなら Java でも問題ありません。手元の実測では Java の総当たりが Python の100倍以上速く動きましたが、計算量を下げるのが基本なのはどちらも同じです。

Q. Run と Submit の違いは何ですか？ A. Run は問題文の例と自分で足したテストケースだけで動かす確認用です。Submit は隠れたテストケースをすべて流して判定し、結果が記録に残ります。

Q. 解けない問題はどうすればよいですか？ A. 20〜30分考えて進まなければ、公式の解説の考え方だけを読み、コードは自分で書きます。3日後と1週間後に何も見ずに解き直すと身につきます。

Q. LeetCode と AtCoder の違いは何ですか？ A. LeetCode は関数だけを書く面接形式で、画面は英語です。AtCoder は入力の読み込みから書く競技形式で、日本語で使えます。面接対策なら LeetCode、競技として鍛えるなら AtCoder が向いています。

Q. LeetCode を解けば仕事のプログラミングもできるようになりますか？ A. 計算量で考える習慣は仕事でも役立ちますが、既存のコードを読む力・設計・テストを書く力は別に身につける必要があります。LeetCode は「部品の速さ」を鍛える道具と考えると位置づけが分かりやすくなります。

まとめ

• LeetCode は、面接向けのアルゴリズム問題を解いて自動採点される練習サイトです。大半は無料で、Premium は限定問題・企業別の問題・デバッガーなどが加わる有料プランです。
• 使い方は「Easy で絞る → 関数を書く → Run → Submit → 解説を読む」の繰り返しです。画面は英語ですが、例と制約を先に読めば進められます。
• 計算量の差は実測で桁違いでした。Two Sum の n = 8,000 で総当たり1,684ms・辞書版0.55ms、線形探索を1,000回は100万要素で43秒・二分探索は8.7ms。
• 例が全部通っても正しいとは限りません。総当たりとランダム入力で突き合わせると、例では見つからない間違いを3回目の入力で見つけられました。
• パターン（ハッシュ・ウィンドウ・二分探索・スタック・DP など）を順番に学び、日本語で基礎を固めたいときは AtCoder・paiza を組み合わせると続けやすくなります。

参考・出典

確認日はいずれも 2026年10月29日です。

• LeetCode「LeetCode Premium」（購読ページ）：https://leetcode.com/subscribe/
• LeetCode Help Center「What are the environments for the programming languages?」：https://support.leetcode.com/hc/en-us/articles/360011833974-What-are-the-environments-for-the-programming-languages
• LeetCode「Study Plan LeetCode 75」：https://leetcode.com/studyplan/leetcode-75/
• LeetCode「Study Plan Top Interview 150」：https://leetcode.com/studyplan/top-interview-150/
• LeetCode「Contest」：https://leetcode.com/contest/
• Wikipedia（英語版）「LeetCode」：https://en.wikipedia.org/wiki/LeetCode
• AtCoder 公式サイト：https://atcoder.jp/home
• AtCoder「AtCoder Beginner Contest 400」：https://atcoder.jp/contests/abc400
• paiza「スキルチェックについて」：https://paiza.jp/challenges/info
• HackerRank「Interview Preparation Kit」：https://www.hackerrank.com/interview/interview-preparation-kit
• HackerRank「Skills Certification」：https://www.hackerrank.com/skills-verification

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。