// ペッパー（暗号化ラッピング）の実装
import crypto from 'crypto';
import argon2 from 'argon2';
 
const PEPPER_KEY = Buffer.from(process.env.PEPPER_KEY!, 'hex'); // 32バイト
 
// パスワードハッシュ + ペッパー暗号化
async function hashPasswordWithPepper(password: string): Promise<string> {
  // Step 1: Argon2id でハッシュ化
  const hash = await argon2.hash(password, {
    type: argon2.argon2id,
    memoryCost: 65536,
    timeCost: 3,
    parallelism: 4,
  });
 
  // Step 2: AES-256-GCM で暗号化
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-gcm', PEPPER_KEY, iv);
  const encrypted = Buffer.concat([
    cipher.update(hash, 'utf8'),
    cipher.final(),
  ]);
  const authTag = cipher.getAuthTag();
 
  // iv + authTag + encrypted を結合して返す
  return Buffer.concat([iv, authTag, encrypted]).toString('base64');
}
 
// パスワード検証
async function verifyPasswordWithPepper(
  password: string,
  stored: string
): Promise<boolean> {
  const data = Buffer.from(stored, 'base64');
 
  // 分離: iv(16) + authTag(16) + encrypted(残り)
  const iv = data.subarray(0, 16);
  const authTag = data.subarray(16, 32);
  const encrypted = data.subarray(32);
 
  // Step 1: AES-256-GCM で復号
  const decipher = crypto.createDecipheriv('aes-256-gcm', PEPPER_KEY, iv);
  decipher.setAuthTag(authTag);
  const hash = decipher.update(encrypted) + decipher.final('utf8');
 
  // Step 2: Argon2 で検証
  return argon2.verify(hash, password);
}

// bcrypt 実装
import bcrypt from 'bcrypt';
 
const SALT_ROUNDS = 12; // コスト係数（2^12 = 4096回のイテレーション）
 
// パスワードのハッシュ化
async function hashPassword(password: string): Promise<string> {
  return bcrypt.hash(password, SALT_ROUNDS);
}
 
// パスワードの検証
async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return bcrypt.compare(password, hash);
}
 
// 使用例
const hash = await hashPassword('mySecurePassword123!');
// "$2b$12$LJ3m4ys3Gk8v0f2xKb2I4O..."
 
const isValid = await verifyPassword('mySecurePassword123!', hash);
// true
 
// bcrypt の72バイト制限に対するプレハッシュ
import crypto from 'crypto';
 
async function hashLongPassword(password: string): Promise<string> {
  // SHA-256 でプレハッシュ（Base64で44文字、72バイト以内）
  const preHash = crypto.createHash('sha256').update(password).digest('base64');
  return bcrypt.hash(preHash, SALT_ROUNDS);
}
 
async function verifyLongPassword(password: string, hash: string): Promise<boolean> {
  const preHash = crypto.createHash('sha256').update(password).digest('base64');
  return bcrypt.compare(preHash, hash);
}

// Argon2 実装（推奨）
import argon2 from 'argon2';
 
// Argon2id（推奨バリアント）
async function hashPassword(password: string): Promise<string> {
  return argon2.hash(password, {
    type: argon2.argon2id,  // Argon2id: サイドチャネル + GPU 両対策
    memoryCost: 65536,       // 64MB のメモリ使用
    timeCost: 3,             // 3回のイテレーション
    parallelism: 4,          // 4つの並列レーン
    saltLength: 16,          // 16バイトのソルト
    hashLength: 32,          // 32バイトのハッシュ出力
  });
}
 
async function verifyPassword(password: string, hash: string): Promise<boolean> {
  return argon2.verify(hash, password);
}
 
// ハッシュ結果例:
// "$argon2id$v=19$m=65536,t=3,p=4$c29tZXNhbHQ$..."
// ↑ アルゴリズム、パラメータ、ソルト、ハッシュが全て含まれる
 
// パスワードが変更された時のリハッシュ確認
async function needsRehash(hash: string): Promise<boolean> {
  return argon2.needsRehash(hash, {
    type: argon2.argon2id,
    memoryCost: 65536,
    timeCost: 3,
    parallelism: 4,
  });
}
 
