乙Py先生のプログラミング教室

乙Py先生のプログラミング教室
初学者のためのプログラミング学習サイト

今回はケリー基準を用いた
破産しないための最適資金配分のシミュレーションです。


解説動画はこちら

 




破産しないための最適な賭け金の割合



・問題
コインを投げて、表が出たら賭け金が2倍、裏が出たら全て失う賭けです
このコインは、55%の確率で表が出るやや有利なコインです

手元には100万円あり、このゲームを250回繰り返すとき
毎回いくら賭けるのが最適でしょうか?






--------------------------------------------------------




・回答
ケリー基準をもとに
最適な賭け金を算出することができます。


ケリー基準 : 
資産運用において
最適な資金配分比率を決定するための数式

割合 = (勝率 × オッズ − (1−勝率) ) / オッズ

ここに
勝率 0.55(55%)
オッズ(2倍-1倍 = 1)
を入れると

0.55 - 0.45 = 0.1

資金の0.1倍を賭けるのが
最適解ということになります。




250回の賭けコイン試行シミュレーション


先ほどの問題をシミュレーションするコードです。

初期資金 : 100万円
勝率 : 55%
回数 : 250回

シミュレーション結果を集計した結果を
出力する関数です。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
pd.options.display.float_format = '{:.2f}'.format

# 250回のコイントスの賭けシミュレーター
def coin_250(default_assets=1000000,times=250,win_rate=0.55):
  kelly_criterion_percentage = (win_rate - (1 - win_rate))
  data = []
  assets = default_assets
  for i in range(times):
    stakes = int(assets * kelly_criterion_percentage)
    assets -= stakes
    result = np.random.choice([1,0],p=[0.55,0.45])
    if result == 1:
      assets += stakes * 2
    tmp =[assets,stakes, int(result)]
    data.append(tmp)
  
  # 250回の結果をデータフレームで集計
  df = pd.DataFrame(data,columns=["assets","stakes","result"])
  max_assets = df["assets"].max()
  min_assets = df["assets"].min()
  max_stakes = df["stakes"].max()
  min_stakes = df["stakes"].min()
  final_ps = int(df["assets"].tail(1).values[0])
  profit = final_ps - default_assets
  win_times = int(df["result"].sum())
  lose_times = len(df) - win_times

  group_id = (df["result"] != df["result"].shift()).cumsum()
  run_lengths = df.groupby(group_id)["result"].sum()
  run_lengths_0 = df.groupby(group_id).apply(lambda x: (len(x) - x["result"].sum()))
  # 最大連敗回数
  max_lose = run_lengths_0.max()
  # 最大連勝回数
  max_win = run_lengths.max()

  result_250 = [max_assets,min_assets,max_stakes,min_stakes,final_ps,profit,win_times,lose_times,max_win,max_lose]
  return result_250

この関数を使って
1000セット試行を行います。
times = 1000
results = []
for i in range(times):
  data = coin_250()
  results.append(data)

columns = ["最大資産","最小資産","最大掛金","最小掛金","最終資産","最終利益","勝利回数","敗北回数","最大連勝","最大連敗"]
df = pd.DataFrame(results,columns=columns)
df.describe()
desc最大資産最小資産最大掛金最小掛金最終資産最終利益勝利回数敗北回数最大連勝最大連敗
count1000.001000.001000.001000.001000.001000.001000.001000.001000.001000.00
mean16066691.73576608.611588961.9557127.3511146821.0310146821.03137.19112.818.496.45
std33581089.69289491.313311346.2928006.3827692950.8927692950.897.917.912.271.56
min900000.007130.00100000.00713.007687.00-992313.00107.0089.004.003.00
25%2515432.75346220.75248966.5034622.001159975.00159975.00132.00108.007.005.00
50%6327419.00575743.50632741.5057574.003163743.502163743.50137.00113.008.006.00
75%15386038.00801900.001515707.5080274.008628829.007628829.00142.00118.0010.007.00
max541305769.001100000.0054130576.00100000.00390665788.00389665788.00161.00143.0026.0014.00


こんな感じの結果になりました

勝利回数の分布をプロットしてみると
download-1

おおよそ勝率55%の回数で正規分布に近似しますね

最終利益はこんな感じです
download

0以上になっていれば、利益が出ている
0未満は負け
ということになります。

今回は1000セットやって
利益が出た回数が762回
0未満は238回でした




まとめ

