# Pythonでのビット演算
 
# AND: 両方1なら1
a = 0b1100  # 12
b = 0b1010  # 10
print(bin(a & b))   # 0b1000 = 8
 
# OR: どちらか1なら1
print(bin(a | b))   # 0b1110 = 14
 
# XOR: 異なれば1
print(bin(a ^ b))   # 0b0110 = 6
 
# NOT: ビット反転
print(bin(~a & 0xFF))  # 0b11110011 = 243 (8ビットの場合)
 
# 左シフト: 2倍（各ビットを左にずらす）
print(bin(a << 1))  # 0b11000 = 24 (12 × 2)
print(bin(a << 3))  # 0b1100000 = 96 (12 × 8)
 
# 右シフト: 半分（各ビットを右にずらす）
print(bin(a >> 1))  # 0b110 = 6 (12 ÷ 2)

# ビット演算の実務的なユースケース
 
# 1. フラグ管理（ビットフィールド）
READ    = 0b001  # 1
WRITE   = 0b010  # 2
EXECUTE = 0b100  # 4
 
permissions = READ | WRITE  # 0b011 = 3
has_read = bool(permissions & READ)     # True
has_execute = bool(permissions & EXECUTE)  # False
 
# ファイルパーミッション: chmod 755 = rwxr-xr-x
# 7 = 111, 5 = 101, 5 = 101
 
# 2. 偶奇判定（最下位ビット）
is_even = (n & 1) == 0  # n % 2 == 0 と同じだが高速
 
# 3. 2の冪乗判定
is_power_of_2 = n > 0 and (n & (n - 1)) == 0
# 8 = 1000, 7 = 0111 → 1000 & 0111 = 0000 → True
# 6 = 0110, 5 = 0101 → 0110 & 0101 = 0100 → False
 
# 4. XORスワップ（一時変数なしで交換）
a ^= b
b ^= a
a ^= b
# 理論的に面白いが、実用では temp = a; a = b; b = temp が読みやすい
 
# 5. ビットマスク
ip_address = 0xC0A80164  # 192.168.1.100
subnet_mask = 0xFFFFFF00  # 255.255.255.0
network = ip_address & subnet_mask  # 192.168.1.0

# === ビットカウント（popcount / ハミング重み） ===
 
# 方法1: 素朴な方法
def popcount_naive(n):
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count
 
# 方法2: Brian Kernighanのアルゴリズム（高速）
def popcount_kernighan(n):
    """n & (n-1) は最下位の1ビットを消す"""
    count = 0
    while n:
        n &= n - 1  # 最下位の1ビットをクリア
        count += 1
    return count
 
# 例: n = 0b1011_0100 (180)
# 1011_0100 & 1011_0011 = 1011_0000 (count=1)
# 1011_0000 & 1010_1111 = 1010_0000 (count=2)
# 1010_0000 & 1001_1111 = 1000_0000 (count=3)
# 1000_0000 & 0111_1111 = 0000_0000 (count=4)
# → 4個の1ビット
 
# 方法3: Python組み込み
bin(180).count('1')  # 4
 
# 方法4: CPUの命令を直接使用（最速）
# x86の POPCNT 命令、ARMの VCNT 命令
 
 
# === 最下位セットビットの抽出 ===
def lowest_set_bit(n):
    """最下位の1ビットだけを残す"""
    return n & (-n)  # 2の補数の性質を利用
 
# 例: n = 0b1010_1000
# -n = 0b0101_1000 (2の補数)
# n & (-n) = 0b0000_1000 → ビット3が最下位の1
 
 
# === 最下位セットビットのクリア ===
def clear_lowest_set_bit(n):
    return n & (n - 1)
 
# 例: n = 0b1010_1000
# n-1 = 0b1010_0111
# n & (n-1) = 0b1010_0000
 
 
# === ビット反転（特定範囲） ===
def toggle_bits(n, mask):
    """maskで指定したビットを反転"""
    return n ^ mask
 
# 例: n = 0b1100_0011, mask = 0b0000_1111
# n ^ mask = 0b1100_1100 (下位4ビットが反転)
 
 
# === 2つの値の中間値（オーバーフローなし） ===
def average_no_overflow(a, b):
    """(a + b) / 2 のオーバーフロー安全版"""
    return (a & b) + ((a ^ b) >> 1)
 
# 通常の (a + b) / 2 は a + b がオーバーフローする可能性
# この方法は共通ビット + 異なるビット/2 で計算
 
 
# === 絶対値（分岐なし） ===
def abs_branchless(n):
    """32ビット符号付き整数の絶対値"""
    mask = n >> 31  # 正なら0x00000000、負なら0xFFFFFFFF
    return (n ^ mask) - mask
 
