def sum_imperative(numbers):
    """
    命令型スタイルでリストの合計値を計算する。
    状態変数 total を用い、ループで逐次更新していく。
    """
    total = 0                    # 状態の初期化
    index = 0                    # ループカウンタの初期化
    while index < len(numbers):  # 反復（終了条件の判定）
        total = total + numbers[index]  # 状態の更新（代入）
        index = index + 1               # カウンタの更新
    return total                 # 最終状態を返す
 
# 実行例
data = [10, 20, 30, 40, 50]
result = sum_imperative(data)
print(f"合計: {result}")  # 合計: 150

#include <stdio.h>
 
int sum_imperative(int numbers[], int length) {
    int total = 0;                  /* 状態の初期化 */
    int index = 0;                  /* ループカウンタの初期化 */
    while (index < length) {        /* 反復 */
        total = total + numbers[index];  /* 状態の更新 */
        index = index + 1;              /* カウンタの更新 */
    }
    return total;                   /* 最終状態を返す */
}
 
int main(void) {
    int data[] = {10, 20, 30, 40, 50};
    int length = sizeof(data) / sizeof(data[0]);
    int result = sum_imperative(data, length);
    printf("合計: %d\n", result);   /* 合計: 150 */
    return 0;
}

# 命令型: 「どうやって」フィルタリングするかを逐一指示する
items = [
    {"name": "ノートPC", "price": 150000},
    {"name": "マウス", "price": 3000},
    {"name": "キーボード", "price": 12000},
    {"name": "モニター", "price": 45000},
    {"name": "USBケーブル", "price": 800},
]
 
expensive_items = []                  # 空リストを用意
for item in items:                    # 各要素を順に処理
    if item["price"] >= 10000:        # 条件を判定
        expensive_items.append(item["name"])  # 結果に追加
 
print(expensive_items)
# ['ノートPC', 'キーボード', 'モニター']

-- 宣言型: 「何が」欲しいかだけを記述する
SELECT name
FROM items
WHERE price >= 10000;
 
-- 実行エンジンがインデックスの使用、テーブルスキャン等を自動判断する

# 宣言型寄りのスタイル
expensive_items = [item["name"] for item in items if item["price"] >= 10000]

; x86アセンブリ言語の例：2つの数値の加算
section .data
    num1 dd 10          ; 32ビット整数 10
    num2 dd 20          ; 32ビット整数 20
    result dd 0         ; 結果格納用
 
section .text
    global _start
 
_start:
    mov eax, [num1]     ; num1の値をEAXレジスタにロード
    add eax, [num2]     ; num2の値をEAXに加算
    mov [result], eax   ; 結果をメモリに格納
 
    ; プログラム終了（Linux システムコール）
    mov eax, 1          ; sys_exit
    xor ebx, ebx        ; 終了コード 0
    int 0x80            ; カーネル呼び出し

C     FORTRAN 77 による数値積分（台形公式）
C     命令型プログラミングの典型例
      PROGRAM TRAPEZOID
      IMPLICIT NONE
      INTEGER N, I
      REAL A, B, H, SUM, X
 
C     積分区間と分割数の設定
      A = 0.0
      B = 1.0
      N = 1000
 
C     刻み幅の計算
      H = (B - A) / N
 
C     台形公式による数値積分
      SUM = 0.0
      DO 10 I = 1, N - 1
          X = A + I * H
          SUM = SUM + X * X
   10 CONTINUE
 
      SUM = H * (A*A/2.0 + SUM + B*B/2.0)
 
      WRITE(*,*) 'Integral of x^2 from 0 to 1 =', SUM
C     理論値: 1/3 = 0.333333...
      STOP
      END

/*
 * C言語による動的配列の実装
 * 命令型プログラミングの特徴が凝縮された例:
 *   - 明示的なメモリ管理（malloc/realloc/free）
 *   - ポインタによる間接参照
 *   - 構造体による状態のカプセル化
 *   - 手続き（関数）による操作の定義
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
    int *data;       /* 要素を格納する配列へのポインタ */
    int size;        /* 現在の要素数 */
    int capacity;    /* 確保済みの容量 */
} DynamicArray;
 
/* 初期化 */
DynamicArray *array_create(int initial_capacity) {
    DynamicArray *arr = malloc(sizeof(DynamicArray));
    if (arr == NULL) return NULL;
    arr->data = malloc(sizeof(int) * initial_capacity);
    if (arr->data == NULL) {
        free(arr);
        return NULL;
    }
    arr->size = 0;
    arr->capacity = initial_capacity;
    return arr;
}
 
/* 要素の追加 */
int array_push(DynamicArray *arr, int value) {
    if (arr->size >= arr->capacity) {
        int new_capacity = arr->capacity * 2;
        int *new_data = realloc(arr->data, sizeof(int) * new_capacity);
        if (new_data == NULL) return -1;
        arr->data = new_data;
        arr->capacity = new_capacity;
    }
    arr->data[arr->size] = value;
    arr->size++;
    return 0;
}
 
/* 要素の取得 */
int array_get(DynamicArray *arr, int index) {
    if (index < 0 || index >= arr->size) {
        fprintf(stderr, "Index out of bounds: %d\n", index);
        exit(1);
    }
    return arr->data[index];
}
 
/* 解放 */
void array_destroy(DynamicArray *arr) {
    if (arr != NULL) {
        free(arr->data);
        free(arr);
    }
}
 
int main(void) {
    DynamicArray *arr = array_create(4);
 
    for (int i = 0; i < 10; i++) {
        array_push(arr, i * 10);
    }
 
    printf("Size: %d, Capacity: %d\n", arr->size, arr->capacity);
    /* Size: 10, Capacity: 16 */
 
    for (int i = 0; i < arr->size; i++) {
        printf("[%d] = %d\n", i, array_get(arr, i));
    }
 
    array_destroy(arr);
    return 0;
}

