コンピューターが当たり前のものとなり、AIの活用が期待される今、その基礎となる「数学」に注目が集まっています。
ここでは、数学がより身近になる特集をお届けします。
これからの複雑な世界を読み解くにあたり、有名な定理や公式などの中から興味が持てるような項目を選びました。
プログラミングを体感できるものもあります。
FOX君が紹介する「数学体感チャレンジ!」に、ぜひトライしてみてください。
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
単純に０から最大の数ｎまでを
足し上げるプログラムです。
仮に最大値を１００万としていますが、とりあえず、実行してみてください。人間がガウスの計算法を使って計算するのと、どちらが早いでしょうか？ さらに桁をあげて試してみてください。
この例では、プログラムだと単純計算でもあっという間に結果が出てしまうことがわかりました。しかし、公式がわかっている場合は、やはり、公式を使った方がよいのです。今の場合は、差が実感できませんが、計算の最大値がどんどん大きくなるに従い、単純計算だと、計算時間もどんどん長くなります。でも、ガウスの計算法のようなクレバーな方法を使えば、計算時間はほとんど変わりません。
プログラミングの上級者は、常に、いちばん効率のよい（＝計算時間の短い）プログラムを書く癖がついています。
単純計算だと何年もかかってしまうが、うまい計算法でやれば、計算時間が劇的に短縮できるようなプログラムをネットで探して勉強してみてください。
０から最大の数ｎまでを足し上げるプログラムをダウンロード
※別途Pythonのダウンロードが必要です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import math
def pythagoras(n):
for b in range(n):
for a in range(1, b):
c = math.sqrt( a * a + b * b)
if c % 1 == 0:
c = int(c)
if math.gcd(a,b)*math.gcd
(b,c)*math.gcd(c,a) == 1:
print(a, b, c)
if __name__ == “__main__”:
pythagoras(100)
99までのピタゴラス数を発見する
プログラムになっています。
まずは、Pythogoras(100)の100を別の数に変えてみてください。
途中の計算で最大公約数（greatest common denominatorを略してgcd）という特殊な数学の命令を使う必要があるので、最初にmathという、前もって用意された「プログラムのかたまり」を輸入（import）しています。
defはdefine（定義する）という意味で、「これがプログラムのかなめの部分だぞ」と宣言しています。ちょっとむずかしい言葉を使うとpythagoras(n)という「関数」を定義しているのです。
脱線しますが、関数というのは、数字を入れると別の数字が出てくるプログラムのことです。自販機に１００（円）を入れると５００（ｍｌ）の水が出てくるようなものです。 今の場合は、１００を入れれば「１００までのピタゴラス数」が出てきますし、１０００を入れれば「１０００までのピタゴラス数」が出てくるような関数になっています。
for b in range(n)は、「ｂについて0からｎ（未満）まで一つずつくりかえせ」という命令で、とてもよく使われます。
sqrtはsquare root（平方根）です。math.がついているのは、最初に輸入した数学に便利なプログラムのかたまりを使ってね、という意味です。
- printで始まる一行がなかったらどうなるだろう？
- ％はどういう意味かな？
- if __name__ == “__main__”:の一行がなかったらどなるだろう？ 大きなプログラムを書くときに、この「おまじない」みたいな一行がなくて困ることってあるだろうか？
プログラムをダウンロード
※別途Pythonのダウンロードが必要です。
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
２３人の人がいるときに、同じ誕生日の
人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint(1,366)で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は(3,65,239,300)になります。
二回目。発生させられた誕生日は、４５，７２、２５６，２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、(45,72,256)となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
※別途Pythonのダウンロードが必要です。
A. 表に残った数（素数）は、2, 3, 5, 7, 11, 13, 17,19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61 ,67, 71, 73, 79, 83, 89, 97
saidai = 100
sosu = {i for i in range(2,saidai)}
for i in range(2,saidai):
if i in sosu:
for j in range(i*2,saidai,i):
if j in sosu:
sosu.remove(j)
print(sosu)
１から９９までの素数を網羅する
プログラムです。
１は素数でないので、まずは２から１００未満の整数の集合を作ります（sosu = {i for i in range(2,max)}）。集合は(2,3,4,5,……,97,98,99）という形をしています。
次に、２から始めて、その「倍数」が集合に入っていたら、その倍数を集合sosuから取り除きます（sosu.remove）。for j in range(i*2,max,i):の最後のiは「ステップ」といって、「i個ごとに」という意味です。２なら２個ごとにたしかめるので、４、６、８、１０、……、９８までをチェックして集合から除外します。
２の倍数をたしかめおわったら、次は集合sosuに残っている次の数である３について、同様に倍数（６、９、１２、……、９９）が集合に入っていたら、それを消していきます。
以下同様に集合から次々と倍数を消していって、最後に残ったのが「どの数の倍数でもない数」、つまりは「素数」ということになります。
１から９９までの素数を網羅するプログラムをダウンロード
※別途Pythonのダウンロードが必要です。
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import random
kaisu = 100000
count = 0
for i in range(kaisu):
x = random.random()
y = random.random()
if x*x + y*y < 1:
count += 1
pi = 4*count/kaisu
print(pi)
モンテカルロ法というシミュレーション方法を使って、円周率πを計算します。
乱数（ランダム数）を使うので、最初にrandomという数学プログラムのかたまりを輸入（import）しています。
考え方としては、半径が１の四分円（＝円の四分の一）を描いて、その弧が「内接」するような正方形を考えます。正方形は辺の長さが１になります。そして、この正方形の中にランダムに点を打っていきます。このプログラムでは１０万個の点を打ちます。その１０万個のうち、四分円の中にあるものを数えていきます（count）。
ここで半径が１の円の公式を思い出してください。はい、x^2+y^2=1でしたよね？ 面積はπr^2で、今の場合、半径ｒは１ですから、面積はπです。ええと、つまり、半径が１の円の面積はπ。
ここでこんなふうに考えてください。あなたはまだ学校で円周率πの値を教わっていません。でも、なぜか物理学の「次元解析」という授業は取っていたので、円の面積は、半径ｒの２乗に「比例」することだけはわかるのです（なぜって、半径以外に円を特徴づける数字がないし、仮にｒをｃｍで測るのであれば、円周ではなく面積なので、正方形などど同じく平方ｃｍの単位になるはず。だから、半径ｒの２乗に比例することが推測できる！）。そこで、あなたはその比例係数であるπをシミュレーションによって求めることにしましたとさ。
さて、正方形の面積は１です。その中に１０万個の点があります。仮に四分円の中に７万個の点が入っていたとしたら、四分円の面積は正方形の面積の７０％なので、０・７になりますよね？ だとしたら、円の面積、そしてπの値は、０・７を４倍して、２・８となります。
実際には、四分円の中には７万個ではなく、もうちょっとたくさんの点が入っているはずです。それを数えたのがcount。
まとめると、正方形と四分円の面積をランダムな点の比率から求め、そこからπの値が概算できる、という寸法なのです。
モンテカルロ法で円周率πを計算するプログラムをダウンロード
※別途Pythonのダウンロードが必要です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
A. 4=2+2
6=3+3
8=3+5
10=3+7 10=5+5
12=5+7
14=3+11 14=7+7
16=3+13 16=5+11
18=5+13 18=7+11
20=3+17 20=7+13
22=3+19 22=5+17 22=11+11
24=5+19 24=7+17 24=11+13
26=3+23 26=7+19 26=13+13
28=5+23 28=11+17
30=7+23 30=11+19 30=13+17
※ 素数は2、3、5、7、11、13、17、19、23･･････です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
A. およそ50％
※ 「1（100％）」−「23人とも誕生日が異なる確率」＝「同じ誕生日の人が少なくとも1組はいる確率」で求められます。
「23人とも誕生日が異なる確率」は、（1人目と2人目の誕生日が異なる確率）×（3人目が、1人目と2人目の誕生日と異なる確率）･･････×（23人目が、1人目と2人目･･････22人目の誕生日と異なる確率）です。
from turtle import *
def koch(length, level):
if level == 0:
forward(length)
return
length /= 3
koch(length, level-1)
left(60)
koch(length, level-1)
right(120)
koch(length, level-1)
left(60)
koch(length, level-1)
if __name__ == “__main__”:
nagasa = 200
for i in range(3):
koch(nagasa, 4)
right(120)
mainloop()
フラクタルの１つ・雪片曲線（コッホ曲線）を描くプログラムです。
まずはpythonにあるタートルグラフィックスを輸入します（from turtle import *）。＊は「なんでもかんでも輸入しろ」というような意味だと思ってください。しかし、この輸入の仕方には、眉をひそめるプログラマーが多いと思います（なぜでしょうか？ 宿題１）。
代わりにimport turtleとしてもかまいません。ただし、その場合、「輸入したタートルグラフィックスの命令を使う」という意味で、たとえば、亀が前に進む命令をturtle.forwardなどとしなくてはなりません。この輸入の仕方については、各自、いろいろ試して自分なりに納得するしかありません。
タートルグラフィックスの命令はかんたんです。前へ進め（forward）、左に何度回転せよ（left）、右に何度回転せよ（right）だけできれば雪片曲線を描くことができます。
雪片曲線の関数はkochで定義しています。フラクタル図形の一つの特徴は「自己相似」です。その意味は、倍率を変えても同じように見える、ということ。
いまの場合、基本の形（koch）は、亀が何歩か前に進む、左に６０度向きを変えて、進む、右に１２０度向きを変えて、進む、左に６０度向きを変えて、進む。これだと、三角形の帽子みたいな線が描かれるだけですね？
でも、kochを３分の１のサイズに縮小して、kochの「進む」を「３分の１に縮小されたkoch」で置き換えると、単純な雪片曲線が描かれます。
これをさらに進めて、縮小するレベルを深めると、どんどん細かい雪片曲線を描くことができます。
kochという関数は「再帰関数」と呼ばれます。そのココロは、再び自分に戻ってくる。つまり、kochという関数の定義の中で、kochを使っているんですね。自分を定義するのに自分を使うなんて、ちょっとおかしな気がしますが、便利な手法なのでプログラミングではよく使われます。
- from turtle import *をimport turtleとし、forwardをturtle.forwardなどとして実行してみてください。同じ結果が得られるはずです。なぜ＊を使う方法を嫌うプログラマーが多いのか、ネットでリサーチしてみてください。
- koch(nagasa, 4)の最後の数字を3にしてみてください。なにが起きましたか？
- for i in range(3):の最後の数字を１にしてみてください。
- タートルグラフィックスの描画のスピードを速くするにはどうすればいいでしょうか？
- 雪片曲線をウィンドウのもっと真ん中にもってくるにはどうすればいいでしょうか？研究してみてください。
プログラムをダウンロード
※別途Pythonのダウンロードが必要です。
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
import random
kaisu = 10000
ninzu = 23
count = 0
for i in range(kaisu):
birthday = set()
for j in range (1,ninzu+1):
k = random.randint(1,365)
birthday.add(k)
if len(birthday) < ninzu:
count += 1
kakuritsu = count/kaisu
print(kakuritsu)
23人の人がいるときに、同じ誕生日の人がいる確率をシミュレーションします。
最初に乱数（ランダム数）をあつかう数学プログラムのかたまりを輸入（import）します。
setというのは「集合」です。たとえば、うちの猫の集合は（ゾンゾン、モモちゃん、リリぺっぺ、シンちゃん）の４匹からできています。
今の場合は２３人の誕生日の集合ですが、話をかんたんにするために４人の誕生日の集合を考えてみましょう。といっても、整数の乱数をつくるrandint（1,366）で擬似的に誕生日を発生させます。１から３６６未満の整数をランダムに発生させるのです。
一回目。発生させられた誕生日は３、６５、２３９、３００だったので、４人の誕生日の集合は（3,65,239,300）になります。
二回目。発生させられた誕生日は、４５、７２、２５６、２５６になりました。最後の二人は同じ日に生まれています。４人の誕生日の集合は（重複しているものはカウントしないので）、（45,72,256）となります。あれ？ ４人いるのに、誕生日が同じ人がいるから、集合の中には誕生日が３日しか入っていません。つまり、４回、ランダムな数字を発生させて、重複があると、集合の大きさが４より小さくなるわけです。集合の大きさはlenという命令で測ることができます。
今の場合は、４人ではなく２３人ですが、この状況で１万回、乱数を発生させて、毎回、集合の大きさが２３より小さいかどうかをたしかめることにより、どれくらいの確率で誕生日が同じ人がいるかがシミュレーションできるのです。
- ２３人をさまざまな数に変えてプログラムを走らせてみてください。
- シミュレーションの試行回数（kaisu）もいろいろ変えてみてください。
プログラムをダウンロード
次世代のための財団
CTC未来財団は、「次世代の育成支援」を目的に伊藤忠テクノソリューションズ株式会社（略称：CTC）が設立。児童・青少年に対するIT教育の支援事業、ITを志す青少年に対する修学支援事業、障がいのある青少年に対する修学及び就労機会創出の支援事業を行っています。
「答えはこちら」のマーク（上記左）があるものは、問題の答えを確認できます。「プログラムはこちら」のマーク（上記右）があるものは、プログラミング言語「Python（パイソン）」を使った、公式や定理、定義に関連するプログラム記述例を紹介しています。各プログラムの解説などについても記しています。
CTCは、最先端のテクノロジーで社会のデジタル化を支えています。
ITの可能性に挑戦し、明日の世界を担う次世代を応援します。