# 負の場合: mask = -1
# n ^ (-1) = ~n (ビット反転)
# ~n - (-1) = ~n + 1 = -n (2の補数)

# === ビットボード（チェス・将棋のAI） ===
# 8x8のボードを64ビット整数で表現
 
# チェスの例: ナイトの移動可能位置
def knight_moves(position):
    """ナイトの移動先を計算（ビットボード）"""
    # 端のマスクで折り返しを防止
    NOT_A_FILE = 0xFEFEFEFEFEFEFEFE
    NOT_H_FILE = 0x7F7F7F7F7F7F7F7F
    NOT_AB_FILE = 0xFCFCFCFCFCFCFCFC
    NOT_GH_FILE = 0x3F3F3F3F3F3F3F3F
 
    moves = 0
    moves |= (position << 17) & NOT_A_FILE   # 上2右1
    moves |= (position << 15) & NOT_H_FILE   # 上2左1
    moves |= (position << 10) & NOT_AB_FILE  # 上1右2
    moves |= (position <<  6) & NOT_GH_FILE  # 上1左2
    moves |= (position >> 17) & NOT_H_FILE   # 下2左1
    moves |= (position >> 15) & NOT_A_FILE   # 下2右1
    moves |= (position >> 10) & NOT_GH_FILE  # 下1左2
    moves |= (position >>  6) & NOT_AB_FILE  # 下1右2
    return moves
 
 
# === ブルームフィルタ（確率的データ構造） ===
class BloomFilter:
    """ビット配列を使った確率的集合メンバーシップテスト"""
 
    def __init__(self, size=1024):
        self.size = size
        self.bit_array = 0  # Python の無限精度整数をビット配列として使用
 
    def _hashes(self, item):
        """複数のハッシュ値を生成"""
        h1 = hash(item) % self.size
        h2 = hash(str(item) + "salt") % self.size
        h3 = hash(str(item) + "pepper") % self.size
        return [h1, h2, h3]
 
    def add(self, item):
        for h in self._hashes(item):
            self.bit_array |= (1 << h)  # 対応ビットをセット
 
    def might_contain(self, item):
        for h in self._hashes(item):
            if not (self.bit_array & (1 << h)):
                return False  # 確実に含まれない
        return True  # 含まれるかもしれない（偽陽性の可能性あり）
 
 
# === ビットマニピュレーションによる部分集合列挙 ===
def enumerate_subsets(s):
    """ビットマスク s の全部分集合を列挙"""
    subset = s
    subsets = []
    while subset > 0:
        subsets.append(subset)
        subset = (subset - 1) & s
    subsets.append(0)  # 空集合
    return subsets
 
# 例: s = 0b1010 (要素2と要素0を含む集合)
# 部分集合: 1010, 1000, 0010, 0000
# → {2,0}, {2}, {0}, {}
 
 
# === ビットリバース（FFTで使用） ===
def reverse_bits(n, bit_width=8):
    """ビット列を逆順にする"""
    result = 0
    for _ in range(bit_width):
        result = (result << 1) | (n & 1)
        n >>= 1
    return result
 
# 例: reverse_bits(0b10110010, 8) = 0b01001101

// C言語: 低レベル操作に最適
 
#include <stdint.h>
 
// 符号なし整数の使用が推奨（シフト演算の挙動が明確）
uint32_t set_bit(uint32_t n, int pos) {
    return n | (1U << pos);
}
 
uint32_t clear_bit(uint32_t n, int pos) {
    return n & ~(1U << pos);
}
 
uint32_t toggle_bit(uint32_t n, int pos) {
    return n ^ (1U << pos);
}
 
int test_bit(uint32_t n, int pos) {
    return (n >> pos) & 1;
}
 
// GCCのビルトイン関数
int count = __builtin_popcount(0xFF);     // 8
int leading_zeros = __builtin_clz(0x10);  // 27
int trailing_zeros = __builtin_ctz(0x10); // 4

// Java: Integer / Long のユーティリティメソッド
 
int n = 0b1010_1100;
 
// ビットカウント
int count = Integer.bitCount(n);        // 4
 
// 先頭/末尾のゼロ数
int leadingZeros = Integer.numberOfLeadingZeros(n);   // 24
int trailingZeros = Integer.numberOfTrailingZeros(n);  // 2
 
// ビット反転
int reversed = Integer.reverse(n);
 