# 順次構造の例：円の面積と円周を計算する
import math
 
radius = 5.0                                # 文1: 半径の設定
area = math.pi * radius ** 2                # 文2: 面積の計算
circumference = 2 * math.pi * radius        # 文3: 円周の計算
 
print(f"半径: {radius}")                     # 文4: 結果の出力
print(f"面積: {area:.2f}")                   # 文5
print(f"円周: {circumference:.2f}")          # 文6
 
# 出力:
# 半径: 5.0
# 面積: 78.54
# 円周: 31.42

# 順序の違いが結果に影響する例
x = 10
y = x + 5    # y = 15
x = 20       # xが変更されても、yはすでに計算済み
print(y)     # 15（20 + 5 = 25 ではない）
 
# 対比：宣言型のスプレッドシートでは
# セルB1 = A1 + 5 とすると、A1を変更するとB1も自動更新される
# → これが命令型と宣言型の根本的な違い

def classify_temperature(celsius):
    """
    温度を分類する選択構造の例。
    複数の条件を elif で連鎖させるパターン。
    """
    if celsius >= 35:
        category = "猛暑"
        advice = "外出を控え、こまめに水分を補給すること"
    elif celsius >= 30:
        category = "真夏日"
        advice = "熱中症に注意すること"
    elif celsius >= 25:
        category = "夏日"
        advice = "適度な水分補給を心がけること"
    elif celsius >= 15:
        category = "快適"
        advice = "過ごしやすい気温"
    elif celsius >= 5:
        category = "肌寒い"
        advice = "上着を用意すること"
    elif celsius >= 0:
        category = "寒い"
        advice = "防寒対策をしっかり行うこと"
    else:
        category = "厳寒"
        advice = "凍結に注意すること"
 
    return category, advice
 
# 実行例
for temp in [38, 28, 10, -3]:
    cat, adv = classify_temperature(temp)
    print(f"{temp}°C → {cat}: {adv}")
 
# 出力:
# 38°C → 猛暑: 外出を控え、こまめに水分を補給すること
# 28°C → 夏日: 適度な水分補給を心がけること
# 10°C → 肌寒い: 上着を用意すること
# -3°C → 厳寒: 凍結に注意すること

#include <stdio.h>
 
/*
 * switch文による多分岐の例。
 * 曜日の番号から名前を返す。
 * break を忘れるとフォールスルーが発生するため注意が必要。
 */
const char *day_name(int day) {
    switch (day) {
        case 0: return "日曜日";
        case 1: return "月曜日";
        case 2: return "火曜日";
        case 3: return "水曜日";
        case 4: return "木曜日";
        case 5: return "金曜日";
        case 6: return "土曜日";
        default: return "不明";
    }
}
 
/* フォールスルーを意図的に使う例 */
void classify_day(int day) {
    switch (day) {
        case 0:
        case 6:
            printf("%s は休日\n", day_name(day));
            break;
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            printf("%s は平日\n", day_name(day));
            break;
        default:
            printf("無効な曜日番号: %d\n", day);
            break;
    }
}
 
int main(void) {
    for (int i = 0; i <= 7; i++) {
        classify_day(i);
    }
    return 0;
}
/*
 * 出力:
 * 日曜日 は休日
 * 月曜日 は平日
 * 火曜日 は平日
 * 水曜日 は平日
 * 木曜日 は平日
 * 金曜日 は平日
 * 土曜日 は休日
 * 無効な曜日番号: 7
 */

def binary_search(sorted_list, target):
    """
    二分探索：while ループによる反復構造の典型例。
    ソート済みリストから目的の要素を効率的に探索する。
 
    - 前判定ループ: 条件を先に判定してからループ本体を実行
    - 状態変数 low, high を更新しながら探索範囲を半減させる
    """
    low = 0
    high = len(sorted_list) - 1
 
    while low <= high:                       # 前判定: 探索範囲が存在する間
        mid = (low + high) // 2              # 中央のインデックスを計算
        if sorted_list[mid] == target:       # 選択: 見つかった場合
            return mid
        elif sorted_list[mid] < target:      # 選択: 右半分を探索
            low = mid + 1                    # 状態の更新
        else:                                # 選択: 左半分を探索
            high = mid - 1                   # 状態の更新
 
    return -1  # 見つからなかった場合
 
# 実行例
data = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
print(binary_search(data, 23))   # 5（インデックス5に存在）
print(binary_search(data, 50))   # -1（存在しない）

def selection_sort(arr):
    """
    選択ソート：二重ループの典型例。
    外側ループ: 確定する位置を順に処理
    内側ループ: 未ソート部分から最小値を探索
    """
    n = len(arr)
    for i in range(n - 1):              # 外側ループ: n-1回繰り返す
        min_index = i
        for j in range(i + 1, n):       # 内側ループ: 未ソート部分を走査
            if arr[j] < arr[min_index]:
                min_index = j
        # 最小値を先頭と交換（代入による状態変更）
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr
 
# 実行例
data = [64, 25, 12, 22, 11]
print(f"ソート前: {data}")
result = selection_sort(data)
print(f"ソート後: {result}")
 
# ソート前: [64, 25, 12, 22, 11]
# ソート後: [11, 12, 22, 25, 64]

#include <stdio.h>
 
/*
 * do-while ループの例：ユーザ入力の検証
 * 「少なくとも1回は実行する」場合に適する。
 * Python には do-while 構文がないため、C言語で示す。
 */
int main(void) {
    int number;
 
    do {
        printf("1から100の整数を入力してください: ");
        scanf("%d", &number);
 
        if (number < 1 || number > 100) {
            printf("範囲外です。もう一度入力してください。\n");
        }
    } while (number < 1 || number > 100);  /* 後判定 */
 
    printf("入力された値: %d\n", number);
    return 0;
}

