kaggle03bool.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "kaggle03bool.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyP8u/XdojvYvfNgAK1yVnmv",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kalz2q/mycolabnotebooks/blob/master/kaggle03bool.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l1D1jCY2hxoe",
        "colab_type": "text"
      },
      "source": [
        "# kaggle03bool.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GpyiaEBut93i",
        "colab_type": "text"
      },
      "source": [
        "# メモ\n",
        "\n",
        "1. kaggleのPython tutorialをベースにColabベースのノートブックを作成しているうちの1つ。\n",
        "\n",
        "1. Colabで開いて読まれることを想定。\n",
        "\n",
        "1. 元ファイル ( https://www.kaggle.com/colinmorris/booleans-and-conditionals)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jwIeF_2_uFsa",
        "colab_type": "text"
      },
      "source": [
        "# ブール型\n",
        "ブール型の値はTrueとFalseだけ。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qMEGBuXSvQc1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "3db7c4c8-9f99-41ec-97d2-94ab0689c3dd"
      },
      "source": [
        "x = True\n",
        "print(x)\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "<class 'bool'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rh0C2VA4vOgF",
        "colab_type": "text"
      },
      "source": [
        "上の例ではxにTrueを代入したが、通常はブール演算の結果としてブール型を得る。\n",
        "ブール演算はyes/noの質問に答える形の式のこと。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fBcSC1mpud7c",
        "colab_type": "text"
      },
      "source": [
        "## 比較演算\n",
        "| 演算\t| 説明\t|\t|演算\t|説明|\n",
        "|---|---|---|---|---|\n",
        "| a == b\t| a は b に等しい            |\t| a != b\t| a は b に等しくない |\n",
        "| a < b\t  | a 小なり b\t            | \t| a > b\t  | a 大なり b |\n",
        "| a <= b\t| a 小なりイコール b\t|\t| a >= b\t| a 大なりイコール b |\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X3ODDSF1AAJE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "03cb6a71-8b10-44e4-9695-70abf7f29fdf"
      },
      "source": [
        "# 引数に年齢を入れて呼び出すと、アメリカの大統領に立候補できる年齢かどうかを判定する\n",
        "\n",
        "def can_run_for_president(age):\n",
        "    \"\"\"Can someone of the given age run for president in the US?\"\"\"\n",
        "    # The US Constitution says you must be at least 35 years old\n",
        "    return age >= 35\n",
        "\n",
        "print(\"Can a 19-year-old run for president?\", can_run_for_president(19))\n",
        "print(\"Can a 45-year-old run for president?\", can_run_for_president(45))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Can a 19-year-old run for president? False\n",
            "Can a 45-year-old run for president? True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lqyMy__aum5l",
        "colab_type": "text"
      },
      "source": [
        "## ブール値の組み合わせ\n",
        "`and`、`or`、`not`でブール値を組み合わせることができる。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C7yZyY_BBMsa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "de5c289d-89a8-4441-fb18-82fe98125210"
      },
      "source": [
        "#引数に年齢とアメリカ生まれかどうかを入れて呼び出すと、アメリカの大統領に立候補することが法律上できるかどうかを判定してTrueまたはFalseを返す\n",
        "\n",
        "def can_run_for_president(age, is_natural_born_citizen):\n",
        "    \"\"\"Can someone of the given age and citizenship status run for president in the US?\"\"\"\n",
        "    # The US Constitution says you must be a natural born citizen *and* at least 35 years old\n",
        "    return is_natural_born_citizen and (age >= 35)\n",
        "\n",
        "print(can_run_for_president(19, True))\n",
        "print(can_run_for_president(55, False))\n",
        "print(can_run_for_president(55, True))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HJfjOYxKEMoh",
        "colab_type": "text"
      },
      "source": [
        "次のコードの結果を考えてから実行してみよう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V08dgCVTESRI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6c092ac0-bf06-4501-c8e8-40c1d35b63f0"
      },
      "source": [
        "True or True and False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AENpAcQ8BIEu",
        "colab_type": "text"
      },
      "source": [
        "これを理解するためには、ブール演算の優先順位を考える必要がある。\n",
        "\n",
        "`and`は`or`より先に評価される。\n",
        "\n",
        "しかし、優先順位を覚えるよりも、なるべくカッコを使ってわかりやすくする方が大切。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZkvclDpFX-v",
        "colab_type": "text"
      },
      "source": [
        "## 条件文\n",
        "ブール型は`if、`elif`、`else`キーワードの条件文と組み合わせて使われる時に威力を発揮する。\n",
        "\n",
        "条件文は`if`文とも言われ、ブール型の条件の結果によって実行するコードをコントロールするもの。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fOftabML70ku",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "b79a224d-12bc-488d-e1ff-31929311a40d"
      },
      "source": [
        "# 引数がゼロか、正か、負かを判定して文字列で返す\n",
        "\n",
        "def inspect(x):\n",
        "    if x == 0:\n",
        "        print(x, \"is zero\")\n",
        "    elif x > 0:\n",
        "        print(x, \"is positive\")\n",
        "    elif x < 0:\n",
        "        print(x, \"is negative\")\n",
        "    else:\n",
        "        print(x, \"is unlike anything I've ever seen...\")\n",
        "\n",
        "inspect(0)\n",
        "inspect(-15)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 is zero\n",
            "-15 is negative\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QbFg_YXFUxF-",
        "colab_type": "text"
      },
      "source": [
        "Pythonの条件文はifで始まり、elifおよびelseブロックはオプションであってもなくてもよい。「else if」の短縮形であるelifは、綴りが特別なので注意する。\n",
        "\n",
        "また、if節、elif節、else節にコロンがつくことが慣れないうちは忘れがちなので注意する。\n",
        "\n",
        "考察: なぜ `else if`でなくて`elif`なのか。他の言語で`else if`と書くのをPythonで実現すると\n",
        "```\n",
        "    else:\n",
        "        if x <  0 :\n",
        "            print (\"This is inside else if\")\n",
        "```\n",
        "となってしまい一気にインデントが2回必要になる。これを避けるため、というのがひとつ。もう一つはRubyも同じだがifの後置が可能な言語の場合、ifの中のifを先に評価する文法が必要で普通のifと区別するため、ではないか。\n",
        "\n",
        "\n",
        "      "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S6zM9pj4ohkb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "7aab3d93-2d03-482e-ab24-a13641c120a7"
      },
      "source": [
        "def f(x):\n",
        "    if x > 0:\n",
        "        print(\"Only printed when x is positive; x =\", x)\n",
        "        print(\"Also only printed when x is positive; x =\", x)\n",
        "    print(\"Always printed, regardless of x's value; x =\", x)\n",
        "\n",
        "f(1)\n",
        "f(0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Only printed when x is positive; x = 1\n",
            "Also only printed when x is positive; x = 1\n",
            "Always printed, regardless of x's value; x = 1\n",
            "Always printed, regardless of x's value; x = 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "izRvMBlAu7G-",
        "colab_type": "text"
      },
      "source": [
        "# 真偽判断\n",
        "\n",
        "なにがTrueでなにがFalseなのか。\n",
        "\n",
        "Pythonでは`0`と空文字列、空リスト、などがFalseでそれ以外はTrue。\n",
        "\n",
        "あらゆる値を真偽値に変換する関数`bool()`があり、`int()`や`float()`のように使う。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ccjxdFpep-D1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        },
        "outputId": "a21b933c-c896-4754-be8c-42a8e4b5750f"
      },
      "source": [
        "print(bool(1)) # all numbers are treated as true, except 0\n",
        "print(bool(0))\n",
        "print(bool(-1))\n",
        "print(bool(\"asf\")) # all strings are treated as true, except the empty string \"\"\n",
        "print(bool(\"\"))\n",
        "print(bool([]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n",
            "False\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E6svb0nyjgLi",
        "colab_type": "text"
      },
      "source": [
        "# 練習問題\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F3D9leh9NybG",
        "colab_type": "text"
      },
      "source": [
        "### 問題 1\n",
        "\n",
        "数値の引数を取り、負の場合は-1、正の場合は1、0の場合は0を返す、signと呼ばれる関数を定義する。多くのプログラミング言語にはあって、Pythonの組み込み関数にはないもの。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mFIE3xODPi9u",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "d5290f5a-826c-41e9-9dc9-2d304994c9bc"
      },
      "source": [
        "# Define a function which takes a numerical argument and returns -1 if it's negative, 1 if it's positive and 0 otherwise\n",
        "def sign (x) :\n",
        "    if x < 0 :\n",
        "        return -1\n",
        "    elif x > 0 :\n",
        "        return 1\n",
        "    else :\n",
        "        return 0\n",
        "\n",
        "print (sign(-1))\n",
        "print (sign(1))\n",
        "print (sign(0))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-1\n",
            "1\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FPQ-F_NoQcm9",
        "colab_type": "text"
      },
      "source": [
        "### 問題 2\n",
        "\n",
        "`to_smash`という関数を作り、引数で与えられた数を3で割った余りを返す。その際、\n",
        "\"Splitting n candies\"と表示する。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eEk8XRhuSVvP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 155
        },
        "outputId": "7c8a88b8-5fc4-40f8-ae51-9f8b03245dbf"
      },
      "source": [
        "def to_smash(total_candies):\n",
        "    \"\"\"Return the number of leftover candies that must be smashed after distributing\n",
        "    the given number of candies evenly between 3 friends.\"\"\"\n",
        "    if total_candies == 1 :\n",
        "         print (\"Splitting \", total_candies, \" candy\" )\n",
        "         return total_candies % 3\n",
        "    else :\n",
        "            print(\"Splitting\", total_candies, \"candies\")\n",
        "    return total_candies % 3\n",
        "\n",
        "print(to_smash(91))\n",
        "print(to_smash(1))\n",
        "print(to_smash(21))\n",
        "print(to_smash(0))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Splitting 91 candies\n",
            "1\n",
            "Splitting  1  candy\n",
            "1\n",
            "Splitting 21 candies\n",
            "0\n",
            "Splitting 0 candies\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oj0npLc6dw7Y",
        "colab_type": "text"
      },
      "source": [
        "### 問題 3\n",
        "\n",
        "傘問題。もし、傘を持っているか、フードがあって雨が激しくなければ大丈夫。雨が降っても仕事日でなければ大丈夫。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YKexT6ACHcvr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6f45c2ee-3b22-4717-be71-896a1506582f"
      },
      "source": [
        "# umprella problem\n",
        "def prepared_for_weather(have_umbrella, rain_level, have_hood, is_workday):\n",
        "    # Don't change this code. Our goal is just to find the bug, not fix it!\n",
        "    return have_umbrella or (rain_level < 5 and have_hood) or (not (rain_level > 0 and is_workday))\n",
        "\n",
        "# Change the values of these inputs so they represent a case where prepared_for_weather\n",
        "# returns the wrong answer.\n",
        "have_umbrella = False\n",
        "rain_level = 1\n",
        "have_hood = False\n",
        "is_workday = True\n",
        "\n",
        "# Check what the function returns given the current values of the variables above\n",
        "actual = prepared_for_weather(have_umbrella, rain_level, have_hood, is_workday)\n",
        "print(actual)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8RuXM6Zrp5FS",
        "colab_type": "text"
      },
      "source": [
        "### 問題 4\n",
        "\n",
        "次の関数`is_negative`を書き換えて、1行のプログラム`concise_is_negative'にする。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0HOvQWXqeQP4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def is_negative(number):\n",
        "    if number < 0:\n",
        "        return True\n",
        "    else:\n",
        "        return False\n",
        "​"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "emtCkFOLeWXn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def concise_is_negative(number):\n",
        "    pass # Your code goes here (try to keep it to one line!)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RgjB-EtieeNz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "a0dd6cde-7d52-415f-d543-61b83bf11c7a"
      },
      "source": [
        "def concise_is_negative(number):\n",
        "    return (number < 0)\n",
        "\n",
        "print(concise_is_negative(3))\n",
        "print(concise_is_negative(-1))\n",
        "print(concise_is_negative(0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bpfFtIL_qDsH",
        "colab_type": "text"
      },
      "source": [
        "### 問題 5\n",
        "\n",
        "変数`ketchup`, `mustard`, `onion`はブール型で、ホットドッグのトッピングのありなしを表している。客の注文時のイエス・ノー質問に対応する関数を作る。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XY3xZFr5hhBl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        },
        "outputId": "448578b0-66fa-478d-cb03-e709b5ad4207"
      },
      "source": [
        "def onionless(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer doesn't want onions\"\"\"\n",
        "    return not onion\n",
        "\n",
        "def ketchupless(ketchup, mustard, onion):\n",
        "    return not ketchup\n",
        "\n",
        "def mustardless(ketchup, mustard, onion):\n",
        "    return not mustard\n",
        "\n",
        "\n",
        "def wants_all_toppings(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer wants \"the works\" (all 3 toppings)\"\"\"\n",
        "    return (ketchup and mustard and onion)\n",
        "\n",
        "def wants_plain_hotdog(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer wants a plain hot dog with no toppings\"\"\"\n",
        "    return (not ketchup and not mustard and not onion)\n",
        "\n",
        "def exactly_one_sauce(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer wants either ketchup or mustard, but not both.\n",
        "    (You may be familiar with this operation under the name \"exclusive or\")\n",
        "    \"\"\"\n",
        "    return (ketchup or mustard) and (not (ketchup and mustard))\n",
        "\n",
        "ketchup = False\n",
        "mustard = False\n",
        "onion = False\n",
        "\n",
        "print (wants_all_toppings(ketchup, mustard, onion))\n",
        "print (wants_plain_hotdog(ketchup, mustard, onion))\n",
        "print (exactly_one_sauce(ketchup, mustard, onion))\n",
        "\n",
        "ketchup = True\n",
        "mustard = True\n",
        "onion = True\n",
        "\n",
        "print (wants_all_toppings(ketchup, mustard, onion))\n",
        "print (wants_plain_hotdog(ketchup, mustard, onion))\n",
        "print (exactly_one_sauce(ketchup, mustard, onion))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "False\n",
            "True\n",
            "False\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OT9WynwoqXss",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "### 問題 6\n",
        "\n",
        "`bool()`は引数が0ならばFalseでそれ以外はTrueを返す。\n",
        "\n",
        "`int()`の引数にブール型を入れた場合どうなるか、実験し、その結果を用いて、お客がトッピングを1つだけ選ぶ、という場合の関数を書く。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v83oa7gl0Atn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "c5575313-2323-46a7-f32d-28134f5725d1"
      },
      "source": [
        "print (int(True))\n",
        "print (int(False))"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i_11jVDpz37V",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5f9fce7f-4319-4371-903d-46456f178b5a"
      },
      "source": [
        "def exactly_one_topping(ketchup, mustard, onion):\n",
        "    \"\"\"Return whether the customer wants exactly one of the three available toppings\n",
        "    on their hot dog.\n",
        "    \"\"\"\n",
        "    return (int(ketchup) + int(mustard) + int(onion)) == 1\n",
        "\n",
        "ketchup = True\n",
        "mustard = True\n",
        "onion = True\n",
        "\n",
        "print (exactly_one_topping(ketchup, mustard, onion))"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Drhp4DPtqZc7",
        "colab_type": "text"
      },
      "source": [
        "### 問題 7\n",
        "\n",
        "この問題では単純化したブラックジャック(別名トゥエンティ・ワン)を使う。プレーヤー1人とディーラー1人でプレイするものとする。\n",
        "\n",
        "プレーヤーは何度でも次のカードを要求(`hit`)できる。手持ちのカードが21を超えたら、その時点で負けとなる。\n",
        "\n",
        "ディーラーはカードを自分で引いて:\n",
        "ディーラーのカード合計が21を超えたら、プレーヤーの勝ち。\n",
        "ディーラーのカード合計が17以上ならば、プレーヤーがディーラーより大きかった場合だけプレーヤーの勝ち。タイの場合でもディーラーの勝ち。\n",
        "\n",
        "合計の際、ジャック、クイーン、キングは10とする。エースは1または11を合計が21を超えないように選べる。例えば、\n",
        "```\n",
        "A+8 = 19, A+8+8 = 17\n",
        "```\n",
        "この問題では、プレーヤーが`hit`するかどうかの戦略を決定するプログラムを作る。最初の戦略は次のとおり。\n",
        "\n",
        "```\n",
        "def should_hit(dealer_total, player_total, player_low_aces, player_high_aces):\n",
        "    \"\"\"Return True if the player should hit (request another card) given the current game\n",
        "    state, or False if the player should stay.\n",
        "    When calculating a hand's total value, we count aces as \"high\" (with value 11) if doing so\n",
        "    doesn't bring the total above 21, otherwise we count them as low (with value 1). \n",
        "    For example, if the player's hand is {A, A, A, 7}, we will count it as 11 + 1 + 1 + 7,\n",
        "    and therefore set player_total=20, player_low_aces=2, player_high_aces=1.\n",
        "    \"\"\"\n",
        "    return False\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xl31t9rX3vH-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def should_hit(dealer_total, player_total, player_low_aces, player_high_aces):\n",
        "    \"\"\"Return True if the player should hit (request another card) given the current game\n",
        "    state, or False if the player should stay.\n",
        "    When calculating a hand's total value, we count aces as \"high\" (with value 11) if doing so\n",
        "    doesn't bring the total above 21, otherwise we count them as low (with value 1). \n",
        "    For example, if the player's hand is {A, A, A, 7}, we will count it as 11 + 1 + 1 + 7,\n",
        "    and therefore set player_total=20, player_low_aces=2, player_high_aces=1.\n",
        "    \"\"\"\n",
        "    if player_total <= 13 :\n",
        "        return True\n",
        "    else :\n",
        "        return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9lc0hSH06b5",
        "colab_type": "text"
      },
      "source": [
        "この保守的な戦略では、プレーヤは常に配られた2枚だけを根拠に判断する。\n",
        "\n",
        "ゲームをシミュレートしてみると、この単純な戦略だけで、ゲームの状況を無視していてもそこそこ勝てることがわかる。\n",
        "\n",
        "プレーヤーの勝ち率が上がるよう工夫してみよう。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SRfjwbpm5Pod",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def should_hit(dealer_total, player_total, player_low_aces, player_high_aces):\n",
        "    \"\"\"Return True if the player should hit (request another card) given the current game\n",
        "    state, or False if the player should stay.\n",
        "    When calculating a hand's total value, we count aces as \"high\" (with value 11) if doing so\n",
        "    doesn't bring the total above 21, otherwise we count them as low (with value 1). \n",
        "    For example, if the player's hand is {A, A, A, 7}, we will count it as 11 + 1 + 1 + 7,\n",
        "    and therefore set player_total=20, player_low_aces=2, player_high_aces=1.\n",
        "    \"\"\"\n",
        "    if player_total <= 13 :\n",
        "        return True\n",
        "    elif (player_high_aces == 1) and (player_total <= 17):\n",
        "        return True\n",
        "    else :\n",
        "        return False"
      ],
      "execution_count": 48,
      "outputs": []
    }
  ]
}