// 最上位/最下位のセットビット
int highest = Integer.highestOneBit(n);   // 128 (0b10000000)
int lowest = Integer.lowestOneBit(n);     // 4   (0b00000100)
 
// 論理右シフト（>>>）と算術右シフト（>>）の違い
int neg = -128;                  // 0xFFFFFF80
int arithmetic = neg >> 4;       // 0xFFFFFFF8 = -8（符号保持）
int logical = neg >>> 4;         // 0x0FFFFFF8 = 268435448（0埋め）

// Go: math/bits パッケージ
 
package main
 
import (
    "fmt"
    "math/bits"
)
 
func main() {
    var n uint32 = 0b1010_1100
 
    // ビットカウント
    fmt.Println(bits.OnesCount32(n))     // 4
 
    // 先頭/末尾のゼロ数
    fmt.Println(bits.LeadingZeros32(n))  // 24
    fmt.Println(bits.TrailingZeros32(n)) // 2
 
    // ビット長
    fmt.Println(bits.Len32(n))           // 8
 
    // ビット反転
    fmt.Println(bits.Reverse32(n))
 
    // ローテーション
    fmt.Println(bits.RotateLeft32(n, 4))
}

// Rust: 型に組み込みメソッド
 
fn main() {
    let n: u32 = 0b1010_1100;
 
    // ビットカウント
    println!("{}", n.count_ones());       // 4
    println!("{}", n.count_zeros());      // 28
 
    // 先頭/末尾のゼロ数
    println!("{}", n.leading_zeros());    // 24
    println!("{}", n.trailing_zeros());   // 2
 
    // ビット反転
    println!("{}", n.reverse_bits());
 
    // ローテーション
    println!("{}", n.rotate_left(4));
    println!("{}", n.rotate_right(4));
 
    // オーバーフロー検出
    let (result, overflowed) = n.overflowing_add(u32::MAX);
    println!("result={}, overflow={}", result, overflowed);
 
    // チェック付き算術
    match n.checked_add(u32::MAX) {
        Some(v) => println!("sum = {}", v),
        None => println!("overflow!"),
    }
}

# Python: 接頭辞で基数を指定
decimal = 42        # 10進数
binary  = 0b101010  # 2進数
octal   = 0o52      # 8進数
hexadec = 0x2A      # 16進数
# 全て42
 
# アンダースコア区切り（Python 3.6+）
large = 1_000_000_000  # 10億
binary_large = 0b1010_1010_1100_1100
hex_large = 0xFF_FF_FF_FF
 
# 変換関数
bin(42)   # '0b101010'
oct(42)   # '0o52'
hex(42)   # '0x2a'
int('101010', 2)  # 42 (2進文字列→整数)
int('2A', 16)     # 42 (16進文字列→整数)
int('52', 8)      # 42 (8進文字列→整数)
 
# フォーマット
f"{42:b}"     # '101010'   (2進)
f"{42:o}"     # '52'       (8進)
f"{42:x}"     # '2a'       (16進小文字)
f"{42:X}"     # '2A'       (16進大文字)
f"{42:08b}"   # '00101010' (8桁ゼロ埋め2進)
f"{42:#010x}" # '0x0000002a' (接頭辞付き10桁ゼロ埋め16進)
 
# Pythonは任意精度整数
huge = 2 ** 1000  # 問題なく計算可能
print(huge.bit_length())  # 1001 (ビット数)

// JavaScript: 同様の接頭辞
const decimal = 42;
const binary  = 0b101010;
const octal   = 0o52;
const hexadec = 0x2A;
 
// BigInt: 大きな整数
const big = 9007199254740993n;  // 'n' サフィックス
const bigHex = 0x1FFFFFFFFFFFFFn;
 
// Number の限界
console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991 (2^53 - 1)
console.log(Number.MIN_SAFE_INTEGER);  // -9007199254740991
// これを超えると精度が失われる
 
// ビット演算は32ビット整数に変換される（注意！）
console.log(0xFFFFFFFF | 0);    // -1 (符号付き32ビット)
console.log(0xFFFFFFFF >>> 0);  // 4294967295 (符号なし32ビット)
 
// 変換
(42).toString(2);    // '101010'
(42).toString(8);    // '52'
(42).toString(16);   // '2a'
parseInt('101010', 2);  // 42
parseInt('2A', 16);     // 42
 
// TypedArray でバイナリデータを扱う
const buffer = new ArrayBuffer(4);
const view = new DataView(buffer);
view.setUint32(0, 0xDEADBEEF);
console.log(view.getUint8(0).toString(16));  // 'de'
 
