今回はヒマなので
なーんか面白いことないかーとか
思っていましたら

東の方に
有名な大学が有るらしいんですよ。


東京大学って知ってます？

自分は行ったことないんで
よく知らないんですけど
有名大学みたいなので
数学の問題を解いてみることにしました。

解説動画はこちら



2003年の東大の入試問題より
 
円周率が 3.05 より大きいことを証明せよ。


さて
どう解きましょうかねー

とりあえず
円周の長さ ＞ 内接X角形の外周

になるはずなので
この内接する多角形の外周を求めて
それが3.05よりも大きければ

総じて
円周率> 3.05 
となるのではないかと思います。

まずは円を描いてみましょう。

Pythonのライブラリを用いて
円を描いてみます。

# ライブラリの読み込み
import numpy as np
import matplotlib.pyplot as plt
% matplotlib inline

描画用のライブラリとして
matplotlibを読み込んでおきます。

# 半径5の円を描く
plt.figure(figsize=(2,2),dpi=300)
r = 5
x = [np.sin(np.radians(_x))*r for _x in np.linspace(-180,180,361)]
y = [np.cos(np.radians(_y))*r for _y in np.linspace(-180,180,361)]
plt.plot(x,y)

plt.xticks([i for i in range(-r,r+1)])
plt.yticks([i for i in range(-r,r+1)])
plt.axes().set_aspect('equal','datalim')
plt.show()

円を描くにはx,y座標が必要ですが
その点を求めるのにnumpyを使います。

numpy.linspaceで等間隔の配列が作成できます。

あとはx,y座標の点を求めるのに
numpy.sin , numpy.cos　を使います。
sin , cos に渡せるのはradianでないといけないので
一旦numpy.radiansで変換します。

これで円を描くことができます。


次にこの円に内接する多角形を描いてみましょう。
今回は12角形を描くこととします。

わかりやすくするために
三角形の辺の長さが3:4:5になるという法則を用いて
座標を決めていきます。

一番長い5の辺は円に接する先端ですね。
あとはx,yの座標は3か4になります。

一番上をx=0,y=5として座標点をプロットしてあげます。

# 内接する12角形を描画
plt.figure(figsize=(2,2),dpi=300)
r = 5
x = [np.sin(np.radians(_x))*r for _x in np.linspace(-180,180,361)]
y = [np.cos(np.radians(_y))*r for _y in np.linspace(-180,180,361)]
plt.plot(x,y)

x2 = [0,3,4,5,4,3,0,-3,-4,-5,-4,-3,0]
y2 = [5,4,3,0,-3,-4,-5,-4,-3,0,3,4,5]
plt.plot(x2,y2)

plt.xticks([i for i in range(-r,r+1)])
plt.yticks([i for i in range(-r,r+1)])
plt.axes().set_aspect('equal','datalim')
plt.show()

はいこれで円に接する12角形が描けました。

あとはこの辺の長さを求めて
あげれば良いということになります。

辺の長さを求めるにはどうすれば良いでしょうか？

これはnumpyを使って
ユークリッド距離を求めることで
辺の長さを計算することができます。

numpy.linalg.norm(座標a - 座標b)

これで2点のユークリッド距離を求めることができます。

12角形のうち
全部を求める必要はなく

右上部分の4点を用いて
3辺の長さを計算してみましょう。

x,y座標はそれぞれ
0,5
3,4
4,3
5,0
となるので
そのうち2点を使って計算します。

l = np.array([[0,5],[3,4],[4,3],[5,0]])
c1 = np.linalg.norm(l[0]-l[1])
c2 = np.linalg.norm(l[1]-l[2])
c3 = np.linalg.norm(l[2]-l[3])
ans1 = 4 *(c1+c2+c3)
print(ans1)

30.9550755308

さてこれで多角形の辺の長さが計算できました。

問題文は3.05より大きいことを証明せよなので
比率を合わせます。

この円は半径5の円なので直径は10です。
なので10倍します。
30.5


10倍した30.5よりも
12角形の外周は30.95のため大きくなり

必然的にそれよりも円周は大きいので

円周率>3.05

になるはずです。

さて
描画などについては
Pythonのライブラリを用いると簡単に
描くことができ
また座標間の距離なども
簡単に計算することができます。

