面接対策：コーディングラウンド — LeetCode ではない、FDE の実践問題

class DataImporter
  REQUIRED_COLUMNS = %w[name email age].freeze
  Result = Struct.new(:imported, :errors, keyword_init: true)
  RowError = Struct.new(:line, :column, :value, :message, keyword_init: true)
 
  def initialize(csv_content)
    @csv_content = csv_content
    @errors = []
    @imported = []
  end
 
  def import
    rows = parse_csv
    rows.each_with_index do |row, i|
      validated = validate_row(row, i + 2)
      @imported << validated if validated
    end
    Result.new(imported: @imported, errors: @errors)
  end
 
  private
 
  def parse_csv
    require "csv"
    CSV.parse(@csv_content, headers: true, liberal_parsing: true)
  rescue CSV::MalformedCSVError => e
    @errors << RowError.new(line: 0, column: nil, value: nil, message: "CSV解析エラー: #{e.message}")
    []
  end
 
  def validate_row(row, line)
    record = {}
    REQUIRED_COLUMNS.each do |col|
      value = row[col]&.strip
      if value.nil? || value.empty?
        @errors << RowError.new(line: line, column: col, value: value, message: "#{col} は必須です")
        return nil
      end
      record[col] = value
    end
    unless record["email"]&.match?(/\A[^@\s]+@[^@\s]+\z/)
      @errors << RowError.new(line: line, column: "email", value: record["email"], message: "メール形式不正")
      return nil
    end
    age = Integer(record["age"], exception: false)
    unless age && (0..150).include?(age)
      @errors << RowError.new(line: line, column: "age", value: record["age"], message: "年齢は0〜150の整数")
      return nil
    end
    record["age"] = age
    record
  end
end

class RateLimiter
  Config = Struct.new(:max_tokens, :refill_rate, :refill_interval, keyword_init: true)
  DEFAULT = Config.new(max_tokens: 100, refill_rate: 10, refill_interval: 1.0)
 
  def initialize
    @buckets = {}
    @configs = {}
    @mutex = Mutex.new
  end
 
  def configure(tenant_id, max_tokens:, refill_rate:, refill_interval: 1.0)
    @configs[tenant_id] = Config.new(max_tokens: max_tokens, refill_rate: refill_rate, refill_interval: refill_interval)
  end
 
  def allow?(tenant_id, cost: 1)
    @mutex.synchronize do
      bucket = fetch_bucket(tenant_id)
      refill(bucket, tenant_id)
      return false unless bucket[:tokens] >= cost
      bucket[:tokens] -= cost
      true
    end
  end
 
  def remaining(tenant_id)
    @mutex.synchronize do
      bucket = fetch_bucket(tenant_id)
      refill(bucket, tenant_id)
      bucket[:tokens].floor
    end
  end
 
  private
 
  def config_for(id) = @configs[id] || DEFAULT
 
  def fetch_bucket(tenant_id)
    config = config_for(tenant_id)
    @buckets[tenant_id] ||= { tokens: config.max_tokens.to_f, last_refill: Time.now }
  end
 
  def refill(bucket, tenant_id)
    config = config_for(tenant_id)
    elapsed = Time.now - bucket[:last_refill]
    bucket[:tokens] = [bucket[:tokens] + (elapsed / config.refill_interval) * config.refill_rate, config.max_tokens.to_f].min
    bucket[:last_refill] = Time.now
  end
end

class WebhookProcessor
  Result = Struct.new(:status, :message, :event_id, keyword_init: true)
 
  def initialize(secret:)
    @secret = secret
    @processed = {}
    @handlers = {}
    @mutex = Mutex.new
  end
 
  def on(event_type, &handler) = @handlers[event_type] = handler
 
  def process(payload:, signature:, event_id:, event_type:)
    return duplicate_result(event_id) if processed?(event_id)
    return Result.new(status: :unauthorized, message: "署名不正", event_id: event_id) unless valid_signature?(payload, signature)
    handler = @handlers[event_type]
    return Result.new(status: :ignored, message: "未登録イベント", event_id: event_id) unless handler
 
    execute(handler, payload, event_id, event_type)
  end
 
  private
 
  def processed?(id) = @mutex.synchronize { @processed.key?(id) }
 
  def duplicate_result(id)
    Result.new(status: :duplicate, message: "処理済み", event_id: id)
  end
 
  def valid_signature?(payload, signature)
    require "openssl"
    expected = OpenSSL::HMAC.hexdigest("SHA256", @secret, payload)
    expected.bytesize == signature.bytesize && expected.bytes.zip(signature.bytes).reduce(0) { |a, (x, y)| a | (x ^ y) }.zero?
  end
 
  def execute(handler, payload, event_id, event_type)
    require "json"
    handler.call(JSON.parse(payload, symbolize_names: true))
    @mutex.synchronize { @processed[event_id] = { type: event_type, at: Time.now } }
    Result.new(status: :ok, message: "処理完了", event_id: event_id)
  rescue JSON::ParserError => e
    Result.new(status: :error, message: "JSON解析エラー: #{e.message}", event_id: event_id)
  rescue StandardError => e
    Result.new(status: :error, message: "処理エラー: #{e.message}", event_id: event_id)
  end