// Uint8Array での直接操作
const bytes = new Uint8Array([0xCA, 0xFE, 0xBA, 0xBE]);

// Rust: 型アノテーション + アンダースコア区切り
let decimal: u32 = 42;
let binary: u32  = 0b0010_1010;  // アンダースコアで視認性向上
let octal: u32   = 0o52;
let hexadec: u32 = 0x2A;
let byte: u8     = b'A';  // ASCII値 (65)
 
// 型サフィックス
let a = 42u8;    // u8 型
let b = 42i32;   // i32 型
let c = 42usize; // usize 型
 
// フォーマット
println!("{:b}", 42);     // "101010"
println!("{:08b}", 42);   // "00101010"
println!("{:o}", 42);     // "52"
println!("{:x}", 42);     // "2a"
println!("{:X}", 42);     // "2A"
println!("{:#010x}", 42); // "0x0000002a"
 
// バイト配列
let bytes: [u8; 4] = [0xDE, 0xAD, 0xBE, 0xEF];
 
// from_str_radix で文字列から変換
let n = u32::from_str_radix("101010", 2).unwrap();   // 42
let m = u32::from_str_radix("2A", 16).unwrap();      // 42
 
// ビット操作メソッド
let n: u32 = 42;
println!("{}", n.count_ones());      // 3
println!("{}", n.count_zeros());     // 29
println!("{}", n.leading_zeros());   // 26
println!("{}", n.trailing_zeros());  // 1
println!("{}", n.reverse_bits());    // ビット反転
println!("{}", n.rotate_left(4));    // 左ローテーション

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    // リテラル
    decimal := 42
    binary := 0b101010     // Go 1.13+
    octal := 0o52          // Go 1.13+ (旧形式: 052 も可)
    hexadec := 0x2A
 
    fmt.Println(decimal, binary, octal, hexadec) // 42 42 42 42
 
    // アンダースコア区切り
    large := 1_000_000_000
 
    // フォーマット
    fmt.Printf("%b\n", 42)    // 101010
    fmt.Printf("%08b\n", 42)  // 00101010
    fmt.Printf("%o\n", 42)    // 52
    fmt.Printf("%x\n", 42)    // 2a
    fmt.Printf("%X\n", 42)    // 2A
    fmt.Printf("%#x\n", 42)   // 0x2a
 
    // 文字列変換
    s := strconv.FormatInt(42, 2)   // "101010"
    n, _ := strconv.ParseInt("101010", 2, 64)  // 42
 
    _ = large
    _ = s
    _ = n
}

// C言語
#include <stdio.h>
#include <stdint.h>
 
int main() {
    int decimal = 42;
    int binary  = 0b00101010;  // C23 / GCC拡張
    int octal   = 052;         // 先頭0で8進数（注意！）
    int hexadec = 0x2A;
 
    // フォーマット
    printf("%d\n", 42);    // 42 (10進)
    printf("%o\n", 42);    // 52 (8進)
    printf("%x\n", 42);    // 2a (16進小文字)
    printf("%X\n", 42);    // 2A (16進大文字)
    printf("%#x\n", 42);   // 0x2a (接頭辞付き)
 
    // 固定幅整数型（推奨）
    uint8_t  byte_val = 0xFF;       // 必ず8ビット
    uint16_t short_val = 0xFFFF;    // 必ず16ビット
    uint32_t int_val = 0xFFFFFFFF;  // 必ず32ビット
    uint64_t long_val = 0xFFFFFFFFFFFFFFFFULL;  // 必ず64ビット
 
    // リテラルサフィックス
    unsigned int u = 42U;
    long l = 42L;
    unsigned long ul = 42UL;
    long long ll = 42LL;
    unsigned long long ull = 42ULL;
 
    // C23のバイナリリテラル
    // int b = 0b1010; // C23標準
 
    return 0;
}

// C++: std::bitset
#include <bitset>
#include <iostream>
 
int main() {
    std::bitset<8> bits(42);          // "00101010"
    std::bitset<8> mask("11110000");  // 文字列から構築
 
    std::cout << bits << std::endl;          // 00101010
    std::cout << bits.count() << std::endl;  // 3 (1の数)
    std::cout << bits.size() << std::endl;   // 8
    std::cout << bits.test(1) << std::endl;  // 1 (ビット1がセットされているか)
 
    bits.set(0);    // ビット0をセット
    bits.reset(3);  // ビット3をクリア
    bits.flip(5);   // ビット5を反転
    bits.flip();    // 全ビット反転
 
    // C++14以降: 2進リテラル
    auto b = 0b0010'1010;  // ' で桁区切り
 
    // C++20: std::bit_cast, std::popcount 等
    // #include <bit>
    // int pc = std::popcount(42u);  // 3
 
    return 0;
}