// ログイン時の透過的リハッシュ
async function loginWithRehash(
  password: string,
  storedHash: string,
  userId: string
): Promise<boolean> {
  const isValid = await argon2.verify(storedHash, password);
 
  if (isValid && await needsRehash(storedHash)) {
    // パラメータが古い場合、新しいパラメータでリハッシュ
    const newHash = await hashPassword(password);
    await db.user.update({
      where: { id: userId },
      data: { password: newHash },
    });
    console.log(`Rehashed password for user ${userId}`);
  }
 
  return isValid;
}

// コスト係数のベンチマーク
async function benchmarkHashParameters() {
  const password = 'test-password-for-benchmarking';
 
  // bcrypt ベンチマーク
  for (const cost of [10, 11, 12, 13, 14]) {
    const start = performance.now();
    await bcrypt.hash(password, cost);
    const duration = performance.now() - start;
    console.log(`bcrypt cost=${cost}: ${duration.toFixed(0)}ms`);
  }
 
  // Argon2id ベンチマーク
  const configs = [
    { memoryCost: 19456, timeCost: 2, parallelism: 1 },
    { memoryCost: 47104, timeCost: 1, parallelism: 1 },
    { memoryCost: 65536, timeCost: 3, parallelism: 4 },
    { memoryCost: 131072, timeCost: 4, parallelism: 4 },
  ];
 
  for (const config of configs) {
    const start = performance.now();
    await argon2.hash(password, { type: argon2.argon2id, ...config });
    const duration = performance.now() - start;
    console.log(
      `argon2id m=${config.memoryCost} t=${config.timeCost} p=${config.parallelism}: ${duration.toFixed(0)}ms`
    );
  }
}
 
// ハッシュ計算の並行制御
class HashService {
  private semaphore: number = 0;
  private readonly maxConcurrent: number;
  private queue: Array<() => void> = [];
 
  constructor(maxConcurrent: number = 10) {
    this.maxConcurrent = maxConcurrent;
  }
 
  async hash(password: string): Promise<string> {
    await this.acquire();
    try {
      return await argon2.hash(password, {
        type: argon2.argon2id,
        memoryCost: 65536,
        timeCost: 3,
        parallelism: 4,
      });
    } finally {
      this.release();
    }
  }
 
  async verify(password: string, hash: string): Promise<boolean> {
    await this.acquire();
    try {
      return await argon2.verify(hash, password);
    } finally {
      this.release();
    }
  }
 
  private async acquire(): Promise<void> {
    if (this.semaphore < this.maxConcurrent) {
      this.semaphore++;
      return;
    }
    return new Promise<void>((resolve) => {
      this.queue.push(resolve);
    });
  }
 
  private release(): void {
    this.semaphore--;
    if (this.queue.length > 0) {
      this.semaphore++;
      const next = this.queue.shift()!;
      next();
    }
  }
}

// モダンなパスワードバリデーション
import { z } from 'zod';
 
const passwordSchema = z.string()
  .min(8, 'パスワードは8文字以上必要です')
  .max(128, 'パスワードは128文字以下にしてください')
  .refine(
    (password) => !isCommonPassword(password),
    'このパスワードはよく使われるため安全ではありません'
  )
  .refine(
    async (password) => !(await isBreachedPassword(password)),
    'このパスワードは過去のデータ漏洩で確認されています'
  );
 
// Have I Been Pwned API でチェック（k-Anonymity モデル）
async function isBreachedPassword(password: string): Promise<boolean> {
  const hash = await sha1(password);
  const prefix = hash.substring(0, 5);
  const suffix = hash.substring(5).toUpperCase();
 
  // k-Anonymity: ハッシュの先頭5文字のみ送信
  // → サーバーにパスワードの情報を漏らさない
  const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
    headers: { 'Add-Padding': 'true' }, // タイミング攻撃防止
  });
  const text = await res.text();
 
  // レスポンス例:
  // "1E4C9B93F3F0682250B6CF8331B7EE68FD8:3"
  // → suffix: 一致するハッシュ, count: 漏洩回数
  return text.split('\n').some((line) => {
    const [hashSuffix] = line.split(':');
    return hashSuffix === suffix;
  });
}
 
// SHA-1 ハッシュ（HIBP API 用）
async function sha1(input: string): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(input);
  const hashBuffer = await crypto.subtle.digest('SHA-1', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase();
}
 
