pseudo_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 疑似コード"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div name=\"html-admonition\" style=\"font-size: 0.8em\">\n",
    "<input type=\"button\" onclick=\"location.href='https://translate.google.com/translate?hl=&sl=ja&tl=en&u='+window.location;\" value=\"Google translation\" style=\"color:#ffffff;background-color:#008080; height:25px\" onmouseover=\"this.style.background='#99ccff'\" onmouseout=\"this.style.background='#008080'\"/> in English or the language of your choice.\n",
    "</div><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# 警告メッセージを非表示\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## はじめに"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "[モジュールとアルゴリズム](chap:5-module)では簡単なアルゴリズムを`Python`コードとして表し実行したが，その裏にある考え方は他のコンピューター言語でも使うことができる。更に言うと，アルゴリズムを図や言葉で表すことも可能である。[フローチャート](https://www.google.co.jp/search?q=%E3%83%95%E3%83%AD%E3%83%BC%E3%83%81%E3%83%A3%E3%83%BC%E3%83%88%E3%80%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)と呼ばれるのがその一つであり，図を使いアルゴリズムの考えを表現している。そしてもう１つが疑似コードと言われるものであり，自然言語（日本語や英語）で書かれたコードのことである。この２つの手法の利点は，コンピューター言語で発生するエラーを気にせずに，アルゴリズムの考えを理解・整理し，より良い（速い）ものを作り出すことができる土壌となり得ることだろう。以下では疑似コードに基づいてコードの書き方を検討する。\n",
    "\n",
    "上でも説明したが，疑似コードとは，自然言語（日本語や英語）で書かれたコードであるため，`Python`は実行できない箇条書きのような文章となっている。レポートを書く際に，まずアウトラインを考えて書き出す人もいると思うが，それをイメージすれば良いだろう。次の点が重要となる。\n",
    "* 明確さ\n",
    "* 簡潔さ\n",
    "* 細かい詳細は省く\n",
    "    * アルゴリズムの核となる部分を捉える\n",
    "* 高い可読性\n",
    "    * コードを理解できる人ならで誰が読んでも手順が分かるもの\n",
    "\n",
    "一方で，疑似コードの決まった書き方はない。通常は人それぞれ自分のスタイルや好みに合わせて書いているのが実状である（出版のための共通のスタイルがある場合もある）。ここでは次のスタイルとする。\n",
    "* `Python`コードと同じインデントを使う。\n",
    "* `Python`コード（例えば，`for`や`while`）を使えればそのまま使う。\n",
    "    * 疑似コードを英語で書く場合，英語での記述と区別するために大文字を多用するが，日本語とは区別し易いので小文字を使う。\n",
    "    \n",
    "これら以外は，箇条書きスタイルとしよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## `FizzBuzz`問題"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず例として有名な`FizzBuzz`問題を考えよう。\n",
    "\n",
    "> 1から100までの数字を表示する。ただし，\n",
    "> * 3の倍数は数字の代わりに`Fizz`と表示し，\n",
    "> * 5の倍数は数字の代わりに`Buzz`と表示し，\n",
    "> * 3と5の倍数は数字の代わりに`FizzBuzz`と表示する。\n",
    "\n",
    "次のコードでは`fizzbuzz`関数として書いている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def fizzbuzz():\n",
    "    \n",
    "    for i in range(1,100+1):\n",
    "        \n",
    "        if i % 3 == 0 and i % 5 == 0:\n",
    "            print('FizzBuzz')\n",
    "            \n",
    "        elif i % 3 == 0:\n",
    "            print('Fizz')\n",
    "            \n",
    "        elif i % 5 == 0:\n",
    "            print('Buzz')\n",
    "            \n",
    "        else:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで`%`は除算の余りを返す演算子である。実行してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "hidden": true,
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Fizz\n",
      "4\n",
      "Buzz\n",
      "Fizz\n",
      "7\n",
      "8\n",
      "Fizz\n",
      "Buzz\n",
      "11\n",
      "Fizz\n",
      "13\n",
      "14\n",
      "FizzBuzz\n",
      "16\n",
      "17\n",
      "Fizz\n",
      "19\n",
      "Buzz\n",
      "Fizz\n",
      "22\n",
      "23\n",
      "Fizz\n",
      "Buzz\n",
      "26\n",
      "Fizz\n",
      "28\n",
      "29\n",
      "FizzBuzz\n",
      "31\n",
      "32\n",
      "Fizz\n",
      "34\n",
      "Buzz\n",
      "Fizz\n",
      "37\n",
      "38\n",
      "Fizz\n",
      "Buzz\n",
      "41\n",
      "Fizz\n",
      "43\n",
      "44\n",
      "FizzBuzz\n",
      "46\n",
      "47\n",
      "Fizz\n",
      "49\n",
      "Buzz\n",
      "Fizz\n",
      "52\n",
      "53\n",
      "Fizz\n",
      "Buzz\n",
      "56\n",
      "Fizz\n",
      "58\n",
      "59\n",
      "FizzBuzz\n",
      "61\n",
      "62\n",
      "Fizz\n",
      "64\n",
      "Buzz\n",
      "Fizz\n",
      "67\n",
      "68\n",
      "Fizz\n",
      "Buzz\n",
      "71\n",
      "Fizz\n",
      "73\n",
      "74\n",
      "FizzBuzz\n",
      "76\n",
      "77\n",
      "Fizz\n",
      "79\n",
      "Buzz\n",
      "Fizz\n",
      "82\n",
      "83\n",
      "Fizz\n",
      "Buzz\n",
      "86\n",
      "Fizz\n",
      "88\n",
      "89\n",
      "FizzBuzz\n",
      "91\n",
      "92\n",
      "Fizz\n",
      "94\n",
      "Buzz\n",
      "Fizz\n",
      "97\n",
      "98\n",
      "Fizz\n",
      "Buzz\n"
     ]
    }
   ],
   "source": [
    "fizzbuzz()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これを疑似コードで表してみよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```\n",
    "def フィズバズ（）\n",
    "\n",
    "    forループ i <-- 1から100まで\n",
    "    \n",
    "        if i を3で割ると余り0 and i を5で割ると余り0\n",
    "            \"FizzBuzz\"を表示\n",
    "            \n",
    "        elif i を3で割ると余り0\n",
    "            \"Fizz\"を表示\n",
    "            \n",
    "        elif i を5で割ると余り0\n",
    "            \"Buzz\"を表示           \n",
    "            \n",
    "        else\n",
    "            i を表示\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`コードと疑似コードを比べて，疑似コードがどのようなものかイメージできたのではないだろうか。上にも書いたが，疑似コードの目的はアルゴリズムを表現することであり，`FizzBuzz`の例はその目的を達成している。もちろん，これこそが「正しい」という疑似コードはないので，自分なりに書き替えてみてはどうだろうか。ただ，ここでの目的は質の高い疑似コードを書くことでは**ない**。\n",
    "\n",
    "疑似コードには次の利点がある。\n",
    "\n",
    "> プログラミング言語の構文について特に注意を払わずに（エラーを心配せずに），コードの内容を計画・検討することを可能にする。\n",
    "\n",
    "この特性を活かして，コードの書き方を検討しようというのがここでの目的である。言い換えると，漠然とした曖昧な疑似コードを**修正する過程**を通して，アルゴリズムを`Python`コードに落とし込むことを考える。５つの例を使うが，疑似コードの修正プロセスがコードを書く上でのヒントになるのではないかと期待している。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## リストの合計（`for`ループ）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでの目的：\n",
    "> リスト（タプル）の要素の合計を返す関数を作成する。ただし`for`ループを使うこと。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 1＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    最初の要素から最後の要素を全て足し合わせる #1\n",
    "    \n",
    "    その合計を返す\n",
    "```\n",
    "* 全体像はイメージできるが，`#1`で要素をどう足し合わせるか不明。要素ごとに何をするかを書き表そう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 2＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    # リストの要素数：N+1\n",
    "\n",
    "    0番目の要素に1番目の要素を加える\n",
    "    それに2番目の要素を加える。      #1\n",
    "    それに3番目の要素を加える。      #1\n",
    "    ・・・・・\n",
    "    それにN番目の要素を加える。      #1\n",
    "    \n",
    "    return その合計\n",
    "``` \n",
    "* 具体性が芽生えてきたが，まだコードに落とせない。特に，`#1`にある「それに」をどう扱うかを考えよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 3＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    # リストの要素数：N+1\n",
    "\n",
    "    0番目の要素に1番目の要素を加えて，合計をxとする。 #1\n",
    "    xに2番目の要素を加えて，それをxとする。      　 #1\n",
    "    xに3番目の要素を加えて，それをxとする。       　#1\n",
    "    ・・・・・\n",
    "    xにN番目の要素を加えて，それをxとする。      　　#1\n",
    "    \n",
    "    return x\n",
    "```\n",
    "* より具体的になってきたが，`#1`の`x`をどう扱うかを考える必要がある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 4＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    # リストの要素数：N+1\n",
    "\n",
    "    x = 0\n",
    "    \n",
    "    xに0番目の要素の値を足す #1\n",
    "    xに1番目の要素の値を足す #1\n",
    "    xに2番目の要素の値を足す #1\n",
    "    ・・・・・\n",
    "    xにN番目の要素の値を足す #1\n",
    "    \n",
    "    return x\n",
    "```    \n",
    "* 骨格ができてきた。`#1`で似た作業がリピートされているのでループを使おう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "    x = 0\n",
    "    \n",
    "    forループ　i <-- 0からNまで  #1\n",
    "        i番目の要素の値をxに足す  #1\n",
    "        \n",
    "    return x\n",
    "```    \n",
    "* `#1`の`i`はリストのインデックス番号になっているが，要素自体で良いのでは？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 6＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "    x = 0\n",
    "    \n",
    "    for v <-- リスト\n",
    "        要素vをxに足す\n",
    "        \n",
    "    return x\n",
    "```    \n",
    "* ここまで来るとゴールは目の前‼️\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def sum_for_loop(lst):\n",
    "    x = 0\n",
    "    \n",
    "    for i in lst:\n",
    "        x += i\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "実行してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 4950)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_for_loop([1,2,3]), sum_for_loop(range(0,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## リストの合計（`while`ループ）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでの目的：\n",
    "> リスト（タプル）の要素の合計を返す関数を作成する。ただし`while`ループを使うこと。\n",
    "\n",
    "リストの合計（`for`ループ）の＜Ver. 4＞まで同じ。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 4＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    # リストの要素数：N+1\n",
    "\n",
    "    x = 0\n",
    "    \n",
    "    xに0番目の要素の値を足す #1\n",
    "    xに1番目の要素の値を足す #1\n",
    "    xに2番目の要素の値を足す #1\n",
    "    ・・・・・\n",
    "    xにN番目の要素の値を足す #1\n",
    "    \n",
    "    return x\n",
    "```    \n",
    "* 骨格ができてきた。`#1`で似た作業がリピートされているのでループを使おう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    x = 0                    #1\n",
    "    \n",
    "    while 条件                #2\n",
    "        i番目の要素の値をxに足す   #3\n",
    "\n",
    "    return x\n",
    "```\n",
    "* `#2`の条件は何にするのか。\n",
    "* 無限ループに入らないように`#1`と`#3`に付け加えることはないか。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 6＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    x = 0\n",
    "    count = 0                  #1\n",
    "    \n",
    "    while count < リストの要素数  #2\n",
    "        i番目の要素の値をxに足す    #3\n",
    "        countを1増やす           #4\n",
    "\n",
    "    return x\n",
    "```\n",
    "* `#3`の`i`と`#1`，`#2`，`#4`の`count`はどう関係しているのか？同じ？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 7＞\n",
    "```\n",
    "def 合計(リスト)\n",
    "\n",
    "    x = 0\n",
    "    count = 0\n",
    "    \n",
    "    while count < リストの要素数\n",
    "        count番目の要素の値をxに足す\n",
    "        countを1増やす\n",
    "\n",
    "    return x\n",
    "```\n",
    "* ここまで来るとゴールは目の前‼️\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def sum_while_loop(lst):\n",
    "    \n",
    "    x = 0\n",
    "    count = 0\n",
    "    \n",
    "    while count < len(lst):\n",
    "        x += lst[count]\n",
    "        count += 1\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "関数を実行しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 4950)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_while_loop([1,2,3]), sum_while_loop(range(0,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## コイントス（`for`ループ）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでの目的：\n",
    "> `n`回コイントスし，表と裏の回数を表示する関数を作成する。ただし`random.randint()`と`for`ループを使うこと。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 1＞\n",
    "```\n",
    "def コイントス(n)\n",
    "   \n",
    "    0回目のコイントス　→　表・裏  #1\n",
    "    1回目のコイントス　→　表・裏  #1\n",
    "    2回目のコイントス　→　表・裏  #1\n",
    "    ・・・\n",
    "    n-1回目のコイントス　→　表・裏   #1\n",
    "   \n",
    "    表の合計を計算  #2\n",
    "    裏の合計を計算  #2\n",
    "    \n",
    "    表の合計と裏の合計を返す\n",
    "```\n",
    "* `#1`で表と裏をどう表す？\n",
    "* `#2`の合計の計算はどうする？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 2＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    0回目のコイントス　→　random.randint(0,1)   #1\n",
    "    1回目のコイントス　→　random.randint(0,1)   #1\n",
    "    2回目のコイントス　→　random.randint(0,1)   #1\n",
    "    ・・・\n",
    "    n-1回目のコイントス　→　random.randint(0,1) #1\n",
    "   \n",
    "    表の合計を計算  #2\n",
    "    裏の合計を計算  #2\n",
    "    \n",
    "    表の合計と裏の合計を返す\n",
    "```\n",
    "* `#1`は似たコードになるのでループを使おう。\n",
    "* `#2`の合計の計算はどうする？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 3＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    for ループ\n",
    "        random.randint(0,1)  #1\n",
    "   \n",
    "    表の合計を計算  #2\n",
    "    裏の合計を計算  #2\n",
    "    \n",
    "    表の合計と裏の合計を返す\n",
    "```\n",
    "* `#1`が実行されるたびに`0`又は`1`が出るが，記録されていない。記録する変数を導入する必要がある。\n",
    "* その記録を使って`#2`の合計の計算できる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 4＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    \n",
    "    for ループ                 #1\n",
    "        random.randint(0,1)\n",
    "        結果が１であれば，headsを１増やす\n",
    "        結果が０であれば，tailsを１増やす\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* `#1`で使うイタラブルは何か？\n",
    "* `#1`で使うイタラブル用の変数は何か？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    \n",
    "    for _ <-- 0からn-1まで            #1\n",
    "        random.randint(0,1)\n",
    "        結果が１であれば，headsを１増やす  #2\n",
    "        結果が０であれば，tailsを１増やす  #2\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* `#1`で`_`を使っている理由：\n",
    "    * `i`や`j`などでも良いが，`for`ループの「本体」で使われていない変数には`_`が使われることがよくある。\n",
    "* `#2`を`if`文に書き換える必要がある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 6＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    \n",
    "    for _ <-- 0からn-1まで\n",
    "    \n",
    "        random.randint(0,1)の結果をresultに割り当てる\n",
    "        \n",
    "        if resultが１\n",
    "            headsを１増やす\n",
    "        \n",
    "        else\n",
    "            tailsを１増やす\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* ここまで来ればゴールは目の前‼️\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def coin_toss_for_loop(n):\n",
    "    \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    \n",
    "    for _ in range(n):\n",
    "        \n",
    "        result = random.randint(0,1)\n",
    "        \n",
    "        if result == 1:\n",
    "            heads += 1\n",
    "            \n",
    "        else:\n",
    "            tails += 1\n",
    "    \n",
    "    return heads, tails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "実行しよう"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(54, 46)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coin_toss_for_loop(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## コイントス（`while`ループ）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでの目的：\n",
    "> `n`回コイントスし，表と裏の回数を表示する関数を作成する。ただし`random.randint()`と`while`ループを使うこと。\n",
    "\n",
    "コイントス（`for`ループ）の＜Ver. 2＞まで同じ。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 2＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    0回目のコイントス　→　random.randint(0,1)   #1\n",
    "    1回目のコイントス　→　random.randint(0,1)   #1\n",
    "    2回目のコイントス　→　random.randint(0,1)   #1\n",
    "    ・・・\n",
    "    n-1回目のコイントス　→　random.randint(0,1) #1\n",
    "   \n",
    "    表の合計を計算  #2\n",
    "    裏の合計を計算  #2\n",
    "    \n",
    "    表の合計と裏の合計を返す\n",
    "```\n",
    "* `#1`は似たコードになるのでループを使おう。\n",
    "* `#2`の合計の計算はどうする？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 3＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "   \n",
    "    while ループ\n",
    "        random.randint(0,1)  #1\n",
    "   \n",
    "    表の合計を計算  #2\n",
    "    裏の合計を計算  #2\n",
    "    \n",
    "    表の合計と裏の合計を返す\n",
    "```\n",
    "* `#1`で結果を記録する必要がある。\n",
    "* その記録を使って`#2`の合計の計算できる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 4＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    # 表：1\n",
    "    # 裏：0\n",
    "    \n",
    "    heads = 0\n",
    "    tails = 0        #1\n",
    "   \n",
    "    while 条件　　     #2\n",
    "    \n",
    "        random.randint(0,1)\n",
    "        結果が１であれば，headsを１増やす\n",
    "        結果が０であれば，tailsを１増やす  #3\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* `#2`の条件は何にするのか。\n",
    "* 無限ループに入らないように`#1`と`#3`に何を付け加える必要があるか。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    count = 0\n",
    "\n",
    "    while count < n\n",
    "    \n",
    "        random.randint(0,1)\n",
    "        結果が１であれば，headsを１増やす  #1\n",
    "        結果が０であれば，tailsを１増やす  #1\n",
    "        countを1増やす\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* `#1`を`if`文として書く。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 6＞\n",
    "```\n",
    "def コイントス(n)\n",
    "    \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    count = 0\n",
    "\n",
    "    while count < n\n",
    "    \n",
    "        random.randint(0,1)の結果をresultに割り当てる\n",
    "        \n",
    "        if resultが１\n",
    "            headsを１増やす\n",
    "        \n",
    "        else\n",
    "            tailsを１増やす\n",
    "            \n",
    "        countを1増やす\n",
    "       \n",
    "    return heads, tails\n",
    "```\n",
    "* ここまで来ればゴールは目の前‼️\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def coin_toss_while_loop(n):\n",
    "    \n",
    "    heads = 0\n",
    "    tails = 0\n",
    "    count = 0\n",
    "    \n",
    "    while count < n:\n",
    "        \n",
    "        result = random.randint(0,1)\n",
    "        \n",
    "        if result == 1:\n",
    "            heads += 1\n",
    "            \n",
    "        else:\n",
    "            tails += 1\n",
    "        \n",
    "        count += 1\n",
    "    \n",
    "    return heads, tails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードを実行しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(48, 52)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coin_toss_while_loop(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## リストの最大値"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでの目的：\n",
    "> リスト（又はタプル）を引数とし，含まれる要素の中から最大値を返す関数を作成する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 1＞\n",
    "```\n",
    "def 最大値を求める（リスト）:\n",
    "\n",
    "    0番目からN番目の要素を比較して最大値を探す  #1\n",
    "    \n",
    "    最大値を返す\n",
    "```\n",
    "* ぼやっとした全体像となっているのは否めない。\n",
    "* `#1`の「比較」をどうするかが重要となる。。:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 2＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "    \n",
    "    # N = リストの要素数\n",
    "    \n",
    "    <0> l[0]をl[1]〜l[N]と比較し，\n",
    "        l[0]が全てに対して大きければ，l[0]が最大値。\n",
    "        そうでなければ<1>に進む。\n",
    "    <1> l[1]をl[2]〜l[N]と比較し，\n",
    "        l[2]が全てに対して大きければ，l[2]が最大値。\n",
    "        そうでなければ<2>に進む。\n",
    "    <2> l[2]をl[3]〜l[N]と比較し，\n",
    "        l[3]が全てに対して大きければ，l[3]が最大値。\n",
    "        そうでなければ<3>に進む。\n",
    "    ・・・・・\n",
    "    <N-1> l[N-1]をl[N]と比較し，\n",
    "          l[N-1]大きければ，l[N-1]が最大値。\n",
    "          そうでなければl[N]が最大値。\n",
    "  \n",
    "    最大値を返す\n",
    "```\n",
    "良さそうにも見えるが，問題がある。\n",
    "* `<0>`では`N`回の比較をおこなう。\n",
    "* `<1>`では`N-1`回の比較をおこなう。\n",
    "* `<2>`では`N-2`回の比較をおこなう。\n",
    "* ・・・・\n",
    "* `<N>`では`1`回の比較をおこなう。\n",
    "* 比較する回数の合計は`1+2+3+・・・+N=N(N+1)/2`。比較回数が非常に多い。もっと良い方法があるのでは？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 3＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    l[0]とl[1]を比較し，大きい方を残す    #1\n",
    "    l[1]とl[2]を比較し，大きい方を残す    #1\n",
    "    l[2]とl[3]を比較し，大きい方を残す    #1\n",
    "    ・・・\n",
    "    l[N-1]とl[N]を比較し，大きい方を残す  #1\n",
    "    \n",
    "    最大値を返す\n",
    "```\n",
    "* 比較する回数は`N`回で＜Ver. 2＞より少ない。\n",
    "* `#1`の「大きい方を残す」はどうする？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 4＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "\n",
    "    max_ = -1_000_000        #1\n",
    "    \n",
    "    l[0]とl[1]を比較し，大きい方をmax_に割り当てる。   #2\n",
    "    l[1]とl[2]を比較し，大きい方をmax_に割り当てる。   #2\n",
    "    l[2]とl[3]を比較し，大きい方をmax_に割り当てる。   #2\n",
    "    ・・・\n",
    "    l[N-1]とl[N]を比較し，大きい方をxに割り当てる。 #2\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#2`だけを見ると最大値は求められそう。\n",
    "* `#1`では最大値が`-1_000_000`未満の場合をカバーできない。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    max_とl[1]を比較し，大きい方をmax_に割り当てる。  #1\n",
    "    max_とl[2]を比較し，大きい方をmax_に割り当てる。  #1\n",
    "    max_とl[3]を比較し，大きい方をmax_に割り当てる。  #1\n",
    "    ・・・\n",
    "    max_とl[N]を比較し，大きい方をmax_に割り当てる。  #1\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#1`は似たようなコードになるのでループを使おう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 5＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    for ループ\n",
    "        max_とl[i]を比較し，大きい方をmax_に割り当てる。 #1\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#1`は条件分岐させる必要がある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 6＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    for ループ     #1\n",
    "        max_ < l[i]の場合は，l[i]をxに割り当てる。\n",
    "        max_ >= l[i]の場合は，pass\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#1`のイタラブルは何にする？\n",
    "* `#1`のイタラブル用の変数は何にする？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 7＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    for i <-- 0から(lの要素数-1)まで                #1\n",
    "        max_ < l[i]の場合は，l[i]をmax_に割り当てる。 #1\n",
    "        max_ >= l[i]の場合は，pass                #1\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#1`の`i`はリストのインデックス番号だが，直接要素自体を使う方が`Python`的である。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 8＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    # N = リストの要素数\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    for v <-- リスト\n",
    "        max_ < vの場合は，vをxに割り当てる。 #1\n",
    "        max_ >= vの場合は，pass          #1\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* `#1`は`if`文に書き換える。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "＜Ver. 9＞\n",
    "```\n",
    "def 最大値を求める（リスト=l）:\n",
    "\n",
    "    max_ = l[0]\n",
    "    \n",
    "    for v <-- リスト\n",
    "    \n",
    "        if max_ < v\n",
    "            max_にvを割り当てる。\n",
    "        else\n",
    "            pass\n",
    "    \n",
    "    return max_\n",
    "```\n",
    "* 後は`Python`コードを書くだけ‼️\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def search_max(l):\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    for v in l:\n",
    "        if v > max_:\n",
    "            max_ = v\n",
    "        else:         # 省略可\n",
    "            pass      # 省略可\n",
    "    \n",
    "    return max_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "実行してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.932262499170067"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [random.gauss(0,1) for _ in range(1000)]\n",
    "\n",
    "search_max(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "code_folding": [],
    "hidden": true
   },
   "source": [
    "````{note}\n",
    "＜Ver. 2＞をコードで書くと次の様になる。上のコードと比べると実行時間が1000倍近く長くなる。\n",
    "```\n",
    "def search_max(l):\n",
    "    \n",
    "    max_ = l[0]\n",
    "    \n",
    "    # 最後の要素はカバーしていない\n",
    "    for idx, val in enumerate(l[:-1]):\n",
    "        \n",
    "        temp = max_\n",
    "        \n",
    "\n",
    "        for k in l[idx+1:]:\n",
    "            if val <= k:\n",
    "                continue\n",
    "            else:\n",
    "                temp = val\n",
    "        \n",
    "        if temp > max_:\n",
    "            max_ = temp\n",
    "    \n",
    "    # 最後の要素について\n",
    "    if max_ < l[-1]:\n",
    "        max_ = l[-1]\n",
    "\n",
    "    return max_\n",
    "```\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 最後に"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードを書くことに慣れてくると，簡単なコードに疑似コードの修正プロセスは必要なくなるだろう。しかし，その段階になればより複雑なコードを書くことになるはずだ。その時には疑似コードが役に立つのではないかと思われる。少し頭をひねるような問題であれば，疑似コードを試してみるのも一案である。"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}