논리 퍼즐로 사고력 훈련

# 1~100 출력. 단:
# - 3의 배수면 "Fizz"
# - 5의 배수면 "Buzz"
# - 15의 배수면 "FizzBuzz"
# - 그 외는 숫자

# 술어 논리 표현: ∀n ∈ [1, 100]: print(label(n))
def label(n):
    fizz = (n % 3 == 0)
    buzz = (n % 5 == 0)

    # 진리표 (4행)
    if fizz and buzz:
        return 'FizzBuzz'
    if fizz:
        return 'Fizz'
    if buzz:
        return 'Buzz'
    return str(n)


for i in range(1, 16):
    print(label(i))
# 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz

"""
세 사람 A, B, C 중 한 명만 진실, 나머지는 거짓.
A: "B가 거짓말쟁이다"
B: "C가 거짓말쟁이다"
C: "A와 B가 둘 다 거짓말쟁이다"
누가 진실?
"""

import itertools

# 변수: a, b, c 각자가 진실인지 여부 (T/F)
# 단, 정확히 1명만 T

for a, b, c in itertools.product([True, False], repeat=3):
    # 정확히 1명만 진실
    if sum([a, b, c]) != 1:
        continue

    # A의 발언: "B가 거짓말쟁이" → not b 일 때 A 발언 참
    a_statement = (not b)
    # B의 발언: "C가 거짓말쟁이" → not c
    b_statement = (not c)
    # C의 발언: "A와 B 둘 다 거짓말쟁이" → not a and not b
    c_statement = (not a and not b)

    # 진실인 사람의 발언만 참, 거짓말쟁이는 발언이 거짓
    consistent = (
        (a == a_statement) and
        (b == b_statement) and
        (c == c_statement)
    )

    if consistent:
        truth_teller = 'A' if a else ('B' if b else 'C')
        print(f"진실: {truth_teller}")  # B
        break

# 8x8 체스판에 퀸 8개를 서로 공격받지 않게 배치
# 술어: ∀(i, j) ∈ queens, ∀(k, l) ∈ queens, (i, j) != (k, l):
#       i != k AND j != l AND |i-k| != |j-l|

def solve_n_queens(n):
    solutions = []

    def backtrack(row, cols, diag1, diag2, current):
        if row == n:
            solutions.append(current[:])
            return
        for col in range(n):
            if col in cols or (row + col) in diag1 or (row - col) in diag2:
                continue
            cols.add(col)
            diag1.add(row + col)
            diag2.add(row - col)
            current.append(col)

            backtrack(row + 1, cols, diag1, diag2, current)

            cols.remove(col)
            diag1.remove(row + col)
            diag2.remove(row - col)
            current.pop()

    backtrack(0, set(), set(), set(), [])
    return solutions


solutions = solve_n_queens(8)
print(f"8-Queens 해법 수: {len(solutions)}")  # 92

# 배열에서 합이 target인 모든 부분집합
# 비트마스크로 모든 부분집합 표현 (2^n)

def find_subsets_with_sum(arr, target):
    n = len(arr)
    results = []

    # i는 0부터 2^n - 1 — 각 비트가 arr[j] 포함 여부
    for i in range(1 << n):
        subset = []
        for j in range(n):
            if i & (1 << j):  # j번째 비트가 1이면 포함
                subset.append(arr[j])
        if sum(subset) == target:
            results.append(subset)

    return results


arr = [1, 2, 3, 4, 5]
print(find_subsets_with_sum(arr, 5))
# [[1, 4], [2, 3], [5]]

# 그레이 코드: 인접 항목이 1비트만 차이 나는 시퀀스
# 카르노 맵에서 사용한 순서 (00, 01, 11, 10)
# 일반화: n비트 그레이 코드

def gray_code(n):
    """n비트 그레이 코드 시퀀스"""
    result = []
    for i in range(1 << n):
        # 그레이 코드 = i XOR (i >> 1)
        gray = i ^ (i >> 1)
        result.append(gray)
    return result


for n in [2, 3, 4]:
    codes = gray_code(n)
    print(f"\n{n}비트 그레이 코드:")
    for c in codes:
        print(f"  {bin(c)[2:].zfill(n)}")


# 결과 (3비트):
#   000
#   001
#   011
#   010
#   110
#   111
#   101
#   100
# 인접 항목 1비트 차이 보장

[모듈 1] 기초 수학 ── 다음 모두 ✅?
□ 변수와 함수의 수학적 의미 + 코드 매핑
□ 1차/2차 함수 그래프 그리기 + 선형 회귀
□ 비율·백분율로 RPM/CTR/전환율 계산
□ 지수와 로그로 알고리즘 시간복잡도 평가
□ 등차/등비/시그마(Σ)로 반복문 분석

[모듈 2] 논리·불대수 ── 다음 모두 ✅?
□ Boolean 단축 평가 활용
□ 진리표로 복잡한 조건문 분석
□ 드모르간 법칙으로 조건 리팩토링
□ 비트 연산으로 권한·색상·플래그 처리
□ 카르노 맵으로 논리식 최소화
□ ∀ ∃ 정량자를 every/some으로 표현