// よく使われるパスワードリスト（上位10万件）
const commonPasswordSet = new Set<string>();
// 起動時にファイルから読み込み
function isCommonPassword(password: string): boolean {
  return commonPasswordSet.has(password.toLowerCase());
}
 
// コンテキスト依存チェック
function containsUserInfo(password: string, userInfo: {
  email: string;
  name?: string;
  username?: string;
}): boolean {
  const lowerPassword = password.toLowerCase();
  const checks = [
    userInfo.email.split('@')[0],
    userInfo.name,
    userInfo.username,
  ].filter(Boolean).map((s) => s!.toLowerCase());
 
  return checks.some((info) => lowerPassword.includes(info));
}

// パスワード強度メーター（zxcvbn）
import zxcvbn from 'zxcvbn';
 
function checkPasswordStrength(password: string, userInputs: string[] = []) {
  const result = zxcvbn(password, userInputs);
 
  return {
    score: result.score,           // 0-4（0=最弱, 4=最強）
    crackTime: result.crack_times_display.offline_slow_hashing_1e4_per_second,
    feedback: result.feedback,     // 改善提案
    warning: result.feedback.warning,
    guesses: result.guesses,       // 推定試行回数
    guessesLog10: result.guesses_log10,
  };
}
 
// 結果例:
// "password" → score: 0, crackTime: "less than a second"
// "correcthorsebatterystaple" → score: 4, crackTime: "centuries"
 
// React コンポーネント
function PasswordStrengthMeter({ password, email }: {
  password: string;
  email: string;
}) {
  const { score, feedback, crackTime } = checkPasswordStrength(
    password,
    [email.split('@')[0]] // ユーザー固有の入力をペナルティ対象に
  );
 
  const labels = ['非常に弱い', '弱い', '普通', '強い', '非常に強い'];
  const colors = ['#ef4444', '#f97316', '#eab308', '#84cc16', '#22c55e'];
 
  if (!password) return null;
 
  return (
    <div className="mt-2">
      {/* 強度バー */}
      <div className="flex gap-1">
        {[0, 1, 2, 3].map((i) => (
          <div
            key={i}
            className="h-1.5 flex-1 rounded-full transition-colors"
            style={{
              backgroundColor: i <= score ? colors[score] : '#e5e7eb',
            }}
          />
        ))}
      </div>
 
      {/* ラベルと推定解読時間 */}
      <div className="flex justify-between mt-1">
        <span className="text-xs" style={{ color: colors[score] }}>
          {labels[score]}
        </span>
        <span className="text-xs text-gray-500">
          解読推定: {crackTime}
        </span>
      </div>
 
      {/* フィードバック */}
      {feedback.warning && (
        <p className="text-xs text-amber-600 mt-1">{feedback.warning}</p>
      )}
      {feedback.suggestions.map((suggestion: string, i: number) => (
        <p key={i} className="text-xs text-gray-500 mt-0.5">{suggestion}</p>
      ))}
    </div>
  );
}

// レート制限の実装（Redis ベース）
class LoginRateLimiter {
  constructor(private redis: Redis) {}
 
  // IP ベースの制限
  async checkIPLimit(ip: string): Promise<{ allowed: boolean; retryAfter?: number }> {
    const key = `login:ip:${ip}`;
    const attempts = await this.redis.incr(key);
 
    if (attempts === 1) {
      await this.redis.expire(key, 900); // 15分
    }
 
    if (attempts > 100) { // IP あたり15分に100回まで
      const ttl = await this.redis.ttl(key);
      return { allowed: false, retryAfter: ttl };
    }
 
    return { allowed: true };
  }
 
  // アカウントベースの制限
  async checkAccountLimit(email: string): Promise<{
    allowed: boolean;
    retryAfter?: number;
    remainingAttempts?: number;
  }> {
    const key = `login:account:${email.toLowerCase()}`;
    const attempts = await this.redis.incr(key);
 
    if (attempts === 1) {
      await this.redis.expire(key, 3600); // 1時間
    }
 
    const maxAttempts = 10;
 
    if (attempts > maxAttempts) {
      const ttl = await this.redis.ttl(key);
      // プログレッシブロックアウト: 失敗が増えるほど長くロック
      const lockoutTime = Math.min(
        Math.pow(2, attempts - maxAttempts) * 60, // 指数バックオフ
        3600 // 最大1時間
      );
      await this.redis.expire(key, lockoutTime);
 
      return {
        allowed: false,
        retryAfter: lockoutTime,
        remainingAttempts: 0,
      };
    }
 
    return {
      allowed: true,
      remainingAttempts: maxAttempts - attempts,
    };
  }
 