def find_primes_sieve(limit):
    """
    エラトステネスの篩：三つの制御構造を組み合わせた例。
 
    - 順次: 初期化、結果の収集
    - 選択: 素数かどうかの判定
    - 反復: 篩の処理、倍数の除去
    """
    # 順次: 初期化
    is_prime = [True] * (limit + 1)
    is_prime[0] = False
    is_prime[1] = False
 
    # 反復（外側）: 2からsqrt(limit)まで
    i = 2
    while i * i <= limit:
        # 選択: iが素数として残っている場合のみ処理
        if is_prime[i]:
            # 反復（内側）: iの倍数を除去
            j = i * i
            while j <= limit:
                is_prime[j] = False  # 代入: 状態の更新
                j += i
        i += 1
 
    # 順次: 結果の収集
    primes = []
    for num in range(2, limit + 1):
        if is_prime[num]:            # 選択
            primes.append(num)
 
    return primes
 
# 実行例
result = find_primes_sieve(50)
print(f"50以下の素数: {result}")
# 50以下の素数: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
print(f"個数: {len(result)}")
# 個数: 15

# === 副作用のある関数 ===
 
# 例1: グローバル変数の変更
counter = 0
 
def increment():
    """呼び出すたびにグローバル変数 counter を変更する（副作用）"""
    global counter
    counter += 1
    return counter
 
print(increment())  # 1
print(increment())  # 2
print(increment())  # 3
# → 同じ引数（なし）で呼んでも、毎回異なる結果を返す
 
 
# 例2: 引数の破壊的変更
def remove_negatives(numbers):
    """元のリストを直接変更する（副作用）"""
    i = 0
    while i < len(numbers):
        if numbers[i] < 0:
            numbers.pop(i)     # 元のリストを変更
        else:
            i += 1
    return numbers
 
data = [3, -1, 4, -1, 5, -9, 2, 6]
result = remove_negatives(data)
print(result)   # [3, 4, 5, 2, 6]
print(data)     # [3, 4, 5, 2, 6] ← 元のリストも変わっている！
 
 
# === 副作用のない関数（純粋関数） ===
 
def remove_negatives_pure(numbers):
    """新しいリストを作成して返す（副作用なし）"""
    result = []
    for num in numbers:
        if num >= 0:
            result.append(num)
    return result
 
data = [3, -1, 4, -1, 5, -9, 2, 6]
result = remove_negatives_pure(data)
print(result)   # [3, 4, 5, 2, 6]
print(data)     # [3, -1, 4, -1, 5, -9, 2, 6] ← 元のリストは不変

# 参照透過な関数
def add(a, b):
    return a + b
 
# add(3, 4) はいつでも 7 に置き換えられる
x = add(3, 4) + add(3, 4)   # x = 7 + 7 = 14
y = 7 + 7                    # y = 14
# x と y は常に等しい → 参照透過
 
# 参照透過でない関数
import random
 
def random_add(a, b):
    return a + b + random.randint(0, 10)
 
# random_add(3, 4) の結果は呼び出すたびに異なる
# → 値で置き換えると意味が変わる → 参照透過でない

# === 可変状態の問題：エイリアシング ===
 
def process_orders(orders, vip_orders):
    """
    注文リストを処理する。
    問題: orders と vip_orders が同じオブジェクトを参照していた場合、
    意図しない副作用が発生する。
    """
    # 一般注文に送料を加算
    for order in orders:
        order["total"] += 500
 
    # VIP注文は送料無料
    for order in vip_orders:
        order["total"] -= 500    # 送料分を減算
 
    return orders, vip_orders
 
# 問題のあるケース: 同じ辞書オブジェクトが両方のリストに存在
shared_order = {"item": "Book", "total": 3000}
orders = [shared_order]
vip_orders = [shared_order]  # 同じオブジェクトへの参照！
 
process_orders(orders, vip_orders)
print(shared_order)
# {"item": "Book", "total": 3000}
# → +500して-500されたので元に戻るが、
#   これは偶然であり、処理順序が変わると結果も変わる
 
# === 解決策: 防御的コピー ===
 
import copy
 
def process_orders_safe(orders, vip_orders):
    """防御的コピーにより、元のデータを保護する"""
    orders_copy = copy.deepcopy(orders)
    vip_copy = copy.deepcopy(vip_orders)
 
    for order in orders_copy:
        order["total"] += 500
 
    for order in vip_copy:
        order["total"] -= 500
 
    return orders_copy, vip_copy

#include <stdio.h>
#include <stdlib.h>
 
int global_var = 100;           /* データセグメント */
int uninitialized_global;       /* BSSセグメント（0に初期化） */
 
void demonstrate_memory(void) {
    int local_var = 42;                       /* スタック */
    static int static_var = 0;                /* データセグメント */
    int *heap_var = malloc(sizeof(int));       /* ヒープ */
 
    static_var++;  /* 関数呼び出しをまたいで値が保持される */
    *heap_var = static_var * 10;
 
    printf("local:  %d (addr: %p)\n", local_var, (void *)&local_var);
    printf("static: %d (addr: %p)\n", static_var, (void *)&static_var);
    printf("heap:   %d (addr: %p)\n", *heap_var, (void *)heap_var);
    printf("global: %d (addr: %p)\n", global_var, (void *)&global_var);
 
    free(heap_var);  /* ヒープ領域の解放 */
}
 
int main(void) {
    printf("=== 1回目の呼び出し ===\n");
    demonstrate_memory();
    printf("\n=== 2回目の呼び出し ===\n");
    demonstrate_memory();
    return 0;
}
/*
 * 出力例:
 * === 1回目の呼び出し ===
 * local:  42 (addr: 0x7ffc...)
 * static: 1  (addr: 0x601...)
 * heap:   10 (addr: 0x1a3...)
 * global: 100 (addr: 0x601...)
 *
 * === 2回目の呼び出し ===
 * local:  42 (addr: 0x7ffc...)    ← localは毎回初期化される
 * static: 2  (addr: 0x601...)     ← staticは値が保持される
 * heap:   20 (addr: 0x1a3...)
 * global: 100 (addr: 0x601...)
 */