end

class ConfigManager
  SCHEMA = {
    "app_name" => { type: String, required: true },
    "max_connections" => { type: Integer, required: true, range: 1..1000 },
    "log_level" => { type: String, required: true, enum: %w[debug info warn error] },
  }.freeze
 
  def initialize(config_path)
    @path = config_path
    @config = load_config
  end
 
  def validate
    errors = []
    SCHEMA.each do |key, rules|
      value = @config[key]
      if value.nil? && rules[:required]
        errors << { path: key, message: "必須項目が未設定" }
        next
      end
      next if value.nil?
      errors << { path: key, message: "型不正 (期待: #{rules[:type]})" } unless value.is_a?(rules[:type])
      errors << { path: key, message: "範囲外 (#{rules[:range]})" } if rules[:range] && !rules[:range].include?(value)
      errors << { path: key, message: "不許可値 (#{rules[:enum].join(',')})" } if rules[:enum] && !rules[:enum].include?(value)
    end
    errors
  end
 
  def diff(new_config)
    all_keys = (@config.keys + new_config.keys).uniq
    all_keys.filter_map do |key|
      old_val, new_val = @config[key], new_config[key]
      next if old_val == new_val
      { path: key, old: old_val, new: new_val }
    end
  end
 
  def apply(new_config, dry_run: false)
    changes = diff(new_config)
    return { applied: false, changes: changes, reason: "ドライラン" } if dry_run
    merged = @config.merge(new_config)
    save_config(merged)
    @config = merged
    { applied: true, changes: changes }
  end
 
  private
 
  def load_config
    require "yaml"
    File.exist?(@path) ? (YAML.safe_load(File.read(@path)) || {}) : {}
  end
 
  def save_config(config)
    require "yaml"
    File.write(@path, YAML.dump(config))
  end
end

class RetryStrategy
  RetryExhausted = Class.new(StandardError)
  RETRYABLE = [Errno::ECONNRESET, Errno::ETIMEDOUT, IOError].freeze
 
  def initialize(max_retries: 5, base_delay: 0.5, max_delay: 30.0, jitter: :full)
    @max_retries = max_retries
    @base_delay = base_delay
    @max_delay = max_delay
    @jitter = jitter
    @attempts = []
  end
 
  def execute
    attempt = 0
    last_delay = @base_delay
    loop do
      begin
        result = yield(attempt)
        @attempts << { attempt: attempt, outcome: :success }
        return result
      rescue *RETRYABLE => e
        attempt += 1
        raise RetryExhausted, "#{@max_retries}回リトライ後も失敗: #{e.message}" if attempt > @max_retries
        delay = calc_delay(attempt, last_delay)
        last_delay = delay
        @attempts << { attempt: attempt, outcome: :retry, delay: delay }
        sleep(delay)
      end
    end
  end
 
  def stats
    { total: @attempts.size, retries: @attempts.count { _1[:outcome] == :retry }, total_delay: @attempts.sum { _1[:delay] || 0 } }
  end
 
  private
 
  def calc_delay(attempt, last_delay)
    case @jitter
    when :full          then rand * [@base_delay * (2**(attempt - 1)), @max_delay].min
    when :decorrelated  then rand(@base_delay..[last_delay * 3, @max_delay].min)
    else [@base_delay * (2**(attempt - 1)), @max_delay].min
    end
  end
end

class SmartCache
  Entry = Struct.new(:value, :expires_at, keyword_init: true)
 
  def initialize(max_size: 1000, default_ttl: 300)
    @max_size = max_size
    @default_ttl = default_ttl
    @store = {}
    @order = []
    @mutex = Mutex.new
    @stats = { hits: 0, misses: 0, evictions: 0 }
  end
 
  def get(key)
    @mutex.synchronize do
      entry = @store[key]
      return (@stats[:misses] += 1; nil) unless entry
      if entry.expires_at && Time.now > entry.expires_at
        evict(key)
        return (@stats[:misses] += 1; nil)
      end
      touch(key)
      @stats[:hits] += 1
      entry.value
    end
  end
 
  def set(key, value, ttl: @default_ttl)
    @mutex.synchronize do
      evict_lru while @store.size >= @max_size && !@store.key?(key)
      @store[key] = Entry.new(value: value, expires_at: ttl ? Time.now + ttl : nil)
      touch(key)
      value
    end
  end
 
  def fetch(key, ttl: @default_ttl)
    value = get(key)
    return value unless value.nil?
    computed = yield
    set(key, computed, ttl: ttl)
  end
 
  def stats
    @mutex.synchronize do
      total = @stats[:hits] + @stats[:misses]
      rate = total.zero? ? 0.0 : (@stats[:hits].to_f / total * 100).round(2)
      @stats.merge(size: @store.size, hit_rate: "#{rate}%")
    end
  end
 
  private
 
  def touch(key) = (@order.delete(key); @order.push(key))
  def evict(key) = (@store.delete(key); @order.delete(key))
 
  def evict_lru
    key = @order.shift
    return unless key
    @store.delete(key)
    @stats[:evictions] += 1
  end
