훌라 초보자 전략 가이드 Part 6: 한 판 복기와 초보 체크리스트

[뽑기 전]
  미등록이고 합 22 이하 / 76 이상인가 → 뽑은 뒤 손패를 다 비울 수 있으면 훌라, 아니면 등록하지 않는다
    (아래 [뽑은 뒤]의 등록 단계를 건너뛴다). 두 번째 턴부터 로우·하이
  확정 스톱 자격이 있는가 (총통 / 두 번째 턴 이후 미등록 로우·하이)
  등록했고 합 15 이하인가 → 내 합 < 상대 전원 최소 가능 합이면 확정 스톱. 아니면 Part 5 표
[뽑은 뒤]
  7 이 있는가 → 내려놓는다 (세 장이면 같은 턴에 붙일 6·8 이 있을 때 따로, 없으면 SET. RUN 안에 있으면 RUN)
  등록 후보가 여럿인가 → 남는 카드를 보고 이 턴에 가장 많이 터는 순서로
  등록했는가 → 붙일 수 있는 카드는 지금 붙인다
[버리기 전]
  미등록 상대가 있는가 (다음 자리부터 전원) → 그 상대에게 땡큐가 될 카드는 가능한 한 피한다
  죽은 조각이 있는가 → 홑 카드로 재분류하고 값·위험으로 비교한다
  홑 카드 중 위험하지 않은 것 중 가장 비싼 것
[남의 차례]
  버림패 + 내 손패 2장이 조합인가 → 부른다
  단, 로우·하이 자격을 지키는 중이거나 한 장이면 훌라인 손패는 참는다
  가져가면 손패가 비는가 → 무조건 부른다

#!/usr/bin/env python3
"""훌라 초보자 전략 가이드의 암기용 표를 계산한다. 표준 라이브러리만 쓴다.

1. 아웃 확률: 안 보이는 카드 U 장 중 아웃 k 장. 한 번 뽑을 때 / 두 번 뽑을 때 적어도 한 장.
2. 일반 스톱 성공률: 상대 한 명이 n 장을 들고 있을 때 카드합이 내 합 S 보다 클 확률.
   (a) 균등 가정 — 안 보이는 카드가 표준 덱 분포(각 값 4장)에서 무작위로 뽑힌다. 전수 계산(DP).
   (b) 치우친 가정 — 상대는 높은 카드를 먼저 버리므로 낮은 카드일수록 손에 남을 무게가 크다.
       무게 w(v) = 1 + (13 - v) / 12  (2 는 K 의 약 2배). 비복원 가중 추출을 Monte Carlo 로 근사.
3. 4인 스톱 기대값: 성공 시 +7, 실패 시 -7 (스톱박 = 패자 전원 몫). 박(미등록·세븐)과 패자 간 동점이 없다고 가정.
"""
import random
from fractions import Fraction
from itertools import product

VALUES = list(range(1, 14))  # A=1 … K=13
DECK = {v: 4 for v in VALUES}


def outs_table():
    print('## 아웃 확률 (안 보이는 카드 U 장, 아웃 k 장)')
    print('| U | k=1 한 번 | k=2 한 번 | k=3 한 번 | k=4 한 번 | k=2 두 번 | k=4 두 번 |')
    print('|---|---|---|---|---|---|---|')
    for U in (40, 35, 30, 25, 20, 15, 10):
        row = [str(U)]
        for k in (1, 2, 3, 4):
            row.append(f'{k / U * 100:.0f}%')
        for k in (2, 4):
            p2 = 1 - (1 - k / U) * (1 - k / (U - 1))
            row.append(f'{p2 * 100:.0f}%')
        print('| ' + ' | '.join(row) + ' |')
    print()