10 REM フィボナッチ数列（goto使用版）
20 LET A = 0
30 LET B = 1
40 LET N = 0
50 PRINT A
60 LET N = N + 1
70 IF N >= 10 THEN GOTO 120
80 LET T = A + B
90 LET A = B
100 LET B = T
110 GOTO 50
120 END

def fibonacci_sequence(count):
    """
    構造化されたフィボナッチ数列の生成。
    - goto文なし、while ループで反復を表現
    - 関数として切り出されており、再利用可能
    - 変数のスコープが関数内に限定されている
    """
    a, b = 0, 1
    result = []
    n = 0
 
    while n < count:       # 反復: 指定回数まで繰り返す
        result.append(a)   # 順次: 結果リストに追加
        a, b = b, a + b    # 順次: 次の項を計算
        n += 1             # 順次: カウンタを更新
 
    return result
 
# 実行例
fib = fibonacci_sequence(10)
print(fib)
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# 早期リターン（ガード節）の例
# 厳密な単一出口には反するが、可読性が高い
 
def calculate_discount(customer, amount):
    """ガード節による早期リターンの例"""
    # ガード節: 異常ケースを先に処理して早期に返す
    if customer is None:
        return 0
    if amount <= 0:
        return 0
    if not customer.get("is_active", False):
        return 0
 
    # 正常ケースの処理（ネストが浅くなる）
    base_rate = 0.05
    if customer.get("is_vip", False):
        base_rate = 0.15
    elif customer.get("years", 0) >= 3:
        base_rate = 0.10
 
    return amount * base_rate

"""
学生成績管理システム（手続き型プログラミングの実践例）
 
設計方針:
- 関数によるモジュール化（各関数は単一責任）
- データは辞書のリストとして管理
- グローバル変数は使用しない
- 各関数は入力（引数）と出力（返り値）が明確
"""
 
 
# ===== データ操作関数 =====
 
def create_student(name, student_id):
    """学生データを作成する"""
    return {
        "name": name,
        "id": student_id,
        "scores": {}
    }
 
 
def add_score(student, subject, score):
    """学生に科目の成績を追加する（新しい辞書を返す）"""
    new_scores = dict(student["scores"])
    new_scores[subject] = score
    return {
        "name": student["name"],
        "id": student["id"],
        "scores": new_scores
    }
 
 
def calculate_average(student):
    """学生の平均点を計算する"""
    scores = student["scores"]
    if not scores:
        return 0.0
    total = 0
    count = 0
    for score in scores.values():
        total += score
        count += 1
    return total / count
 
 
def determine_grade(average):
    """平均点から評定を判定する"""
    if average >= 90:
        return "A"
    elif average >= 80:
        return "B"
    elif average >= 70:
        return "C"
    elif average >= 60:
        return "D"
    else:
        return "F"
 
 
# ===== 集計関数 =====
 
def find_top_students(students, n=3):
    """上位n名の学生を取得する"""
    averages = []
    for student in students:
        avg = calculate_average(student)
        averages.append((student, avg))
 
    # 平均点で降順ソート（選択ソートで実装）
    for i in range(len(averages)):
        max_idx = i
        for j in range(i + 1, len(averages)):
            if averages[j][1] > averages[max_idx][1]:
                max_idx = j
        averages[i], averages[max_idx] = averages[max_idx], averages[i]
 
    result = []
    for i in range(min(n, len(averages))):
        result.append(averages[i])
    return result
 
 
def calculate_subject_stats(students, subject):
    """特定科目の統計情報（平均、最高、最低）を計算する"""
    scores = []
    for student in students:
        if subject in student["scores"]:
            scores.append(student["scores"][subject])
 
    if not scores:
        return {"subject": subject, "count": 0, "avg": 0, "max": 0, "min": 0}
 
    total = 0
    max_score = scores[0]
    min_score = scores[0]
    for score in scores:
        total += score
        if score > max_score:
            max_score = score
        if score < min_score:
            min_score = score
 
    return {
        "subject": subject,
        "count": len(scores),
        "avg": total / len(scores),
        "max": max_score,
        "min": min_score,
    }
 
 
# ===== 表示関数 =====
 
def format_student_report(student):
    """学生の成績レポートを文字列として整形する"""
    avg = calculate_average(student)
    grade = determine_grade(avg)
 
    lines = []
    lines.append(f"学生名: {student['name']} (ID: {student['id']})")
    lines.append("-" * 40)
 
    for subject, score in student["scores"].items():
        lines.append(f"  {subject:12s}: {score:5.1f}")
 
    lines.append("-" * 40)
    lines.append(f"  {'平均点':12s}: {avg:5.1f}")
    lines.append(f"  {'評定':12s}:     {grade}")
 
    return "\n".join(lines)
 
 
def format_ranking(top_students):
    """ランキングを文字列として整形する"""
    lines = []
    lines.append("=== 成績上位者 ===")
    for rank, (student, avg) in enumerate(top_students, 1):
        grade = determine_grade(avg)
        lines.append(f"  {rank}位: {student['name']} "
                      f"(平均: {avg:.1f}, 評定: {grade})")
    return "\n".join(lines)
 
 
# ===== メイン処理 =====
 