  // ログイン成功時にカウンターをリセット
  async onLoginSuccess(email: string): Promise<void> {
    await this.redis.del(`login:account:${email.toLowerCase()}`);
  }
}
 
// ログインエンドポイント
app.post('/auth/login', async (req, res) => {
  const { email, password } = req.body;
  const ip = req.ip!;
 
  // IP 制限チェック
  const ipCheck = await rateLimiter.checkIPLimit(ip);
  if (!ipCheck.allowed) {
    return res.status(429).json({
      error: 'Too many requests',
      retryAfter: ipCheck.retryAfter,
    });
  }
 
  // アカウント制限チェック
  const accountCheck = await rateLimiter.checkAccountLimit(email);
  if (!accountCheck.allowed) {
    return res.status(429).json({
      error: 'Account temporarily locked',
      retryAfter: accountCheck.retryAfter,
    });
  }
 
  // 認証処理
  const user = await db.user.findUnique({ where: { email: email.toLowerCase() } });
 
  // タイミング攻撃防止: ユーザーが存在しなくてもハッシュ計算
  if (!user) {
    await argon2.hash('dummy-password-for-timing', {
      type: argon2.argon2id, memoryCost: 65536, timeCost: 3, parallelism: 4,
    });
    return res.status(401).json({ error: 'Invalid email or password' });
  }
 
  const isValid = await loginWithRehash(password, user.password, user.id);
 
  if (!isValid) {
    return res.status(401).json({
      error: 'Invalid email or password',
      remainingAttempts: accountCheck.remainingAttempts,
    });
  }
 
  // ログイン成功
  await rateLimiter.onLoginSuccess(email);
 
  // 異常検知: 新しい IP / デバイスからのログイン
  await notifyUnusualLogin(user, req);
 
  const tokens = await issueTokens(user);
  res.json(tokens);
});

// パスワードリセットの実装
import crypto from 'crypto';
 
class PasswordResetService {
  constructor(
    private db: Database,
    private redis: Redis,
    private emailService: EmailService,
    private hashService: HashService
  ) {}
 
  // リセットトークン生成
  async createResetToken(email: string): Promise<void> {
    const user = await this.db.user.findUnique({ where: { email } });
 
    // ユーザーが存在しなくても同じレスポンスを返す（ユーザー列挙攻撃対策）
    if (!user) {
      // タイミング攻撃防止
      await new Promise((resolve) => setTimeout(resolve, 200));
      return;
    }
 
    // レート制限: 同一メールへの連続リクエスト制限
    const rateLimitKey = `reset:ratelimit:${email}`;
    const isLimited = await this.redis.exists(rateLimitKey);
    if (isLimited) return;
    await this.redis.setex(rateLimitKey, 300, '1'); // 5分
 
    // 既存のトークンを無効化
    await this.db.resetToken.updateMany({
      where: { userId: user.id, usedAt: null },
      data: { usedAt: new Date() },
    });
 
    // 安全なランダムトークン生成
    const token = crypto.randomBytes(32).toString('hex');
    const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
    await this.db.resetToken.create({
      data: {
        userId: user.id,
        token: hashedToken,            // ハッシュ化して保存
        expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 1時間有効
      },
    });
 
    // リセットリンクを送信（平文トークンをURL に含める）
    await this.emailService.send(email, {
      subject: 'パスワードリセット',
      html: `
        <p>以下のリンクからパスワードをリセットしてください（1時間有効）:</p>
        <a href="${process.env.APP_URL}/reset-password?token=${token}">
          パスワードをリセット
        </a>
        <p>このリクエストに心当たりがない場合は、このメールを無視してください。</p>
        <p>リンクの有効期限: 1時間</p>
      `,
    });
  }
 