数学の問題では
このnumpyとmatplotlibライブラリを使って
いろいろ問題に応用することができます。

数学的な可視化や
その計算については
numpyやmatplotlibライブラリを
用いることが多いです。

単純な計算については
通常のPythonプログラムだけでも
行うことができます。

問題を読み間違わなければ
このくらいの計算は
プログラミングで簡単に行うことができるので

プログラミングを覚えていない方
これから覚えたい方は
ぜひPythonを覚えてみてください。

Pythonについては無料の動画講座を用意しています。
乙py式５時間で学ぶプログラミング基礎(python編)

興味のある方はぜひこちらをご参照くださいませ。

それでは。

タグ ：

#プログラミング

#Python

#数学

#有名大学

#受験

さて
今回は確率のお話です。



なんてニュースが最近有ったので
いろいろなギャンブルの確率が
どのくらいなのかを求めてみたくなりました。

解説動画はこちら



まずは競馬からです。

競馬は16-18頭の馬の中から
着順を当てる仕組みです。

馬券は正式には
勝ち馬投票券と言うらしいです。

16頭18頭だてでそれぞれを求めました。

確率計算にはPythonを用いますので
ライブラリをインポートします。

import math
import itertools

こちらを用います。

さて、まずは単勝から
単に1着を当てるもの

確率は

# 16頭
print('{0}/{1}'.format(1, 16))
print('{0:.5}%'.format(1/16*100))

1/16
6.25%

# 18頭
print('{0}/{1}'.format(1, 18))
print('{0:.5}%'.format(1/18*100))

1/18
5.5556%

次は複勝
1-3着に入る馬を当てます。

予想した馬が1位でも3位でも良いので
単純に単勝の3倍になります。

# 16頭
print('{0}/{1}'.format(3, 16))
print('{0:.5}%'.format(3/16*100))

3/16
18.75%

# 18頭
print('{0}/{1}'.format(3, 18))
print('{0:.5}%'.format(3/18*100))

3/18
16.667%


複勝であれば
6回に1回は当たるという確率ですね。

ただし払い戻しは平均2倍程度なので
あまり美味しくはありません。

お次は枠連
18頭の馬は9の枠に入れられます。
それぞれ1-2頭ほどで構成され
その枠での順位を当てるというものです。

9枠の中から2枠を選ぶというものです。

Pythonでの
組み合わせの求め方は2通りありますが

len(list(itertools.combinations(range(9),2)))

math.factorial(9) // (math.factorial(9 - 2) * math.factorial(2))

どちらであっても36通りです。

ということで確率は

waku = math.factorial(9) // (math.factorial(9 - 2) * math.factorial(2))
print('{0}/{1}'.format(1, waku))
print('{0:.5}%'.format(1/waku*100))

1/36
2.7778%

となります。


お次は馬単と馬連
選んだ2頭が1-2着になる組み合わせで
馬単は1-2着をそのまま当てる
馬連は1-2,2-1どちらでも良いという買い方です。

当然
馬連は馬単の2倍の確率になります。

馬練：

# 16頭
umaren= math.factorial(16) // (math.factorial(16 - 2) * math.factorial(2))
print('{0}/{1}'.format(1, umaren))
print('{0:.5}%'.format(1/umaren*100))

1/120
0.83333%

# 18頭
umaren= math.factorial(18) // (math.factorial(18 - 2) * math.factorial(2))
print('{0}/{1}'.format(1, umaren))
print('{0:.5}%'.format(1/umaren*100))

1/153
0.65359%

馬単：

# 16頭
umatan= math.factorial(16) // math.factorial(16 - 2)
print('{0}/{1}'.format(1, umatan))
print('{0:.5}%'.format(1/umatan*100))

1/240
0.41667%

# 18頭
umatan= math.factorial(18) // math.factorial(18 - 2)
print('{0}/{1}'.format(1, umatan))
print('{0:.5}%'.format(1/umatan*100))

1/306
0.3268%


お次はワイド
3着以内に入る組み合わせのうち2つを
それらの着順に依らず順不同で予想するものです。

1-2 , 1-3 , 2-3着になれば良いので
単純に馬連の3倍の確率になります。