def main():
    """メイン処理: データの生成、処理、表示を順に実行する"""
 
    # データの準備
    students = [
        create_student("佐藤太郎", "S001"),
        create_student("鈴木花子", "S002"),
        create_student("田中一郎", "S003"),
        create_student("高橋美咲", "S004"),
        create_student("伊藤健太", "S005"),
    ]
 
    # 成績データの設定
    score_data = [
        ("S001", [("数学", 85), ("英語", 72), ("物理", 90)]),
        ("S002", [("数学", 92), ("英語", 88), ("物理", 76)]),
        ("S003", [("数学", 68), ("英語", 55), ("物理", 73)]),
        ("S004", [("数学", 95), ("英語", 91), ("物理", 88)]),
        ("S005", [("数学", 78), ("英語", 82), ("物理", 65)]),
    ]
 
    # 成績の登録
    for sid, scores in score_data:
        for i in range(len(students)):
            if students[i]["id"] == sid:
                for subject, score in scores:
                    students[i] = add_score(students[i], subject, score)
 
    # 個別レポートの表示
    print("=" * 40)
    print("      個別成績レポート")
    print("=" * 40)
    for student in students:
        print()
        print(format_student_report(student))
 
    # ランキングの表示
    print()
    top = find_top_students(students, 3)
    print(format_ranking(top))
 
    # 科目別統計の表示
    print()
    print("=== 科目別統計 ===")
    for subject in ["数学", "英語", "物理"]:
        stats = calculate_subject_stats(students, subject)
        print(f"  {stats['subject']}: "
              f"平均={stats['avg']:.1f}, "
              f"最高={stats['max']:.0f}, "
              f"最低={stats['min']:.0f}")
 
 
# エントリポイント
if __name__ == "__main__":
    main()

/* === stack.h（インターフェース: 公開される宣言） === */
#ifndef STACK_H
#define STACK_H
 
#define STACK_MAX_SIZE 100
 
typedef struct {
    int data[STACK_MAX_SIZE];
    int top;
} Stack;
 
/* 公開関数の宣言（利用者はこれだけ知ればよい） */
void stack_init(Stack *s);
int  stack_push(Stack *s, int value);
int  stack_pop(Stack *s, int *value);
int  stack_peek(const Stack *s, int *value);
int  stack_is_empty(const Stack *s);
int  stack_size(const Stack *s);
 
#endif /* STACK_H */

/* === stack.c（実装: 内部の詳細） === */
#include "stack.h"
#include <stdio.h>
 
void stack_init(Stack *s) {
    s->top = -1;
}
 
int stack_push(Stack *s, int value) {
    if (s->top >= STACK_MAX_SIZE - 1) {
        fprintf(stderr, "Stack overflow\n");
        return -1;
    }
    s->top++;
    s->data[s->top] = value;
    return 0;
}
 
int stack_pop(Stack *s, int *value) {
    if (s->top < 0) {
        fprintf(stderr, "Stack underflow\n");
        return -1;
    }
    *value = s->data[s->top];
    s->top--;
    return 0;
}
 
int stack_peek(const Stack *s, int *value) {
    if (s->top < 0) {
        return -1;
    }
    *value = s->data[s->top];
    return 0;
}
 
int stack_is_empty(const Stack *s) {
    return s->top < 0;
}
 
int stack_size(const Stack *s) {
    return s->top + 1;
}

/* === main.c（利用コード） === */
#include <stdio.h>
#include "stack.h"
 
int main(void) {
    Stack s;
    stack_init(&s);
 
    /* 値をプッシュ */
    stack_push(&s, 10);
    stack_push(&s, 20);
    stack_push(&s, 30);
 
    printf("スタックサイズ: %d\n", stack_size(&s));  /* 3 */
 
    /* 値をポップ */
    int value;
    while (!stack_is_empty(&s)) {
        stack_pop(&s, &value);
        printf("ポップ: %d\n", value);
    }
    /* ポップ: 30, ポップ: 20, ポップ: 10 */
 
    return 0;
}

# === 命令型スタイル ===
 
def sum_of_even_squares_imperative(numbers):
    """
    命令型: 状態変数 total を逐次更新する
    """
    total = 0                         # 状態の初期化
    for num in numbers:               # 反復
        if num % 2 == 0:              # 選択
            total += num ** 2         # 状態の更新（代入）
    return total
 
 
# === 関数型スタイル ===
 
def sum_of_even_squares_functional(numbers):
    """
    関数型: 関数の合成でデータを変換する
    中間状態を持たない
    """
    from functools import reduce
    return reduce(
        lambda acc, x: acc + x,       # 集約関数
        map(
            lambda x: x ** 2,         # 変換関数
            filter(
                lambda x: x % 2 == 0, # フィルタ関数
                numbers
            )
        ),
        0                             # 初期値
    )
 
 
# === Python的な関数型スタイル（リスト内包表記） ===
 
def sum_of_even_squares_pythonic(numbers):
    """
    Pythonらしい宣言的スタイル
    """
    return sum(x ** 2 for x in numbers if x % 2 == 0)
 
 
# 実行例（いずれも同じ結果）
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(sum_of_even_squares_imperative(data))    # 220
print(sum_of_even_squares_functional(data))    # 220
print(sum_of_even_squares_pythonic(data))      # 220
 
# 2^2 + 4^2 + 6^2 + 8^2 + 10^2 = 4 + 16 + 36 + 64 + 100 = 220

# 手続き型: データは辞書、操作は独立した関数
 
def create_bank_account(owner, balance=0):
    """口座データを作成する"""
    return {"owner": owner, "balance": balance, "history": []}
 
def deposit(account, amount):
    """入金する"""
    if amount <= 0:
        print("入金額は正の数でなければならない")
        return account
    new_balance = account["balance"] + amount
    new_history = list(account["history"])
    new_history.append(f"入金: +{amount}")
    return {
        "owner": account["owner"],
        "balance": new_balance,
        "history": new_history,
    }
 
def withdraw(account, amount):
    """出金する"""
    if amount <= 0:
        print("出金額は正の数でなければならない")
        return account
    if amount > account["balance"]:
        print("残高不足")
        return account
    new_balance = account["balance"] - amount
    new_history = list(account["history"])
    new_history.append(f"出金: -{amount}")
    return {
        "owner": account["owner"],
        "balance": new_balance,
        "history": new_history,
    }
 