# ハッシュテーブルのインデックス計算
 
# 方法1: モジュロ演算（一般的）
index = hash(key) % table_size
 
# 方法2: ビットマスク（テーブルサイズが2のべき乗の場合、高速）
# table_size = 2^n のとき
index = hash(key) & (table_size - 1)
 
# 例: table_size = 1024 = 2^10
# hash(key) & 0x3FF  ← 下位10ビットを取り出す（0-1023）
 
# これが HashMap/HashSet のパフォーマンスの秘密
# → テーブルサイズを常に2のべき乗に保つ理由
 
# FNV-1aハッシュ（ビット演算で実装）
def fnv1a_32(data: bytes) -> int:
    FNV_OFFSET_BASIS = 0x811C9DC5
    FNV_PRIME = 0x01000193
    h = FNV_OFFSET_BASIS
    for byte in data:
        h ^= byte
        h = (h * FNV_PRIME) & 0xFFFFFFFF  # 32ビットに制限
    return h
 
# MurmurHash の最終ミキシング（ビットシフト + XOR）
def murmur_finalizer(h):
    h ^= h >> 16
    h = (h * 0x85EBCA6B) & 0xFFFFFFFF
    h ^= h >> 13
    h = (h * 0xC2B2AE35) & 0xFFFFFFFF
    h ^= h >> 16
    return h

# RGBA色の操作（各8ビット = 合計32ビット）
 
# 色の構成: 0xAARRGGBB (Alpha, Red, Green, Blue)
color = 0xFF8040C0  # A=255, R=128, G=64, B=192
 
# 各チャンネルの抽出
alpha = (color >> 24) & 0xFF  # 255
red   = (color >> 16) & 0xFF  # 128
green = (color >>  8) & 0xFF  # 64
blue  = (color >>  0) & 0xFF  # 192
 
# チャンネルから色を合成
def rgba(r, g, b, a=255):
    return (a << 24) | (r << 16) | (g << 8) | b
 
white = rgba(255, 255, 255)       # 0xFFFFFFFF
red_color = rgba(255, 0, 0)       # 0xFFFF0000
transparent = rgba(0, 0, 0, 0)    # 0x00000000
 
# アルファブレンディング
def blend(fg, bg, alpha):
    """alpha: 0-255"""
    return ((fg * alpha) + (bg * (255 - alpha))) // 255
 
# 色の明度調整
def brighten(color, factor):
    """factor: 0.0-2.0 (1.0 = 変化なし)"""
    a = (color >> 24) & 0xFF
    r = min(int(((color >> 16) & 0xFF) * factor), 255)
    g = min(int(((color >>  8) & 0xFF) * factor), 255)
    b = min(int(((color >>  0) & 0xFF) * factor), 255)
    return (a << 24) | (r << 16) | (g << 8) | b
 
# Webカラー
# #FF8040 → RGB(255, 128, 64)
hex_str = "FF8040"
r = int(hex_str[0:2], 16)  # 255
g = int(hex_str[2:4], 16)  # 128
b = int(hex_str[4:6], 16)  # 64

# IPv4アドレスの操作
 
import struct
import socket
 
# ドット表記 → 32ビット整数
def ip_to_int(ip_str):
    """'192.168.1.100' → 0xC0A80164"""
    parts = ip_str.split('.')
    return (int(parts[0]) << 24) | (int(parts[1]) << 16) | \
           (int(parts[2]) << 8) | int(parts[3])
 
# 32ビット整数 → ドット表記
def int_to_ip(ip_int):
    """0xC0A80164 → '192.168.1.100'"""
    return f"{(ip_int >> 24) & 0xFF}.{(ip_int >> 16) & 0xFF}." \
           f"{(ip_int >> 8) & 0xFF}.{ip_int & 0xFF}"
 
# サブネット計算
ip = ip_to_int('192.168.1.100')        # 0xC0A80164
mask = ip_to_int('255.255.255.0')      # 0xFFFFFF00
 
network = ip & mask                     # 192.168.1.0
broadcast = ip | (~mask & 0xFFFFFFFF)   # 192.168.1.255
host_part = ip & (~mask & 0xFFFFFFFF)   # 0.0.0.100
 
# CIDRプレフィックスからマスクを生成
def cidr_to_mask(prefix_len):
    """24 → 0xFFFFFF00"""
    return (0xFFFFFFFF << (32 - prefix_len)) & 0xFFFFFFFF
 