def sum_dist_uniform(n, deck=DECK):
    """deck(값→장수)에서 n 장을 비복원 균등 추출했을 때 합의 분포. 경우의 수 DP."""
    # dp[j][s] = j 장 골라 합 s 인 조합 수
    from math import comb
    dp = [dict() for _ in range(n + 1)]
    dp[0][0] = 1
    for v, cnt in deck.items():
        for j in range(n, 0, -1):
            for take in range(1, min(cnt, j) + 1):
                ways = comb(cnt, take)
                for s, w in list(dp[j - take].items()):
                    dp[j][s + v * take] = dp[j][s + v * take] + w * ways if (s + v * take) in dp[j] else w * ways
    total = sum(dp[n].values())
    return {s: Fraction(w, total) for s, w in dp[n].items()}


def p_opp_above_uniform(S, n):
    d = sum_dist_uniform(n)
    return float(sum(p for s, p in d.items() if s > S))


def p_opp_above_biased(S, n, rng, trials=60000):
    cards = [v for v in VALUES for _ in range(4)]
    weights = [1 + (13 - v) / 12 for v in cards]
    hit = 0
    for _ in range(trials):
        pool = cards[:]
        wts = weights[:]
        total = 0
        for _ in range(n):
            i = rng.choices(range(len(pool)), weights=wts, k=1)[0]
            total += pool[i]
            pool.pop(i)
            wts.pop(i)
        if total > S:
            hit += 1
    return hit / trials


def stop_tables():
    rng = random.Random(7)
    print('## 상대 한 명이 내 카드합보다 높을 확률 — 균등 가정')
    print('| 내 합 \\ 상대 장수 | 2장 | 3장 | 4장 | 5장 | 6장 | 7장 |')
    print('|---|---|---|---|---|---|---|')
    uni = {}
    for S in (5, 8, 10, 12, 15):
        row = [str(S)]
        for n in range(2, 8):
            p = p_opp_above_uniform(S, n)
            uni[(S, n)] = p
            row.append(f'{p * 100:.0f}%')
        print('| ' + ' | '.join(row) + ' |')
    print()
    print('## 상대 한 명이 내 카드합보다 높을 확률 — 치우친 가정 (낮은 카드가 손에 남는다)')
    print('| 내 합 \\ 상대 장수 | 2장 | 3장 | 4장 | 5장 | 6장 | 7장 |')
    print('|---|---|---|---|---|---|---|')
    bia = {}
    for S in (5, 8, 10, 12, 15):
        row = [str(S)]
        for n in range(2, 8):
            p = p_opp_above_biased(S, n, rng)
            bia[(S, n)] = p
            row.append(f'{p * 100:.0f}%')
        print('| ' + ' | '.join(row) + ' |')
    print()
    print('## 4인: 상대 셋이 (n1,n2,n3) 장일 때 스톱 성공률 (상대별 확률의 곱 — 근사) 과 기대값 (성공 +7 / 실패 -7)')
    print('| 내 합 | 상대 장수 | 균등 성공률 | 균등 기대값 | 치우침 성공률 | 치우침 기대값 |')
    print('|---|---|---|---|---|---|')
    for S in (8, 10, 12, 15):
        for sizes in ((3, 3, 3), (2, 4, 5), (4, 5, 6), (5, 6, 7)):
            pu = 1
            pb = 1
            for n in sizes:
                pu *= uni[(S, n)]
                pb *= bia[(S, n)]
            print(f'| {S} | {sizes} | {pu * 100:.0f}% | {7 * (2 * pu - 1):+.1f} | {pb * 100:.0f}% | {7 * (2 * pb - 1):+.1f} |')
    print()


def seven_table():
    print('## 7 을 들고 판이 끝났을 때 배수 (4인 4등 -4점 기준)')
    print('| 손에 남은 7 | 등록함 | 미등록 |')
    print('|---|---|---|')
    for k in range(0, 4):
        reg = -4 * (2 ** k)
        unreg = -4 * 2 * (2 ** k)
        print(f'| {k}장 | {reg} | {unreg} |')
    print()


if __name__ == '__main__':
    outs_table()
    seven_table()
    stop_tables()