def get_balance_info(account):
    """残高情報を取得する"""
    return f"{account['owner']}の残高: {account['balance']}円"
 
# 利用例
acc = create_bank_account("佐藤太郎", 10000)
acc = deposit(acc, 5000)
acc = withdraw(acc, 3000)
print(get_balance_info(acc))  # 佐藤太郎の残高: 12000円

class BankAccount:
    """
    OOP: データ（残高、履歴）と操作（入出金）を
    一つのクラスにカプセル化する
    """
 
    def __init__(self, owner, balance=0):
        self._owner = owner         # プライベート属性
        self._balance = balance
        self._history = []
 
    def deposit(self, amount):
        """入金する"""
        if amount <= 0:
            raise ValueError("入金額は正の数でなければならない")
        self._balance += amount
        self._history.append(f"入金: +{amount}")
 
    def withdraw(self, amount):
        """出金する"""
        if amount <= 0:
            raise ValueError("出金額は正の数でなければならない")
        if amount > self._balance:
            raise ValueError("残高不足")
        self._balance -= amount
        self._history.append(f"出金: -{amount}")
 
    @property
    def balance(self):
        return self._balance
 
    def __str__(self):
        return f"{self._owner}の残高: {self._balance}円"
 
 
# 利用例
acc = BankAccount("佐藤太郎", 10000)
acc.deposit(5000)
acc.withdraw(3000)
print(acc)  # 佐藤太郎の残高: 12000円

"""
現代的なPythonにおけるパラダイムの融合例:
ログファイルを解析してエラー統計を生成する
"""
from collections import defaultdict
from datetime import datetime
 
 
# === 命令型スタイル ===
 
def analyze_logs_imperative(log_lines):
    """命令型: 明示的なループと状態管理"""
    error_counts = {}
    error_times = []
 
    for line in log_lines:
        # 各行を解析
        parts = line.strip().split(" ", 3)
        if len(parts) < 4:
            continue
 
        timestamp_str = parts[0] + " " + parts[1]
        level = parts[2].strip("[]")
        message = parts[3]
 
        if level == "ERROR":
            # エラーカウントの更新
            if message in error_counts:
                error_counts[message] += 1
            else:
                error_counts[message] = 1
 
            # タイムスタンプの記録
            try:
                ts = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
                error_times.append(ts)
            except ValueError:
                pass
 
    # 最も多いエラーを見つける
    most_common_error = None
    max_count = 0
    for error, count in error_counts.items():
        if count > max_count:
            max_count = count
            most_common_error = error
 
    return {
        "total_errors": len(error_times),
        "unique_errors": len(error_counts),
        "most_common": most_common_error,
        "most_common_count": max_count,
        "error_counts": error_counts,
    }
 
 
# === 宣言型/関数型スタイル ===
 
def analyze_logs_declarative(log_lines):
    """宣言型: 高階関数とジェネレータの活用"""
 
    def parse_line(line):
        """行をパースして構造化データに変換"""
        parts = line.strip().split(" ", 3)
        if len(parts) < 4:
            return None
        return {
            "timestamp": parts[0] + " " + parts[1],
            "level": parts[2].strip("[]"),
            "message": parts[3],
        }
 
    # データ変換パイプライン
    parsed = (parse_line(line) for line in log_lines)           # 遅延評価
    valid = (entry for entry in parsed if entry is not None)    # フィルタ
    errors = [entry for entry in valid if entry["level"] == "ERROR"]
 
    # 集計（defaultdictで簡潔に）
    error_counts = defaultdict(int)
    for error in errors:
        error_counts[error["message"]] += 1
 
    most_common = max(error_counts.items(), key=lambda x: x[1],
                      default=(None, 0))
 
    return {
        "total_errors": len(errors),
        "unique_errors": len(error_counts),
        "most_common": most_common[0],
        "most_common_count": most_common[1],
        "error_counts": dict(error_counts),
    }
 
 
# テスト用データ
sample_logs = [
    "2024-01-15 10:23:45 [INFO] Application started",
    "2024-01-15 10:24:01 [ERROR] Database connection failed",
    "2024-01-15 10:24:15 [ERROR] Database connection failed",
    "2024-01-15 10:25:30 [WARNING] High memory usage",
    "2024-01-15 10:26:00 [ERROR] File not found: config.yml",
    "2024-01-15 10:27:12 [INFO] Retry successful",
    "2024-01-15 10:28:45 [ERROR] Database connection failed",
    "2024-01-15 10:30:00 [ERROR] Timeout waiting for response",
]
 
# 両方のアプローチで同じ結果が得られる
result1 = analyze_logs_imperative(sample_logs)
result2 = analyze_logs_declarative(sample_logs)
 
print(f"総エラー数: {result1['total_errors']}")        # 5
print(f"一意のエラー数: {result1['unique_errors']}")     # 3
print(f"最多エラー: {result1['most_common']}")           # Database connection failed
print(f"最多エラー回数: {result1['most_common_count']}")  # 3

// Rust における命令型スタイルと関数型スタイルの比較
 
/// 命令型スタイル: 明示的なループと可変変数
fn word_frequency_imperative(text: &str) -> Vec<(String, usize)> {
    use std::collections::HashMap;
 
    let mut counts: HashMap<String, usize> = HashMap::new();
 
    // 命令型ループ
    for word in text.split_whitespace() {
        let word_lower = word.to_lowercase();
        // パターンマッチで安全にカウントを更新
        let count = counts.entry(word_lower).or_insert(0);
        *count += 1;
    }
 
    // 結果をベクタに変換してソート
    let mut result: Vec<(String, usize)> = counts.into_iter().collect();
    result.sort_by(|a, b| b.1.cmp(&a.1));
    result
}
 