# 16頭
wide = math.factorial(16) // (math.factorial(16 - 2) * math.factorial(2))
print('{0}/{1}'.format(3, wide))
print('{0:.5}%'.format(3/wide*100))

3/120
2.5%

# 18頭
wide = math.factorial(18) // (math.factorial(18 - 2) * math.factorial(2))
print('{0}/{1}'.format(3, wide))
print('{0:.5}%'.format(3/wide*100))

3/153
1.9608%


次は3連
3連単と3連複でそれぞれ
3連単：1着・2着・3着になる組み合わせを着順通りに予想する
3連複：1着・2着・3着になる組み合わせを順不同で予想する

3連複：は組み合わせ(16C3 , 18C3)
3連単：は順列(16P3 , 18P3)でもとめることになります。


3連複：

# 16頭
sanrenhuku = math.factorial(16) // (math.factorial(16 - 3) * math.factorial(3))
print('{0}/{1}'.format(1, sanrenhuku))
print('{0:.5}%'.format(1/sanrenhuku*100))

1/560
0.17857%

# 18頭
sanrenhuku = math.factorial(18) // (math.factorial(18 - 3) * math.factorial(3))
print('{0}/{1}'.format(1, sanrenhuku))
print('{0:.5}%'.format(1/sanrenhuku*100))

1/816
0.12255%


3連単：

# 16頭
sanrentan= math.factorial(16) // math.factorial(16 - 3)
print('{0}/{1}'.format(1, sanrentan))
print('{0:.5}%'.format(1/sanrentan*100))

1/3360
0.029762%

# 18頭
sanrentan= math.factorial(18) // math.factorial(18 - 3)
print('{0}/{1}'.format(1, sanrentan))
print('{0:.5}%'.format(1/sanrentan*100))

1/4896
0.020425%

このくらいの確率になると
でたらめに選んで買っても
5千回に1回しか当たりません。

そうとう当たらないので
当てるには絞り込みの技術が必要になってきます。

競馬の最後はWIN5
JRAが指定する５つのレース
それぞれの1着を予想するものです。

単勝の5乗ですね。

その確率は

win5 = 18**5
print('{0}/{1}'.format(1, win5))
print('{0:.10F}%'.format(1/win5*100))

1/1889568
0.0000529221%

約190万分の1の確率です。
当てた際の
払戻金の想定額が2億円ほどで

宝くじなどの確率が
1000万分の1の確率で
同じくらいの金額なので

WIN5の方が期待値は上かと思います。


競馬の確率の高さは

複勝＞単勝＞枠連＞ワイド＞馬連＞馬単＞３連複＞３連単＞WIN5

になります。

次は宝くじのうち
ロト6です。

ロト6は1-43まで数字のうち
本数字6個と1個のボーナス数字
計7個の数字を選択して当てるものです。

1-5等まであります。

まずは1等

本数字6個すべて一致

なので単純に
43C6 となります。
この数はロト6のベースとなる数です。

求め方は

loto_base = math.factorial(43) // (math.factorial(43 - 6) * math.factorial(6))
print('{0}/{1}'.format(1, loto_base))
print('{0:.10f}%'.format(1/loto_base*100))

1/6096454
0.0000164030%

1等は約600万分の1の確率となります。

2等以下は次のようになります。

2等 : 本数字５個と一致,ボーナス数字１個と一致

loto_base = math.factorial(43) // (math.factorial(43 - 6) * math.factorial(6))
print('{0}/{1}'.format(6, loto_base))
print('{0:.10f}%'.format(6/loto_base*100))

6/6096454
0.0000984179%

3等 : ６個のうち５個が本数字に一致