勝率とオッズが分かっているならケリー基準を元に
資金調整すれば、資金が0になることはほぼ無いです。

ただし、勝率とオッズ次第では
元の資金より減る事もあるので注意が必要です。

より負けたく無い場合は
ケリー基準の半分の割合でかけるなど
保守的な割合にすればもっと負けづらくなります。

株式などにも応用できるため
色々シミュレーションに使うと面白そうです。


今回はここまでです
それでは

今回は競技プログラミングについてです。

解説動画はこちら



競技プログラミングの世界をのぞいてみよう


競技プログラミングとは

プログラミングを「速く・正確に・美しく」解く
頭脳スポーツです。

与えられるのは数行の問題文と、入力例
頭の中でアルゴリズムを組み立て
最速のコードで正答を競います。


競技プログラミングの概要

問題が与えられ、入力例と出力例も与えられます。

問題文から、入力を受け取って
出力例になるようなプログラムコードを書いていきます。

実際の競技では
プログラムコードが開催側のシステム内で実行されて
成否が出るような仕組みになっています。


問題文の例(超初級)

問題:最大値を求めよう

N 個の整数が与えられるので
その中で最大の値を出力してください。

入力例
5
10 3 5 8 2

出力例
10

サンプルコード
N = int(input())
nums = list(map(int, input().split()))
print(max(nums))

通常は計算量や、数値の上限などの制約が与えられます。

正解かどうかの判定は、もっと大掛かりな数値で自動計算されているようで
数が多い場合、制限時間に間に合わないことも有ります。



競技プログラミングの主な大会

AtCoder(日本)
Topcoder(海外)
その他も有るみたいだけど、色々休止中



競技プログラミングはどんなことに役立つのか

1.思考を“構造化”する力が身につく
問題を分解し、条件を抽象化し、最適なアルゴリズムを選ぶ
という一連の思考過程を繰り返し構造化思考力を鍛えることができます

2.アルゴリズムの理解が“AIを使いこなす力”になる
AIが生成したコードを見て
計算量のボトルネック、論理が最適化されているか
入力制約に対応できているか等を判断できます

3.「論理×直感」問題解決能力を鍛える最高のトレーニング
限られた時間と資源の中で最適な解決方法を
論理と直感、両方を磨きながら鍛えることができます

4.キャリアや採用で有利に働く
近年、大企業やスタートアップなどで評価される傾向
アルゴリズムが必要な企業への就職で有利になります




競技プログラミングの問題を解いてみよう


中級くらいの問題集、動画を止めて考えてみてね

問題1 : 文字列の入れ替えチェック(中級)

2つの文字列 S, T が与えられます
S の文字を並べ替えて T にできるなら Yes
できないなら No と出力してください

入力例
listen
silent

出力例
Yes

-------------------------------------------------------------


解説

文字の出現がすべて一致していればOK
sorted(S) == sorted(T) で判定可能です。

S = input().strip()
T = input().strip()
print("Yes" if sorted(S) == sorted(T) else "No")



問題2 : 数字の組み合わせの和(中上級)

N 個の整数が与えられます
この中から3つ選んで、その和が K になる組み合わせの数を求めてください

入力例
5 10
2 3 5 4 1

出力例
2

-------------------------------------------------------------


解説

単純に3重ループで解くコードの場合
3つの数値の和が K になれば OK です。

N, K = map(int, input().split())
A = list(map(int, input().split()))

count = 0
for i in range(N):
    for j in range(i+1, N):
        for k in range(j+1, N):
            if A[i] + A[j] + A[k] == K:
                count += 1
print(count)

ただし実際の競技では
3重ループだと、制限に合わない場合があるので
別の方法を検討することが多いようです。

ここでは一例として次のようなアルゴリズムで
解くこととします。

    1.  配列 A の要素をセット S にしておく(探索用)
    2.  二重ループで全ペア (i, j) を探索
    3.  そのペアの和 A[i] + A[j] を計算
    4.  target = K - (A[i] + A[j]) として、 S に存在すればカウント

これをコードに落とすと次のようになります。
# 入力
N, K = map(int, input().split())
A = list(map(int, input().split()))

# 集合(SET)を作成
S = set(A)
count = 0
seen = set()  # 同じ組み合わせの重複カウント防止用