  // パスワードリセット実行
  async resetPassword(token: string, newPassword: string): Promise<void> {
    const hashedToken = crypto.createHash('sha256').update(token).digest('hex');
 
    const resetToken = await this.db.resetToken.findFirst({
      where: {
        token: hashedToken,
        expiresAt: { gt: new Date() },   // 有効期限チェック
        usedAt: null,                     // 未使用チェック
      },
      include: { user: true },
    });
 
    if (!resetToken) {
      throw new Error('Invalid or expired reset token');
    }
 
    // 旧パスワードと同じでないか確認
    const isSameAsOld = await argon2.verify(resetToken.user.password, newPassword);
    if (isSameAsOld) {
      throw new Error('New password must be different from the current password');
    }
 
    // パスワード更新
    const hashedPassword = await this.hashService.hash(newPassword);
    await this.db.$transaction([
      this.db.user.update({
        where: { id: resetToken.userId },
        data: { password: hashedPassword },
      }),
      // トークンを使用済みに
      this.db.resetToken.update({
        where: { id: resetToken.id },
        data: { usedAt: new Date() },
      }),
      // 全セッション無効化（パスワード変更時は全デバイスからログアウト）
      this.db.session.deleteMany({
        where: { userId: resetToken.userId },
      }),
    ]);
 
    // パスワード変更通知メールを送信
    await this.emailService.send(resetToken.user.email, {
      subject: 'パスワードが変更されました',
      html: `
        <p>パスワードが正常に変更されました。</p>
        <p>変更日時: ${new Date().toISOString()}</p>
        <p>この変更に心当たりがない場合は、直ちにサポートに連絡してください。</p>
      `,
    });
  }
}

// パスワードマイグレーション実装
import crypto from 'crypto';
import argon2 from 'argon2';
 
class PasswordMigration {
  // ハッシュ形式の判定
  detectHashType(hash: string): 'md5' | 'sha256' | 'bcrypt' | 'argon2' {
    if (hash.startsWith('$argon2')) return 'argon2';
    if (hash.startsWith('$2b$') || hash.startsWith('$2a$')) return 'bcrypt';
    if (hash.length === 32) return 'md5';    // 32文字のhex
    if (hash.length === 64) return 'sha256'; // 64文字のhex
    throw new Error(`Unknown hash format: ${hash.substring(0, 10)}...`);
  }
 
  // 旧ハッシュで検証
  async verifyLegacy(password: string, hash: string, type: string): Promise<boolean> {
    switch (type) {
      case 'md5':
        return crypto.createHash('md5').update(password).digest('hex') === hash;
      case 'sha256':
        return crypto.createHash('sha256').update(password).digest('hex') === hash;
      case 'bcrypt':
        return bcrypt.compare(password, hash);
      case 'argon2':
        return argon2.verify(hash, password);
      default:
        return false;
    }
  }
 
  // ログイン時の透過的マイグレーション
  async loginWithMigration(
    email: string,
    password: string
  ): Promise<{ success: boolean; user?: any }> {
    const user = await db.user.findUnique({ where: { email } });
    if (!user) return { success: false };
 
    const hashType = this.detectHashType(user.password);
    const isValid = await this.verifyLegacy(password, user.password, hashType);
 
    if (!isValid) return { success: false };
 
    // 旧アルゴリズムの場合、Argon2id にリハッシュ
    if (hashType !== 'argon2') {
      const newHash = await argon2.hash(password, {
        type: argon2.argon2id,
        memoryCost: 65536,
        timeCost: 3,
        parallelism: 4,
      });
 
      await db.user.update({
        where: { id: user.id },
        data: { password: newHash },
      });
 
      console.log(`Migrated password hash for user ${user.id}: ${hashType} → argon2id`);
    }
 
    return { success: true, user };
  }
 
  // 一括ラッピングマイグレーション
  async wrapAllHashes(): Promise<{ migrated: number; errors: number }> {
    let migrated = 0;
    let errors = 0;
 
    const users = await db.user.findMany({
      where: {
        NOT: { password: { startsWith: '$argon2' } },
      },
    });
 
    for (const user of users) {
      try {
        // 旧ハッシュを Argon2id でラッピング
        const wrappedHash = await argon2.hash(user.password, {
          type: argon2.argon2id,
          memoryCost: 65536,
          timeCost: 3,
          parallelism: 4,
          raw: false,
        });
 
        await db.user.update({
          where: { id: user.id },
          data: {
            password: wrappedHash,
            passwordWrapped: true, // ラッピング済みフラグ
          },
        });
 
        migrated++;
      } catch (error) {
        errors++;
        console.error(`Failed to migrate user ${user.id}:`, error);
      }
    }
 
    return { migrated, errors };
  }
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()