loto_base = math.factorial(43) // (math.factorial(43 - 6) * math.factorial(6))
loto3 = (math.factorial(6) // (math.factorial(6 - 5) * math.factorial(5)))*37-6
print('{0}/{1}'.format(loto3, loto_base))
print('{0:.10f}%'.format(loto3/loto_base*100))

216/6096454
0.0035430432%

4等 : ６個のうち４個が本数字に一致

loto_base = math.factorial(43) // (math.factorial(43 - 6) * math.factorial(6))
loto4 = (math.factorial(6) // (math.factorial(6 - 4) * math.factorial(4)))* \
((math.factorial(37) // (math.factorial(37 - 2) * math.factorial(2))))
print('{0}/{1}'.format(loto4, loto_base))
print('{0:.10f}%'.format(loto4/loto_base*100))

9990/6096454
0.1638657488%

5等 : ６個のうち３個が本数字に一致

loto_base = math.factorial(43) // (math.factorial(43 - 6) * math.factorial(6))
loto5 = (math.factorial(6) // (math.factorial(6 - 3) * math.factorial(3)))* \
((math.factorial(37) // (math.factorial(37 - 3) * math.factorial(3))))
print('{0}/{1}'.format(loto5, loto_base))
print('{0:.10f}%'.format(loto5/loto_base*100))

155400/6096454
2.5490227598%

さて
5等は1000円です。
2.5%の確率でしか当たらないので
40回買っても1000円しか戻ってこないのです。

1位がでなければキャリーオーバーで
持ち越しになり、金額が増えますが
そもそも600万分の1の確率では
人生において当たることは
ほぼないでしょうね。


今回のラストはポーカーです。

ポーカーはトランプ52枚を使ったゲームで
役が決まっています。

その役がどれだけ有るのかを求めます。

役は
一番強い役がロイヤルフラッシュ
(ロイヤルストレートフラッシュ)

ストレートフラッシュ: 連続した数字で(絵柄)
同じスートの5枚のカード。

ストレートフラッシュ同士の場合は、
最もランクが高いカードを持つプレイヤーが勝者
最も強いストレートフラッシュは同じスートのA-K-Q-J-10

フォーカード: 同じランクのカード4枚と他1枚カード
フォーカード同士の場合は、同じランクのカード
4 枚のランクが最も高いプレイヤーが勝者

フルハウス: 同じランクのカード 3 枚と別の同じランクのカード 2 枚。
(スリーカードとワンペアの組み合わせ)
フルハウス同士の場合は、3 枚 1 組のカードのランクが最も高いプレイヤーが勝者

フラッシュ: 同じスートの 5 枚のカード。
フラッシュ同士の場合は、最もランクが高いカードを持つプレイヤーが勝者

ストレート: 連続した数字の 5 枚のカード。
ストレート同士の場合は、最もランクが高いカードを持つプレイヤーが勝者
最も強いストレートは A-K-Q-J-T (エースハイ)、最も弱いストレートは 5-4-3-2-A (ファイブハイ)

スリーカード: 同じランクのカード 3 枚と、ランクの異なる 2 枚のサイドカード。
スリーカード同士の場合は、3 枚 1 組のカードのランクが最も高いプレイヤーが勝者

ツーペア: 同じランクのカード 2 枚 1 組が 2 組と、1 枚のサイドカード。
ツーペア同士の場合は、最もランクが高いペアを持つプレイヤーが勝者

ワンペア: 同じランクのカード 2 枚と、ランクの異なる 3 枚のサイドカード。
ワンペア同士の場合は、最もランクが高いペアを持つプレイヤーが勝者

ハイカード: 上記のどれにも当てはまらない手札。
ブタとも言います。

今回は役を判定するプログラムを作って
全カードの組み合わせからその役がなんなのかを判定して
役の組み合わせ数を求めます。

デッキはカード52枚として
それを判定する関数を作成し
全52枚の中から5枚を選んだ際の組み合わせから
役が何かを求めて役の個数をカウントします。

# デッキの生成
deck=[b+':'+str(a) for a in range(1,14) for b in ['C','S','D','H']]

# 役の判定
def jadge_role(card):
    s = {}
    for c in card:
        k = int(c.split(':')[1])
        if k in s:
            s[k]+=1
        else:
            s[k] =1
    t = {c.split(':')[0] for c in card}
    n = sorted([c for c in s.keys()])
    if len(t)==1 and all([1 in n,10 in n ,11 in n,12 in n,13 in n]):
        return 'RSF'
    if len(t)==1 and (all([1 in n,10 in n ,11 in n,12 in n,13 in n]) or
             (max(n)-min(n)==4) and len(s)==5):
        return 'SF'
    if 4 in s.values():
        return '4C'
    if 3 in s.values() and 2 in s.values():
        return 'FH'
    if len(t)==1:
        return 'FL'
    if (all([1 in n,10 in n ,11 in n,12 in n,13 in n]) or
             (max(n)-min(n)==4) and len(s)==5):
        return 'ST'
    if 3 in s.values():
        return '3C'
    if list(s.values()).count(2)==2:
        return '2P'
    if list(s.values()).count(2)==1:
        return '1P'
    return 'BT'

# 組み合わせを計算
cards = itertools.combinations(deck,5)
calc_dict = {}
for card in cards:
    role = jadge_role(card)
    if role in calc_dict:
        calc_dict[role] += 1
    else:
        calc_dict[role]   = 1

# 結果
poker_base = math.factorial(52) // (math.factorial(52 - 5) * math.factorial(5))
print(poker_base)
for k,v in sorted(calc_dict.items(),reverse=True,key=lambda x:x[1]):
    print(k,'\t',v,'\t','{0:.10f}%'.format(v/poker_base*100))

2598960

BT  1302540 50.1177394035%
1P  1098240 42.2569027611%
2P    123552 4.7539015606%
3C      54912 2.1128451381%
ST      10200 0.3924646782%
FL         5108 0.1965401545%
FH        3744 0.1440576230%
4C          624 0.0240096038%
SF            36 0.0013851695%
RSF           4 0.0001539077%

このような結果になります。
ロイヤルストレートフラッシュは
約64万回に1回ほどは出る計算ですね

フラッシュとストレートでは
ストレートの方が2倍も出る確率が高いのです。
なのでどちらかを迷う場合は
確率の高いストレートを狙うというのが
戦略になるのかもしれませんね。

と
いろいろなギャンブルにまつわる
組み合わせと確率を求めてみました。

次は
戦略なども考えていきたいかなと思っております。

それでは

タグ ：

#Python

#プログラミング

#確率

新しい元号が決まり

令和

その由来は「万葉集」ということで
今回は万葉集のデータを使って
文章生成で遊んでみました。


まずは
万葉集のデータを用意しましょう。

テキストでも
エクセルでも
なんでも良いです。

手に入れたら
Pythonの文字列型にしておきましょう。

 '篭毛與 美篭母乳 布久思毛與 美夫君志持 
此岳尓 菜採須兒 家吉閑名 告紗根 虚見津 
山跡乃國者 押奈戸手 吾許曽居 師吉名倍手 
吾己曽座 我許背齒 告目 家呼毛名雄母',
 '山常庭 村山有等 取與呂布 天乃香具山 
騰立 國見乎為者 國原波 煙立龍 
海原波 加萬目立多都 怜Ａ國曽 蜻嶋 八間跡能國者',

・・・

自分は一旦リストに格納してから
これを連結しました。

text = '.\n'.join(m_list)

さて、今回は
マルコフ連鎖というものを用いて
文章生成を行います。

マルコフ連鎖とは・・・
wikiによると
マルコフ連鎖 出典:
フリー百科事典『ウィキペディア（Wikipedia）』
マルコフ連鎖（英: Markov chain）とは、
確率過程の一種であるマルコフ過程のうち、
とりうる状態が離散的なものをいう。

また特に、時間が離散的なものを指すことが多い。

マルコフ連鎖は、未来の挙動が現在の値だけで決定され、
過去の挙動と無関係である。

各時刻において起こる状態変化に関して、
マルコフ連鎖は遷移確率が過去の状態によらず、
現在の状態のみによる系列である。

特に重要な確率過程として、
様々な分野に応用される。

・・・・

ちょっと何言ってるか
わかんないっす！！！

簡単にいうと
次の図のように


文章をたくさん読み込んだ後にある一節を取り出し
そこに繋がる単語(文章)などを確率で選んで
どんどん文をつなげます。

句読点などの文の終わりに続くものが選ばれたら
そこで一文が終了となります。

よく使われる言い回しは
たくさん出てきてしまう感じですね。

さて
マルコフ連鎖を
Pythonで取り扱う場合は
markovify　というライブラリが必要です。

pip install markovify

などでインストールできます。

使い方も簡単です。
ライブラリを読み込んで。

文章を文字列型にして
それを使ってマルコフモデルを生成します。

import markovify
text_model = markovify.Text(text)

マルコフモデルを作ったら
あとは文章生成です。

これも非常に簡単で
マルコフモデルのメソッド

make_short_sentence(文字数,max_overlap_ratio=かぶり率)

とすると文が生成されます。
かぶり率のデフォルトが0.7
70%は元の文章とかぶるようですね。

元の文章と全く同じにならないような文にするには
このかぶり率を下げるといいでしょう。

下げすぎた場合は
文章が生成できないことがあり
その際は　None　が返ってきてしまいます。

古文だから
11個文章を作るようにしました。

ソースはこちら

# マルコフ連鎖で生成
r_dict = {}
for _ in range(1000):
    result = text_model.make_short_sentence(50,max_overlap_ratio=0.7)
    if result is not None:
        r_dict[result]=''
        if len(r_dict)==11:
            break

for i,t in enumerate(r_dict.keys(),start=1):
    print(i)
    for g in t.replace('.','').split(' '):
        print(g,'\t',yomi_dict.get(g))
    print()

単に文章だけを生成すると
読み方がわからないので
別途読み方用の辞書も用意して
生成された文章に当てています。

結果は

1
河上乃 	 かはかみの
伊都藻之花乃 	 いつものはなの
何時々々 	 いつもいつも
来座吾背子 	 きませわがせこ
時自異目八方 	 ときじけめやも

2
足桧木之 	 あしひきの
山菅根之 	 やますがのねの
懃 	 ねもころに
不止念者 	 やまずおもはば
於妹将相可聞 	 いもにあはむかも

3
暮月夜 	 ゆふづくよ
暁闇夜乃 	 あかときやみの
朝影尓 	 あさかげに
吾身者成奴 	 あがみはなりぬ
玉蜻 	 たまかぎる
髣髴所見而 	 ほのかにみえて
徃之兒故尓 	 いにしこゆゑに

4
待君常 	 きみまつと
庭耳居者 	 にはのみをれば
打靡 	 うちなびき
吾黒髪尓 	 わがくろかみに
霜乃置萬代日 	 しものおくまでに

5
國遠 	 くにとほみ
直不相 	 ただにはあはず
夢谷 	 いめにだに
相見与 	 あふとみえこそ
我戀國 	 あがこふらくに

6
現 	 うつつには
直不相 	 ただにはあはず
夢谷 	 いめにだに
吾尓所見社 	 われにみえこそ
相日左右二 	 あはむひまでに

7
天降就 	 あもりつく
神乃香山 	 かみのかぐやま
打靡 	 うちなびき
春去来者 	 はるさりくれば
小竹之末丹 	 しののうれに
尾羽打觸而 	 をはうちふれて
鴬鳴毛 	 うぐひすなくも

8
劔大刀 	 つるぎたち
名之惜毛 	 なのをしけくも
吾者無 	 われはなし
不相日數多 	 あはぬひまねく
年之經者 	 としのへぬれば

9
三吉野之 	 みよしのの
御金高尓 	 みかねがたけに
間無序 	 まなくぞ
雨者落云 	 あめはふるといふ
不時曽 	 ときじくぞ
雪者落云 	 ゆきはふるといふ
其雨 	 そのあめの
無間如 	 まなきがごと
隈毛不堕 	 くまもおちず
思乍叙来 	 おもひつつぞくる
其山道乎 	 そのやまみちを

10
於保伎美乃 	 おほきみの
美己等可思古美 	 みことかしこみ
可奈之伊毛我 	 かなしいもが
多麻久良波奈礼 	 たまくらはなれ
阿夜尓可奈之毛 	 あやにかなしも

11
吾妹兒尓 	 わぎもこに
相坂山之 	 あふさかやまの
皮為酢寸 	 はだすすき
穂庭開不出 	 ほにはさきでぬ
戀乎吾為 	 こひをぞあがする
玉蜻 	 たまかぎる
直一目耳 	 ただひとめのみ
視之人故尓 	 みしひとゆゑに

それっぽいのが
できていますかね？

万葉集読んだことないので
正しいかどうかはわかりません。

元の歌と被っているところも多いと思います。

なので
あんまり使えないプログラムではあります。

なぜこんなものを作ったかというと

古文イレブン

言いたかった！！！！

ただそれだけです。
終

タグ ：

#Python

#プログラミング

#マルコフ連鎖

#万葉集