for i in range(N):
    for j in range(i + 1, N):
        two_sum = A[i] + A[j]
        target = K - two_sum

        # 3つの値がすべて異なることを確認
        if target in S and target != A[i] and target != A[j]:
            # 組み合わせを小さい順にソートして一意化
            triple = tuple(sorted((A[i], A[j], target)))
            if triple not in seen:
                seen.add(triple)
                count += 1

print(count)






問題3 : 最短経路を求める迷路探索(上級)


H×W のマップが与えられ . は通行可
S から G までの最短距離を求めてください
到達できない場合は -1 を出力

入力例
4 5
S....
.###.
..#G.
.....

出力例
7


------------------------------------------


解説

BFS(幅優先探索 : Breadth First Search)で
最短距離を求めていきます。
(開始地点に近いノードから順に「横に広がるように」探していく手法)

入力は一旦省略し、直接データ化したコードです。
from collections import deque

data = """\
4 5
S....
.###.
..#G.
.....
"""

lines = data.strip().splitlines()
H, W = map(int, lines[0].split())
grid = [list(line) for line in lines[1:]]

# スタート(S)とゴール(G)を探して座標を求める
for i in range(H):
    for j in range(W):
        if grid[i][j] == "S":
            sx, sy = i, j
        if grid[i][j] == "G":
            gx, gy = i, j

# 4方向の移動ベクトルと距離配列の初期化
# dx,dyは上下左右の移動を表す、dist は各セルへの最短距離(始点からの距離)
# 訪問したら dist[nx][ny] = dist[x][y] + 1 と更新
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
dist = [[-1]*W for _ in range(H)]

# キュー初期化と始点の距離設定
# 始点をキューに入れて距離 0 をセット
# 以降はキューから取り出すごとに、そのセルから隣接を探索
q = deque()
q.append((sx, sy))
dist[sx][sy] = 0

# BFS のメインループ
# q.popleft() でキューの先頭から取り出し(FIFO)
# 4方向それぞれについて:
#	•	範囲チェック(境界外は無視)
#	•	壁 (#) なら通れないので無視
#	•	dist[nx][ny] == -1 は未訪問の確認(訪問済みならスキップ)
# 未訪問かつ通行可なら距離を +1 してキューに追加
while q:
    x, y = q.popleft()
    for k in range(4):
        nx, ny = x + dx[k], y + dy[k]
        if 0 <= nx < H and 0 <= ny < W:
            if grid[nx][ny] != "#" and dist[nx][ny] == -1:
                dist[nx][ny] = dist[x][y] + 1
                q.append((nx, ny))

# G に到達していれば dist[gx][gy] は非負の最短距離
#	到達していなければ -1(初期値)のまま出力される
print(dist[gx][gy])




まとめ

最適なアルゴリズムが必要な業務には
競技プログラミングの知識が役にたちます。

すごく時間の掛かる処理の高速化、省力化、消費電力低下など
実務面で有効な場面はかなり多いです。

若い人は就職面でも有利になるので、
競技プログラミングに取り組むのかかなりオススメです。


今回は簡易的なパチスロゲームを作って

自分の反応速度の限界にチャレンジしてみました。


解説動画はこちら

 

簡単パチスロアプリ

今回はStreamlitを用いて
簡単なパチスロアプリを作っていきます。

ローカルPCにstreamlitをインストールしたら
遊ぶことができると思います。
pip install streamlit 

必要なファイルは
main.py
game.py
の2つです。

コピペしてファイル作成して下さい。


main.py
from game import run_app

if __name__ == '__main__':
    run_app()




game.py
import streamlit as st
import random
import time
from typing import List, Tuple

# 絵柄の辞書と配当
SYMBOL_COUNTS = {
    'C': 6,
    'L': 5,
    'P': 3,
    'O': 3,
    'S': 2,
    'BAR': 1,
    '7': 1,
}

PAYOUT = {
    'C': 5,
    'L': 10,
    'P': 15,
    'O': 20,
    'S': 25,
    'BAR': 30,
    '7': 50,
}

# リールの数は21枚になること
TOTAL_PER_REEL = 21

def make_reel() -> List[str]:
    items = []
    for k, v in SYMBOL_COUNTS.items():
        items += [k] * v
    if len(items) != TOTAL_PER_REEL:
        raise ValueError(f"reel composition must be {TOTAL_PER_REEL}, got {len(items)}")
    random.shuffle(items)
    return items