/// 関数型スタイル: イテレータチェーン
fn word_frequency_functional(text: &str) -> Vec<(String, usize)> {
    use std::collections::HashMap;
 
    let counts: HashMap<String, usize> = text
        .split_whitespace()
        .map(|w| w.to_lowercase())
        .fold(HashMap::new(), |mut acc, word| {
            *acc.entry(word).or_insert(0) += 1;
            acc
        });
 
    let mut result: Vec<_> = counts.into_iter().collect();
    result.sort_by(|a, b| b.1.cmp(&a.1));
    result
}
 
fn main() {
    let text = "the quick brown fox jumps over the lazy dog the fox";
 
    let result = word_frequency_imperative(text);
    for (word, count) in &result {
        println!("{}: {}", word, count);
    }
    // the: 3
    // fox: 2
    // quick: 1
    // brown: 1
    // ...
}

package main
 
import (
    "fmt"
    "math"
    "sort"
    "strings"
)
 
// Point は二次元平面上の点を表す
type Point struct {
    X, Y float64
}
 
// Distance は2点間のユークリッド距離を計算する
func Distance(p1, p2 Point) float64 {
    dx := p1.X - p2.X
    dy := p1.Y - p2.Y
    return math.Sqrt(dx*dx + dy*dy)
}
 
// FindClosestPair は点の集合から最も近い2点の組を見つける
// 命令型スタイル: 明示的な二重ループ
func FindClosestPair(points []Point) (Point, Point, float64) {
    if len(points) < 2 {
        return Point{}, Point{}, -1
    }
 
    minDist := math.Inf(1)
    var closest1, closest2 Point
 
    // 命令型の二重ループで全ての組み合わせを検査
    for i := 0; i < len(points); i++ {
        for j := i + 1; j < len(points); j++ {
            dist := Distance(points[i], points[j])
            if dist < minDist {
                minDist = dist
                closest1 = points[i]
                closest2 = points[j]
            }
        }
    }
 
    return closest1, closest2, minDist
}
 
// GroupByQuadrant は点を象限ごとに分類する
func GroupByQuadrant(points []Point) map[string][]Point {
    groups := map[string][]Point{
        "第1象限": {},
        "第2象限": {},
        "第3象限": {},
        "第4象限": {},
        "軸上":    {},
    }
 
    for _, p := range points {
        switch {
        case p.X > 0 && p.Y > 0:
            groups["第1象限"] = append(groups["第1象限"], p)
        case p.X < 0 && p.Y > 0:
            groups["第2象限"] = append(groups["第2象限"], p)
        case p.X < 0 && p.Y < 0:
            groups["第3象限"] = append(groups["第3象限"], p)
        case p.X > 0 && p.Y < 0:
            groups["第4象限"] = append(groups["第4象限"], p)
        default:
            groups["軸上"] = append(groups["軸上"], p)
        }
    }
 
    return groups
}
 
func main() {
    points := []Point{
        {1.0, 2.0}, {3.0, 4.0}, {1.5, 2.5},
        {-1.0, 3.0}, {-2.0, -1.0}, {4.0, -2.0},
        {0.0, 5.0},
    }
 
    // 最近点対の探索
    p1, p2, dist := FindClosestPair(points)
    fmt.Printf("最近点対: (%.1f, %.1f) と (%.1f, %.1f)\n", p1.X, p1.Y, p2.X, p2.Y)
    fmt.Printf("距離: %.4f\n", dist)
 
    // 象限ごとの分類
    groups := GroupByQuadrant(points)
    for quadrant, pts := range groups {
        if len(pts) > 0 {
            strs := make([]string, len(pts))
            for i, p := range pts {
                strs[i] = fmt.Sprintf("(%.1f, %.1f)", p.X, p.Y)
            }
            fmt.Printf("%s: %s\n", quadrant, strings.Join(strs, ", "))
        }
    }
 
    // ソート（命令型: sort.Sliceで比較関数を指定）
    sort.Slice(points, func(i, j int) bool {
        d1 := Distance(points[i], Point{0, 0})
        d2 := Distance(points[j], Point{0, 0})
        return d1 < d2
    })
 
    fmt.Println("\n原点からの距離でソート:")
    for _, p := range points {
        d := Distance(p, Point{0, 0})
        fmt.Printf("  (%.1f, %.1f) -> 距離 %.4f\n", p.X, p.Y, d)
    }
}

import java.util.*;
import java.util.stream.*;
 
public class ImperativeVsStreams {
 
    record Employee(String name, String department, int salary) {}
 
    /**
     * 命令型スタイル: 部門ごとの平均給与を計算する
     */
    static Map<String, Double> avgSalaryImperative(List<Employee> employees) {
        // 部門ごとの合計と人数を集計
        Map<String, Integer> totalByDept = new HashMap<>();
        Map<String, Integer> countByDept = new HashMap<>();
 
        for (Employee emp : employees) {
            String dept = emp.department();
            // 合計の更新
            if (totalByDept.containsKey(dept)) {
                totalByDept.put(dept, totalByDept.get(dept) + emp.salary());
            } else {
                totalByDept.put(dept, emp.salary());
            }
            // 人数の更新
            if (countByDept.containsKey(dept)) {
                countByDept.put(dept, countByDept.get(dept) + 1);
            } else {
                countByDept.put(dept, 1);
            }
        }
 
        // 平均の計算
        Map<String, Double> result = new HashMap<>();
        for (String dept : totalByDept.keySet()) {
            double avg = (double) totalByDept.get(dept) / countByDept.get(dept);
            result.put(dept, avg);
        }
        return result;
    }
 