end

class LogAnalyzer
  Alert = Struct.new(:rule, :count, :threshold, :samples, keyword_init: true)
  LogEntry = Struct.new(:timestamp, :level, :server, :message, keyword_init: true)
 
  def initialize
    @rules = {}
    @buffer = Hash.new { |h, k| h[k] = [] }
    @alerts = []
  end
 
  def add_rule(name, pattern:, threshold:, window:, level: nil)
    @rules[name] = { pattern: pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern),
                      threshold: threshold, window: window, level: level }
  end
 
  def ingest(line, server: "unknown")
    entry = parse(line, server)
    return unless entry
    @rules.each do |name, rule|
      next if rule[:level] && entry.level != rule[:level]
      next unless rule[:pattern].match?(entry.message)
      @buffer[name] << entry
      @buffer[name].reject! { |e| e.timestamp < entry.timestamp - rule[:window] }
      if @buffer[name].size >= rule[:threshold]
        @alerts << Alert.new(rule: name, count: @buffer[name].size, threshold: rule[:threshold],
                             samples: @buffer[name].last(3).map { "[#{_1.server}] #{_1.message}" })
        @buffer[name].clear
      end
    end
  end
 
  def ingest_file(path, server: nil)
    name = server || File.basename(path, ".*")
    File.foreach(path) { |l| ingest(l.chomp, server: name) }
  end
 
  def summary = { total_alerts: @alerts.size, by_rule: @alerts.group_by(&:rule).transform_values(&:size) }
 
  private
 
  def parse(line, server)
    m = line.match(/\A\[(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2})\]\s*(\w+)\s*(.+)\z/)
    return unless m
    LogEntry.new(timestamp: Time.parse(m[1]), level: m[2].downcase, server: server, message: m[3])
  rescue ArgumentError
    nil
  end
end

class SimpleRag
  Chunk = Struct.new(:id, :text, :source, :vector, keyword_init: true)
  Result = Struct.new(:chunk, :score, keyword_init: true)
 
  def initialize(chunk_size: 200, overlap: 50)
    @chunk_size = chunk_size
    @overlap = overlap
    @chunks = []
    @idf = {}
  end
 
  def add_document(text, source: "unknown")
    splits = split(text)
    splits.each_with_index { |s, i| @chunks << Chunk.new(id: "#{source}:#{i}", text: s, source: source, vector: nil) }
    rebuild_index
    splits.size
  end
 
  def search(query, top_k: 3)
    qvec = tfidf(query)
    @chunks.map { |c| Result.new(chunk: c, score: cosine(qvec, c.vector)) }
           .select { _1.score > 0 }
           .sort_by { -_1.score }
           .first(top_k)
  end
 
  def answer(query, top_k: 3)
    results = search(query, top_k: top_k)
    return "関連ドキュメントが見つかりませんでした。" if results.empty?
    results.map { |r| "--- #{r.chunk.source} (#{r.score.round(3)}) ---\n#{r.chunk.text}" }.join("\n\n")
  end
 
  private
 
  def split(text)
    words = text.split
    step = [(@chunk_size - @overlap), 1].max
    (0...words.size).step(step).map { |i| words[i, @chunk_size].join(" ") }.reject(&:empty?)
  end
 
  def rebuild_index
    df = Hash.new(0)
    @chunks.each { |c| tokenize(c.text).uniq.each { |t| df[t] += 1 } }
    @idf = df.transform_values { |v| Math.log(@chunks.size.to_f / v) }
    @chunks.each { |c| c.vector = tfidf(c.text) }
  end
 
  def tokenize(text) = text.downcase.scan(/[a-z0-9\p{Han}\p{Hiragana}\p{Katakana}]+/)
 
  def tfidf(text)
    terms = tokenize(text)
    tf = terms.tally
    total = terms.size.to_f
    tf.each_with_object({}) { |(t, c), h| h[t] = (c / total) * @idf.fetch(t, 0) if @idf[t] }
  end
 
  def cosine(a, b)
    common = a.keys & b.keys
    return 0.0 if common.empty?
    dot = common.sum { |k| a[k] * b[k] }
    dot / (Math.sqrt(a.values.sum { _1**2 }) * Math.sqrt(b.values.sum { _1**2 }))
  end
end