# マスクからCIDRプレフィックスを取得
def mask_to_cidr(mask):
    """0xFFFFFF00 → 24"""
    return bin(mask).count('1')
 
# ホスト数の計算
def host_count(prefix_len):
    """使用可能なホスト数"""
    return (2 ** (32 - prefix_len)) - 2  # ネットワークとブロードキャストを除く
 
print(host_count(24))   # 254
print(host_count(16))   # 65534
print(host_count(8))    # 16777214
 
# 同じサブネットに属するか判定
def same_subnet(ip1, ip2, mask):
    return (ip_to_int(ip1) & ip_to_int(mask)) == \
           (ip_to_int(ip2) & ip_to_int(mask))
 
print(same_subnet('192.168.1.100', '192.168.1.200', '255.255.255.0'))  # True
print(same_subnet('192.168.1.100', '192.168.2.100', '255.255.255.0'))  # False
 
 
# TCPフラグ（ビットフィールド）
TCP_FIN = 0x01  # 接続終了
TCP_SYN = 0x02  # 接続開始
TCP_RST = 0x04  # リセット
TCP_PSH = 0x08  # プッシュ
TCP_ACK = 0x10  # 確認応答
TCP_URG = 0x20  # 緊急
 
# SYN-ACK パケットのフラグ
flags = TCP_SYN | TCP_ACK  # 0x12
 
# フラグチェック
is_syn = bool(flags & TCP_SYN)      # True
is_fin = bool(flags & TCP_FIN)      # False
is_syn_ack = (flags & (TCP_SYN | TCP_ACK)) == (TCP_SYN | TCP_ACK)  # True

# XOR暗号（ストリーム暗号の基礎）
 