def evaluate_result(s1: str, s2: str, s3: str) -> Tuple[int, str]:
    if s1 == s2 == s3:
        symbol = s1
        payout = PAYOUT.get(symbol, 0)
        return payout, f"{symbol} : + {payout} 枚"
    else:
        return 0, "揃わず"

def run_app():
    st.title('簡易パチスロ')

    # 初期化
    if 'medals' not in st.session_state:
        st.session_state['medals'] = 100
    if 'speed' not in st.session_state:
        st.session_state['speed'] = 0.1  # 秒
    if 'spinning' not in st.session_state:
        st.session_state['spinning'] = False
    # リール本体
    if 'reels' not in st.session_state:
        st.session_state['reels'] = [make_reel(), make_reel(), make_reel()]
    if 'indices' not in st.session_state:
        st.session_state['indices'] = [0, 0, 0]
    if 'stop_flags' not in st.session_state:
        st.session_state['stop_flags'] = [False, False, False]
    if 'last_message' not in st.session_state:
        st.session_state['last_message'] = ''

    # UI レイアウト
    col_top = st.columns([1, 1, 1])
    placeholders = [col_top[i].empty() for i in range(3)]
    for i in range(3):
        idx = st.session_state['indices'][i]
        symbol = st.session_state['reels'][i][idx]
        placeholders[i].markdown(f"### {symbol}")

    # 停止ボタン
    col_buttons = st.columns([1, 1, 1])
    if col_buttons[0].button('停止1'):
        st.session_state['stop_flags'][0] = True
    if col_buttons[1].button('停止2'):
        st.session_state['stop_flags'][1] = True
    if col_buttons[2].button('停止3'):
        st.session_state['stop_flags'][2] = True

    # メダル表示
    st.write(f"**メダル:** {st.session_state['medals']} 枚")

    # 停止スピード
    start_col, speed_col = st.columns([1, 1])
    if speed_col.slider('回転速度 (秒)', min_value=0.01, max_value=1.0, value=st.session_state['speed'], step=0.01, key='speed_input'):
        st.session_state['speed'] = st.session_state.pop('speed_input')

    # 開始ボタン
    if start_col.button('開始') and not st.session_state['spinning']:
        if st.session_state['medals'] < 5:
            st.warning('メダルが不足しています。')
        else:
            # 消費
            st.session_state['medals'] -= 5
            # 新しいリールを作る
            st.session_state['reels'] = [make_reel(), make_reel(), make_reel()]
            # indices をランダムに初期化
            st.session_state['indices'] = [random.randrange(TOTAL_PER_REEL) for _ in range(3)]
            st.session_state['stop_flags'] = [False, False, False]
            st.session_state['spinning'] = True
            st.session_state['last_message'] = ''
            st.rerun() 

    # 回転ループ
    if st.session_state['spinning']:
        while True:
            # まず停止していないリールのインデックスを進める
            for i in range(3):
                if not st.session_state['stop_flags'][i]:
                    st.session_state['indices'][i] = (
                        st.session_state['indices'][i] + 1
                    ) % TOTAL_PER_REEL

            # 表示更新
            for i in range(3):
                idx = st.session_state['indices'][i]
                symbol = st.session_state['reels'][i][idx]
                placeholders[i].markdown(f"### {symbol}")

            # 停止判定
            if all(st.session_state['stop_flags']):
                s1 = st.session_state['reels'][0][st.session_state['indices'][0]]
                s2 = st.session_state['reels'][1][st.session_state['indices'][1]]
                s3 = st.session_state['reels'][2][st.session_state['indices'][2]]
                payout, msg = evaluate_result(s1, s2, s3)
                if payout > 0:
                    st.session_state['medals'] += payout
                st.session_state['last_message'] = msg
                st.session_state['spinning'] = False
                st.rerun()
                break

            # 待機 → 再実行
            time.sleep(st.session_state['speed'])
            st.rerun()

    # 結果表示
    if st.session_state['last_message']:
        st.info(st.session_state['last_message'])




実行方法は main.py のある場所で
streamlit run main.py
です。


実行するとこんな画面になります。

スクリーンショット 2025-09-27 15.57.54

開始ボタンクリックでゲーム開始
停止ボタンをクリックしてリールを止め
3つ絵柄が揃うとコイン獲得です。

回転速度を変えると、変化のスピードを変えられます。

自分は1秒でないと絵柄を揃えられなかったので
だいぶ反応速度が落ちていますね

どこまで行けるか、チャレンジしてみて下さい。

それでは。





このページのトップヘ