    /**
     * ストリームAPI（宣言型スタイル）: 同じ処理をパイプラインで記述
     */
    static Map<String, Double> avgSalaryStreams(List<Employee> employees) {
        return employees.stream()
            .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.averagingInt(Employee::salary)
            ));
    }
 
    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee("佐藤", "開発", 600000),
            new Employee("鈴木", "開発", 550000),
            new Employee("田中", "営業", 500000),
            new Employee("高橋", "営業", 480000),
            new Employee("伊藤", "人事", 520000),
            new Employee("渡辺", "開発", 700000),
            new Employee("山本", "営業", 530000)
        );
 
        // 命令型
        Map<String, Double> result1 = avgSalaryImperative(employees);
        System.out.println("命令型: " + result1);
 
        // ストリームAPI
        Map<String, Double> result2 = avgSalaryStreams(employees);
        System.out.println("ストリーム: " + result2);
 
        // どちらも同じ結果:
        // {開発=616666.67, 営業=503333.33, 人事=520000.0}
    }
}

# ===== アンチパターン: グローバル状態の乱用 =====
 
# グローバル変数で全ての状態を管理
current_user = None
cart_items = []
total_price = 0
discount_rate = 0
is_logged_in = False
error_message = ""
 
def login(username, password):
    global current_user, is_logged_in, error_message
    # 認証処理（省略）
    current_user = username
    is_logged_in = True
    error_message = ""
 
def add_to_cart(item, price):
    global cart_items, total_price, error_message
    if not is_logged_in:          # 別のグローバル変数に依存
        error_message = "ログインしてください"
        return
    cart_items.append({"item": item, "price": price})
    total_price += price          # グローバル変数を直接変更
 
def apply_discount(rate):
    global discount_rate, total_price
    discount_rate = rate
    total_price = total_price * (1 - rate)  # 適用済みかの判定がない
 
def checkout():
    global cart_items, total_price, error_message
    if not is_logged_in:
        error_message = "ログインしてください"
        return
    if total_price <= 0:
        error_message = "カートが空です"
        return
    # 注文処理...
    print(f"{current_user}の注文: {total_price}円")
    cart_items = []
    total_price = 0
 
# 問題点:
# 1. apply_discount() を2回呼ぶと割引が二重適用される
# 2. どの関数がどのグローバル変数を変更するか追跡が困難
# 3. テスト時にグローバル状態の初期化が必要
# 4. 並行実行すると状態が競合する
 
 
# ===== 改善版: 状態をオブジェクトに局所化 =====
 
class ShoppingSession:
    """状態をクラス内に閉じ込め、操作を制御する"""
 
    def __init__(self):
        self._user = None
        self._cart = []
        self._discount_applied = False
 
    def login(self, username, password):
        # 認証処理
        self._user = username
 
    @property
    def is_logged_in(self):
        return self._user is not None
 
    def add_to_cart(self, item, price):
        if not self.is_logged_in:
            raise RuntimeError("ログインしてください")
        self._cart.append({"item": item, "price": price})
 
    def apply_discount(self, rate):
        if self._discount_applied:
            raise RuntimeError("割引は一度のみ適用可能です")
        self._discount_applied = True
        self._discount_rate = rate
 
    @property
    def total(self):
        subtotal = sum(item["price"] for item in self._cart)
        if self._discount_applied:
            subtotal *= (1 - self._discount_rate)
        return subtotal
 
    def checkout(self):
        if not self.is_logged_in:
            raise RuntimeError("ログインしてください")
        if not self._cart:
            raise RuntimeError("カートが空です")
        order_total = self.total
        print(f"{self._user}の注文: {order_total}円")
        self._cart = []
        self._discount_applied = False
        return order_total

# ===== アンチパターン: 深いネストのスパゲッティコード =====
 
def process_order_bad(order):
    """深いネストの悪い例"""
    if order is not None:
        if order.get("status") == "pending":
            if order.get("items"):
                total = 0
                for item in order["items"]:
                    if item.get("price") is not None:
                        if item["price"] > 0:
                            if item.get("quantity", 0) > 0:
                                subtotal = item["price"] * item["quantity"]
                                if order.get("discount"):
                                    if order["discount"] > 0:
                                        if order["discount"] <= 0.5:
                                            subtotal *= (1 - order["discount"])
                                        else:
                                            print("割引率が大きすぎる")
                                            return None
                                total += subtotal
                            else:
                                print("数量が不正")
                                return None
                        else:
                            print("価格が不正")
                            return None
                    else:
                        print("価格が未設定")
                        return None
                return total
            else:
                print("商品がない")
                return None
        else:
            print("ステータスが不正")
            return None
    else:
        print("注文がない")
        return None
 
 
# ===== 改善版: ガード節とヘルパー関数で平坦化 =====
 
def validate_order(order):
    """注文の基本検証"""
    if order is None:
        return False, "注文がない"
    if order.get("status") != "pending":
        return False, "ステータスが不正"
    if not order.get("items"):
        return False, "商品がない"
    return True, ""
 
 
def validate_item(item):
    """商品アイテムの検証"""
    if item.get("price") is None:
        return False, "価格が未設定"
    if item["price"] <= 0:
        return False, "価格が不正"
    if item.get("quantity", 0) <= 0:
        return False, "数量が不正"
    return True, ""
 
 
def validate_discount(discount):
    """割引率の検証"""
    if discount is None or discount <= 0:
        return 1.0  # 割引なし
    if discount > 0.5:
        raise ValueError("割引率が大きすぎる")
    return 1.0 - discount
 
 
def calculate_item_subtotal(item, discount_rate):
    """アイテムの小計を計算する"""
    return item["price"] * item["quantity"] * discount_rate
 
 
def process_order_good(order):
    """改善版: ガード節とヘルパー関数で平坦化"""
    # ガード節: 異常ケースを早期に排除
    is_valid, error = validate_order(order)
    if not is_valid:
        print(error)
        return None
 
    # 割引率の検証
    try:
        discount_multiplier = validate_discount(order.get("discount"))
    except ValueError as e:
        print(str(e))
        return None
 
    # メイン処理: 合計計算
    total = 0
    for item in order["items"]:
        is_valid, error = validate_item(item)
        if not is_valid:
            print(error)
            return None
        total += calculate_item_subtotal(item, discount_multiplier)
 
    return total