def xor_encrypt(plaintext: bytes, key: bytes) -> bytes:
    """XOR暗号化（復号も同じ操作）"""
    return bytes(p ^ k for p, k in zip(plaintext, key * (len(plaintext) // len(key) + 1)))
 
# XORの性質: A ^ K ^ K = A
message = b"Hello, World!"
key = b"SECRET"
encrypted = xor_encrypt(message, key)
decrypted = xor_encrypt(encrypted, key)
print(decrypted)  # b'Hello, World!'
 
 
# ビットローテーション（暗号アルゴリズムで多用）
def rotate_left_32(n, d):
    """32ビット左ローテーション"""
    return ((n << d) | (n >> (32 - d))) & 0xFFFFFFFF
 
def rotate_right_32(n, d):
    """32ビット右ローテーション"""
    return ((n >> d) | (n << (32 - d))) & 0xFFFFFFFF
 
# SHA-256のCh関数とMaj関数
def ch(x, y, z):
    """Choice: xが1ならyのビット、0ならzのビット"""
    return (x & y) ^ (~x & z)
 
def maj(x, y, z):
    """Majority: 多数決"""
    return (x & y) ^ (x & z) ^ (y & z)
 
 
# Feistel構造（DES等のブロック暗号の基本構造）
def feistel_round(left, right, round_key):
    """1ラウンドのFeistel構造"""
    new_left = right
    new_right = left ^ f(right, round_key)  # f は暗号化関数
    return new_left, new_right
 
# 逆変換（復号）は鍵の順序を逆にするだけ
def feistel_round_inv(left, right, round_key):
    new_right = left
    new_left = right ^ f(left, round_key)
    return new_left, new_right

import struct
 
# Python の struct モジュール
# '<' = リトルエンディアン, '>' = ビッグエンディアン, '!' = ネットワーク(BE)
 
value = 0x12345678
 
# パック（整数 → バイト列）
be_bytes = struct.pack('>I', value)  # b'\x12\x34\x56\x78'
le_bytes = struct.pack('<I', value)  # b'\x78\x56\x34\x12'
 
# アンパック（バイト列 → 整数）
be_value = struct.unpack('>I', be_bytes)[0]  # 0x12345678
le_value = struct.unpack('<I', le_bytes)[0]  # 0x12345678
 
# int.from_bytes / int.to_bytes (Python 3.2+)
n = int.from_bytes(b'\x12\x34\x56\x78', byteorder='big')    # 0x12345678
n = int.from_bytes(b'\x78\x56\x34\x12', byteorder='little') # 0x12345678
 
data = (0x12345678).to_bytes(4, byteorder='big')    # b'\x12\x34\x56\x78'
data = (0x12345678).to_bytes(4, byteorder='little')  # b'\x78\x56\x34\x12'
 
# バイトスワップ（ビット演算で実装）
def bswap32(n):
    """32ビット値のバイトスワップ"""
    return ((n & 0xFF000000) >> 24) | \
           ((n & 0x00FF0000) >>  8) | \
           ((n & 0x0000FF00) <<  8) | \
           ((n & 0x000000FF) << 24)
 
print(hex(bswap32(0x12345678)))  # 0x78563412
 
def bswap16(n):
    """16ビット値のバイトスワップ"""
    return ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8)

// C言語でのエンディアン変換
 
#include <arpa/inet.h>  // POSIX
 
// ネットワークバイトオーダー変換関数
uint32_t net_val = htonl(0x12345678);  // Host TO Network Long
uint16_t net_s   = htons(0x1234);      // Host TO Network Short
uint32_t host_val = ntohl(net_val);    // Network TO Host Long
uint16_t host_s   = ntohs(net_s);     // Network TO Host Short
 
// GCCビルトイン
uint32_t swapped = __builtin_bswap32(0x12345678);  // 0x78563412
uint64_t swapped64 = __builtin_bswap64(value64);

// Rustでのエンディアン変換
 
let n: u32 = 0x12345678;
 
// バイトスワップ
let swapped = n.swap_bytes();  // 0x78563412
 
// エンディアン変換
let be_bytes = n.to_be_bytes();  // [0x12, 0x34, 0x56, 0x78]
let le_bytes = n.to_le_bytes();  // [0x78, 0x56, 0x34, 0x12]
 
let from_be = u32::from_be_bytes([0x12, 0x34, 0x56, 0x78]);  // 0x12345678
let from_le = u32::from_le_bytes([0x78, 0x56, 0x34, 0x12]);  // 0x12345678

# 演習2-1: ビット演算のみの加算
def add(a, b):
    """ビット演算のみで加算を実装"""
    while b:
        carry = a & b      # 繰り上がりビット
        a = a ^ b           # 繰り上がりなしの加算
        b = carry << 1      # 繰り上がりを次の桁へ
    return a
 
# テスト
print(add(5, 3))    # 8
print(add(100, 200)) # 300
 
# 動作の詳細:
# a=5 (101), b=3 (011)
# 1回目: carry=001, a=110, b=010
# 2回目: carry=010, a=100, b=100
# 3回目: carry=100, a=000, b=1000
# 4回目: carry=000, a=1000, b=0000 → 終了
# 結果: 1000 = 8 ✓
 
 
# 演習2-2: ビットカウント
def count_bits(n):
    """Brian Kernighanのアルゴリズム"""
    count = 0
    while n:
        n &= n - 1  # 最下位の1ビットをクリア
        count += 1
    return count
 
print(count_bits(0b1011_0110))  # 5
 
 
# 演習2-3: 符号反転（2の補数）
def negate(n):
    """~n + 1 = -n"""
    return add(~n, 1)  # ビット反転 + 1
 
 
# 演習4: ファイルパーミッション
class FilePermission:
    # ビット位置の定義
    OTHER_EXECUTE = 0  # ビット0
    OTHER_WRITE   = 1  # ビット1
    OTHER_READ    = 2  # ビット2
    GROUP_EXECUTE = 3  # ビット3
    GROUP_WRITE   = 4  # ビット4
    GROUP_READ    = 5  # ビット5
    USER_EXECUTE  = 6  # ビット6
    USER_WRITE    = 7  # ビット7
    USER_READ     = 8  # ビット8
 
    def __init__(self, mode=0):
        self.mode = mode
 
    @classmethod
    def from_octal(cls, octal_str):
        """'755' → FilePermission"""
        return cls(int(octal_str, 8))
 
    def has_permission(self, bit):
        """指定ビットの権限があるか確認"""
        return bool(self.mode & (1 << bit))
 
    def grant(self, bit):
        """権限を付与"""
        self.mode |= (1 << bit)
 
    def revoke(self, bit):
        """権限を剥奪"""
        self.mode &= ~(1 << bit)
 
    def toggle(self, bit):
        """権限を反転"""
        self.mode ^= (1 << bit)
 
    def __repr__(self):
        chars = ''
        for label, r, w, x in [
            ('u', self.USER_READ, self.USER_WRITE, self.USER_EXECUTE),
            ('g', self.GROUP_READ, self.GROUP_WRITE, self.GROUP_EXECUTE),
            ('o', self.OTHER_READ, self.OTHER_WRITE, self.OTHER_EXECUTE),
        ]:
            chars += 'r' if self.has_permission(r) else '-'
            chars += 'w' if self.has_permission(w) else '-'
            chars += 'x' if self.has_permission(x) else '-'
        return chars
 
perm = FilePermission.from_octal('755')
print(perm)  # rwxr-xr-x
print(perm.has_permission(FilePermission.USER_WRITE))  # True
print(perm.has_permission(FilePermission.OTHER_WRITE))  # False

# 間違い1: Cの8進数リテラルに注意
# C言語で:
# int n = 010;  // これは8！（8進数の10）、10進数の10ではない
 
# 間違い2: JavaScriptのビット演算は32ビット
# JavaScript:
# 0xFFFFFFFF | 0  → -1 (符号付き32ビットとして解釈)
# 正しくは: 0xFFFFFFFF >>> 0  → 4294967295
 
# 間違い3: Pythonの~演算子
n = 5
print(~n)     # -6 (-(n+1))
# 8ビットの範囲で反転したい場合:
print(~n & 0xFF)  # 250 (0b11111010)
 
# 間違い4: 符号付きの右シフト
# -1 >> 1 = -1 (算術右シフト: 符号ビットが維持される)
# Pythonでは整数は無限精度なので:
# -1 = ...1111_1111_1111 (全ビットが1)
# >> 1 = ...1111_1111_1111 (やはり全ビットが1) = -1
 
# 間違い5: 浮動小数点数のビット演算
# Python: int型のみビット演算可能
# float には使えない
# 3.14 & 0xFF  → TypeError
 
# 間違い6: オーバーフロー
# Cで: uint8_t n = 255; n + 1 = 0（ラップアラウンド）
# Pythonでは整数がオーバーフローしない（任意精度）

# ビット表現の可視化ヘルパー
 
def show_bits(n, width=8):
    """整数のビット表現を見やすく表示"""
    if n < 0:
        # 2の補数表現を表示
        n = n & ((1 << width) - 1)
    bits = format(n, f'0{width}b')
    # 4ビットずつ区切る
    grouped = ' '.join(bits[i:i+4] for i in range(0, len(bits), 4))
    print(f"Dec: {n:>{width//3+3}d}  Hex: 0x{n:0{width//4}X}  Bin: {grouped}")
 
show_bits(42)       # Dec:  42  Hex: 0x2A  Bin: 0010 1010
show_bits(255)      # Dec: 255  Hex: 0xFF  Bin: 1111 1111
show_bits(0, 16)    # Dec:   0  Hex: 0x0000  Bin: 0000 0000 0000 0000
 
def show_operation(a, b, op_name, op_func, width=8):
    """ビット演算の過程を可視化"""
    result = op_func(a, b) & ((1 << width) - 1)
    a_bits = format(a & ((1 << width) - 1), f'0{width}b')
    b_bits = format(b & ((1 << width) - 1), f'0{width}b')
    r_bits = format(result, f'0{width}b')
 
    print(f"  {a_bits}  ({a})")
    print(f"{op_name} {b_bits}  ({b})")
    print(f"  {'─' * width}")
    print(f"  {r_bits}  ({result})")
    print()
 
show_operation(0b11001010, 0b10110110, '&', lambda a, b: a & b)
#   11001010  (202)
# & 10110110  (182)
#   ────────
#   10000010  (130)
 
show_operation(0b11001010, 0b10110110, '|', lambda a, b: a | b)
show_operation(0b11001010, 0b10110110, '^', lambda a, b: a ^ b)

# ファイルの16進ダンプ
xxd file.bin | head -20
# 00000000: 504b 0304 1400 0000 0800 ...  PK..........
 
# hexdump（別フォーマット）
hexdump -C file.bin | head -20
 
# 特定のバイトオフセットから読み取り
xxd -s 0x100 -l 32 file.bin
 
# バイナリ比較
xxd file1.bin > /tmp/hex1.txt
xxd file2.bin > /tmp/hex2.txt
diff /tmp/hex1.txt /tmp/hex2.txt
 
# Pythonでバイナリファイル解析
python3 -c "
with open('file.bin', 'rb') as f:
    data = f.read(16)
    print(' '.join(f'{b:02X}' for b in data))
    # マジックナンバーの確認
    magic = {
        b'\\x89PNG': 'PNG画像',
        b'\\xff\\xd8\\xff': 'JPEG画像',
        b'PK': 'ZIP/XLSX/DOCX',
        b'\\x7fELF': 'ELF実行ファイル',
        b'GIF8': 'GIF画像',
        b'%PDF': 'PDFファイル',
    }
    for sig, name in magic.items():
        if data[:len(sig)] == sig:
            print(f'ファイル形式: {name}')
"

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md