From 209b11be753dd65aac89ac3d4099d7037e3df4bc Mon Sep 17 00:00:00 2001 From: Mark Daoust Date: Thu, 27 Jun 2024 11:14:06 -0700 Subject: [PATCH] cleanup + format --- examples/Object_detection.ipynb | 110 ++-- examples/prompting/Self_ask_prompting.ipynb | 167 +++--- quickstarts/Code_Execution.ipynb | 537 ++++++++++++++------ 3 files changed, 492 insertions(+), 322 deletions(-) diff --git a/examples/Object_detection.ipynb b/examples/Object_detection.ipynb index 22ea2e713..c848c9275 100644 --- a/examples/Object_detection.ipynb +++ b/examples/Object_detection.ipynb @@ -66,8 +66,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "46zEFO2a9FFd", - "outputId": "38bebdc7-fa5e-48d9-8996-f155b95e42c7" + "id": "46zEFO2a9FFd" }, "outputs": [ { @@ -458,8 +457,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "9tWmY-3QipvK", - "outputId": "6f37d591-4748-4d66-dd09-6eecfddb2e6a" + "id": "9tWmY-3QipvK" }, "outputs": [ { @@ -484,8 +482,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "VZpN7EhQ4RtJ", - "outputId": "e52d5de9-30b7-44c5-b6a6-976874ceed5c" + "id": "VZpN7EhQ4RtJ" }, "outputs": [ { @@ -513,8 +510,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "nLL28l-Cln_f", - "outputId": "1338de0e-80f9-4cd0-a446-f1c095458a8a" + "id": "nLL28l-Cln_f" }, "outputs": [ { @@ -566,8 +562,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "EFwPLbFP6PeP", - "outputId": "6a43b81d-28a0-48ee-a820-a76a7c0ab620" + "id": "EFwPLbFP6PeP" }, "outputs": [ { @@ -597,8 +592,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "dq0iHPFnx71V", - "outputId": "7f8eb175-e713-42c5-82be-9f0571fce8b5" + "id": "dq0iHPFnx71V" }, "outputs": [ { @@ -650,8 +644,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "TOfGkvwSsuGa", - "outputId": "a604d4ba-3e6c-4ca0-f873-1bdf98cda1ea" + "id": "TOfGkvwSsuGa" }, "outputs": [ { @@ -685,8 +678,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "znGcX4ED7Xew", - "outputId": "74b417e9-4326-4e94-af74-650f708fa025" + "id": "znGcX4ED7Xew" }, "outputs": [ { @@ -746,8 +738,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "E3bfny-37jet", - "outputId": "6cec4a53-9eb1-4ac3-c0c8-5d935909fe1d" + "id": "E3bfny-37jet" }, "outputs": [ { @@ -772,8 +763,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "lEwZHwyFUIzj", - "outputId": "6175fe49-f8ab-4c2a-e7cd-4d613c7bf453" + "id": "lEwZHwyFUIzj" }, "outputs": [ { @@ -802,8 +792,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "OjXWN6NR9_kR", - "outputId": "ec72fc91-0cd6-415b-a26b-c997a9d75f6b" + "id": "OjXWN6NR9_kR" }, "outputs": [ { @@ -864,8 +853,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "SMHiaqCYwYtQ", - "outputId": "5e0f6bb4-2b68-4ee9-b7fd-83175dde60a1" + "id": "SMHiaqCYwYtQ" }, "outputs": [ { @@ -900,8 +888,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "dAOGEaFvYDHd", - "outputId": "c678030b-d8ce-4562-a790-38926f6b8c4e" + "id": "dAOGEaFvYDHd" }, "outputs": [ { @@ -934,8 +921,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "rnJ1620ZxWVT", - "outputId": "6d765927-7277-4dc5-e722-2443cff88298" + "id": "rnJ1620ZxWVT" }, "outputs": [ { @@ -986,8 +972,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "Rzug1ZVPUnvt", - "outputId": "4a0e7c02-1c67-44ee-9f80-65d4480a62e6" + "id": "Rzug1ZVPUnvt" }, "outputs": [ { @@ -1012,8 +997,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "4c517S-kUOIv", - "outputId": "a5e191b2-8c36-4a52-aeb3-a58ef783e83d" + "id": "4c517S-kUOIv" }, "outputs": [ { @@ -1047,8 +1031,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "8wwXMtLvUxSQ", - "outputId": "e5721967-8d1e-4ebb-bdeb-84cae92ca7d2" + "id": "8wwXMtLvUxSQ" }, "outputs": [ { @@ -1099,8 +1082,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "9Bc_HY7c5nBR", - "outputId": "bb25a9f0-b29d-4164-cfaf-c418d71ebaeb" + "id": "9Bc_HY7c5nBR" }, "outputs": [ { @@ -1126,8 +1108,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "J52oUKFh9KeI", - "outputId": "25e4a816-63c2-40a3-ff65-5fd9460af57f" + "id": "J52oUKFh9KeI" }, "outputs": [ { @@ -1159,8 +1140,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "Enr9zcRY__qm", - "outputId": "7d958ee6-3235-4cd9-978e-008850923638" + "id": "Enr9zcRY__qm" }, "outputs": [ { @@ -1192,8 +1172,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "TVI202fRHPe3", - "outputId": "8bcd211f-a5c3-48e7-e48b-29d441b3c6a6" + "id": "TVI202fRHPe3" }, "outputs": [ { @@ -1282,8 +1261,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "qSzcPiIAO-z8", - "outputId": "b5a12852-0fa4-4ccb-ee42-635909750b7b" + "id": "qSzcPiIAO-z8" }, "outputs": [ { @@ -1383,8 +1361,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "mIyx6mqwPgOd", - "outputId": "071626c2-7b80-4d70-bbd0-1c3963ca2058" + "id": "mIyx6mqwPgOd" }, "outputs": [ { @@ -1405,8 +1382,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "n0K6it54O-z8", - "outputId": "eeb8b323-4b95-4c04-d9ca-d2e25ba1bf28" + "id": "n0K6it54O-z8" }, "outputs": [ { @@ -1431,8 +1407,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "EzugRgZT10u-", - "outputId": "594569d8-924d-47aa-bdc2-d6d25ea06a0e" + "id": "EzugRgZT10u-" }, "outputs": [ { @@ -1526,8 +1501,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "xb0_moMm1M6D", - "outputId": "43c6ab7f-d75e-4384-ba44-b2532630e274" + "id": "xb0_moMm1M6D" }, "outputs": [ { @@ -1550,8 +1524,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "1PUJh7hx1WRq", - "outputId": "2a814aee-f5bf-4ef4-cc45-e7cac8f0cd48" + "id": "1PUJh7hx1WRq" }, "outputs": [ { @@ -1574,8 +1547,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "LjMPlrLI1YER", - "outputId": "abad0e48-342c-4df2-85e6-1c443e2b420b" + "id": "LjMPlrLI1YER" }, "outputs": [ { @@ -1598,8 +1570,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "a75HXaQL1Zn1", - "outputId": "1b0fdcad-1de1-4024-a917-d80b51d203a4" + "id": "a75HXaQL1Zn1" }, "outputs": [ { @@ -1622,8 +1593,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "_miGOSdoDYFG", - "outputId": "fbdd5772-ef29-4b71-a399-96f264f574f7" + "id": "_miGOSdoDYFG" }, "outputs": [ { @@ -1652,8 +1622,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "caaYBGrGDpnf", - "outputId": "6325e46d-c8a3-4fcd-8221-4f3b9745e567" + "id": "caaYBGrGDpnf" }, "outputs": [ { @@ -1697,8 +1666,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "7bTOlFdmwFLu", - "outputId": "bb1f6388-9efc-4df8-e21a-2b9d75b3a328" + "id": "7bTOlFdmwFLu" }, "outputs": [ { @@ -1723,8 +1691,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "TVXSbIGpCsc4", - "outputId": "dcf57671-bb4d-4580-c761-940c11921e74" + "id": "TVXSbIGpCsc4" }, "outputs": [ { @@ -1752,8 +1719,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "W3FhAC6dC972", - "outputId": "3e2730d2-b3af-4722-b748-2928073a101d" + "id": "W3FhAC6dC972" }, "outputs": [ { @@ -1775,8 +1741,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "RMJ10S5CKmDD", - "outputId": "098fb51e-cc91-43ce-a360-417f3dd09205" + "id": "RMJ10S5CKmDD" }, "outputs": [ { @@ -1799,8 +1764,7 @@ "metadata": { "colab": { "name": "Object_detection.ipynb", - "toc_visible": true, - "provenance": [] + "toc_visible": true }, "kernelspec": { "display_name": "Python 3", @@ -1809,4 +1773,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/examples/prompting/Self_ask_prompting.ipynb b/examples/prompting/Self_ask_prompting.ipynb index 78973205b..bc94db60c 100644 --- a/examples/prompting/Self_ask_prompting.ipynb +++ b/examples/prompting/Self_ask_prompting.ipynb @@ -1,30 +1,22 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, "cells": [ { "cell_type": "markdown", - "source": [ - "##### Copyright 2024 Google LLC." - ], "metadata": { "id": "d2PtAueID-nE" - } + }, + "source": [ + "##### Copyright 2024 Google LLC." + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "bipCP1xBEAJF" + }, + "outputs": [], "source": [ "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", @@ -37,66 +29,57 @@ "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License." - ], - "metadata": { - "id": "bipCP1xBEAJF" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "source": [ - "# Gemini API: Self-ask prompting" - ], "metadata": { "id": "sP8PQnz1QrcF" - } + }, + "source": [ + "# Gemini API: Self-ask prompting" + ] }, { "cell_type": "markdown", + "metadata": { + "id": "bxGr_x3MRA0z" + }, "source": [ "\n", " \n", "
\n", " Run in Google Colab\n", "
" - ], - "metadata": { - "id": "bxGr_x3MRA0z" - } + ] }, { "cell_type": "markdown", - "source": [ - "Self ask prompting is similar to chain of thought, but instead of going step by step as one answer, it asks itself questions that will help answer the query. Like the chain of thought, it helps the model to think analytically." - ], "metadata": { "id": "ysy--KfNRrCq" - } + }, + "source": [ + "Self ask prompting is similar to chain of thought, but instead of going step by step as one answer, it asks itself questions that will help answer the query. Like the chain of thought, it helps the model to think analytically." + ] }, { "cell_type": "code", - "source": [ - "!pip install -U -q google-generativeai" - ], + "execution_count": null, "metadata": { - "id": "Ne-3gnXqR0hI", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "047a609f-de91-4143-aadf-faf231671d79" + "id": "Ne-3gnXqR0hI" }, - "execution_count": null, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/158.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m30.7/158.8 kB\u001b[0m \u001b[31m829.7 kB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━\u001b[0m \u001b[32m153.6/158.8 kB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.8/158.8 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h" ] } + ], + "source": [ + "!pip install -U -q google-generativeai" ] }, { @@ -114,40 +97,57 @@ }, { "cell_type": "markdown", + "metadata": { + "id": "eomJzCa6lb90" + }, "source": [ "## Configure your API key\n", "\n", "To run the following cell, your API key must be stored it in a Colab Secret named `GOOGLE_API_KEY`. If you don't already have an API key, or you're not sure how to create a Colab Secret, see [Authentication](https://github.com/google-gemini/cookbook/blob/main/quickstarts/Authentication.ipynb) for an example." - ], - "metadata": { - "id": "eomJzCa6lb90" - } + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "v-JZzORUpVR2" + }, + "outputs": [], "source": [ "from google.colab import userdata\n", "GOOGLE_API_KEY=userdata.get('GOOGLE_API_KEY')\n", "\n", "genai.configure(api_key=GOOGLE_API_KEY)" - ], - "metadata": { - "id": "v-JZzORUpVR2" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", - "source": [ - "## Example" - ], "metadata": { "id": "yQnqEPjephXi" - } + }, + "source": [ + "## Example" + ] }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XEfLLHa7pjC8" + }, + "outputs": [ + { + "data": { + "text/markdown": "Let's break this down step by step:\n\n**1. When was Maria Skłodowska born?** \n\n* Maria Skłodowska (Marie Curie) was born on November 7, 1867.\n\n**2. Who was the Emperor of Japan in 1867?**\n\n* The Emperor of Japan in 1867 was **Emperor Meiji**, who reigned from 1867 to 1912.\n\n**3. Where did Emperor Meiji die?**\n\n* Emperor Meiji died in **Tokyo, Japan** on July 30, 1912.\n\n**Final Answer:** The Emperor of Japan who ruled the year Maria Skłodowska was born, Emperor Meiji, died in Tokyo, Japan. \n", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "prompt = \"\"\"\n", "Question: Who was the president of the united states when Mozart died?\n", @@ -161,42 +161,31 @@ "Question: Where did the Emperor of Japan, who ruled the year Maria Skłodowska was born, die?\"\"\"\n", "model = genai.GenerativeModel(model_name='gemini-1.5-flash-latest')\n", "Markdown(model.generate_content(prompt).text)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 210 - }, - "id": "XEfLLHa7pjC8", - "outputId": "fcba7e92-32ae-49a9-ca75-3da2137351b3" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ], - "text/markdown": "Let's break this down step by step:\n\n**1. When was Maria Skłodowska born?** \n\n* Maria Skłodowska (Marie Curie) was born on November 7, 1867.\n\n**2. Who was the Emperor of Japan in 1867?**\n\n* The Emperor of Japan in 1867 was **Emperor Meiji**, who reigned from 1867 to 1912.\n\n**3. Where did Emperor Meiji die?**\n\n* Emperor Meiji died in **Tokyo, Japan** on July 30, 1912.\n\n**Final Answer:** The Emperor of Japan who ruled the year Maria Skłodowska was born, Emperor Meiji, died in Tokyo, Japan. \n" - }, - "metadata": {}, - "execution_count": 8 - } ] }, { "cell_type": "markdown", + "metadata": { + "id": "1RtZ1y-IpcnV" + }, "source": [ - "\n", "## Additional note\n", "Self-ask prompting works well with function calling. Follow-up questions can be used as input to a function, which e.g. searches the internet. The question and answer from the function can be added back to the prompt. During the next query to the model, it can either create another function call or return the final answer.\n", "\n", "For a related example, please see the [Search re-ranking using Gemini embeddings](https://github.com/google-gemini/cookbook/blob/22ba52659005defc53ce2d6717fb9fedf1d661f1/examples/Search_reranking_using_embeddings.ipynb) example in the Gemini Cookbook." - ], - "metadata": { - "id": "1RtZ1y-IpcnV" - } + ] } - ] -} \ No newline at end of file + ], + "metadata": { + "colab": { + "name": "Self_ask_prompting.ipynb", + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/quickstarts/Code_Execution.ipynb b/quickstarts/Code_Execution.ipynb index 7ba0da7dc..0382fb90a 100644 --- a/quickstarts/Code_Execution.ipynb +++ b/quickstarts/Code_Execution.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "cellView": "form", "id": "tuOe1ymfHZPu" @@ -77,13 +77,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "id": "OsxWu_BI50Ex" }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'0.7.1'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import google.generativeai as genai" + "import google.generativeai as genai\n", + "genai.__version__" ] }, { @@ -109,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "kS3JQzazOI48" }, @@ -117,7 +129,7 @@ "source": [ "from IPython.display import HTML, Markdown\n", "\n", - "def set_css_in_cell_output():\n", + "def set_css_in_cell_output(unused):\n", " display(HTML(\"\"\"" + "def is_prime(n):\n", + " if n <= 1:\n", + " return False\n", + " for i in range(2, int(math.sqrt(n)) + 1):\n", + " if n % i == 0:\n", + " return False\n", + " return True\n", + "\n", + "primes = []\n", + "i = 2\n", + "while len(primes) < 200:\n", + " if is_prime(i):\n", + " primes.append(i)\n", + " i += 1\n", + "\n", + "print(f'The first 200 prime numbers are: {primes}')\n", + "print(f'The sum of the first 200 prime numbers is: {sum(primes)}')\n", + "\n", + "```\n", + "```\n", + "The first 200 prime numbers are: [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223]\n", + "The sum of the first 200 prime numbers is: 111587\n", + "\n", + "```\n", + "The sum of the first 200 prime numbers is **111587**. \n" ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": "Let's break down this problem step by step and use Python to help with some calculations.\n\n**1. Calculate the moles of O2 produced**\n\n* **Decomposition of KClO3:**\n * 2KClO3 → 2KCl + 3O2\n* **Molar mass of KClO3:** 122.55 g/mol\n* **Molar mass of O2:** 32 g/mol\n\n\n\n``` python\nimport sympy\n\n# Define symbols\nKClO3 = sympy.Symbol('KClO3')\nO2 = sympy.Symbol('O2')\n\n# Define the balanced chemical equation\nequation = 2*KClO3 == 2*sympy.Symbol('KCl') + 3*O2\n\n# Calculate the moles of KClO3\nmoles_KClO3 = 49 / 122.55\n\n# Solve for the moles of O2 using the stoichiometric ratio\nmoles_O2 = (3/2) * moles_KClO3\nprint(f'{moles_O2=}')\n\n```\n```\nmoles_O2=0.5997552019583844\n\n```\nWe have successfully calculated the moles of O2 produced: 0.5997552019583844 moles.\n\n**2. Calculate the mass of pure metal that reacted**\n\n* We need to consider the purity of the metal (20%)\n* The metal oxide formation involves oxygen reacting with the metal:\n * Metal + O2 → Metal Oxide\n* We need to find the mass of the pure metal that reacted with the oxygen.\n\n**3. Determine the metal and its oxide**\n\n* We are told the metal is amphoteric and one of the most abundant in the Earth's crust.\n* This strongly suggests the metal is **Aluminum (Al)**.\n* Its oxide is **Aluminum Oxide (Al2O3)**.\n\n**4. Calculate the mass of Aluminum Oxide formed**\n\n* **Molar mass of Al:** 26.98 g/mol\n* **Molar mass of Al2O3:** 101.96 g/mol\n\nTo calculate the mass of Aluminum Oxide formed, we need to determine the limiting reactant: Aluminum or Oxygen.\n\n\n\n``` python\nimport sympy\n\n# Define symbols\nO2 = sympy.Symbol('O2')\nAl = sympy.Symbol('Al')\nAl2O3 = sympy.Symbol('Al2O3')\n\n# Define the balanced chemical equation\nequation = 4*Al + 3*O2 == 2*Al2O3\n\n# Calculate the moles of Al that reacted (based on 20% purity)\nmoles_Al = 0.2 * 10.8 / 26.98\n\n# Calculate the moles of Al2O3 based on moles of Al\nmoles_Al2O3_from_Al = (1/2) * moles_Al\n\n# Calculate the moles of Al2O3 based on moles of O2\nmoles_Al2O3_from_O2 = (2/3) * moles_O2\n\n# Determine the limiting reactant\nif moles_Al2O3_from_Al < moles_Al2O3_from_O2:\n limiting_reactant = 'Al'\n moles_Al2O3 = moles_Al2O3_from_Al\nelse:\n limiting_reactant = 'O2'\n moles_Al2O3 = moles_Al2O3_from_O2\n\n# Calculate the mass of Al2O3\nmass_Al2O3 = moles_Al2O3 * 101.96\nprint(f'{mass_Al2O3=}')\n\n```\n```\nmass_Al2O3=4.081423276501112\n\n```\nWe've calculated the mass of Al2O3 formed: 4.081423276501112 g. \n\n**5. Calculate the mass of Carbon needed**\n\n* The reaction to convert Al2O3 back to Al involves using carbon as a reducing agent:\n * Al2O3 + 3C → 2Al + 3CO\n* **Molar mass of C:** 12.01 g/mol\n\n\n\n``` python\nimport sympy\n\n# Define symbols\nAl2O3 = sympy.Symbol('Al2O3')\nC = sympy.Symbol('C')\nAl = sympy.Symbol('Al')\n\n# Define the balanced chemical equation\nequation = Al2O3 + 3*C == 2*Al + 3*sympy.Symbol('CO')\n\n# Calculate the moles of Al2O3\nmoles_Al2O3 = 4.081423276501112 / 101.96\n\n# Calculate the moles of C using the stoichiometric ratio\nmoles_C = 3 * moles_Al2O3\nprint(f'{moles_C=}')\n\n# Calculate the mass of C\nmass_C = moles_C * 12.01\nprint(f'{mass_C=}')\n\n```\n```\nmoles_C=0.1200889547813195\nmass_C=1.4422683469236472\n\n```\nWe've calculated the mass of Carbon needed: 1.4422683469236472 g.\n\n**Final answer:**\n\nTherefore, approximately **1.44 g** of carbon is needed to convert the aluminum oxide back to pure aluminum. \n", "text/plain": [ "" ] }, - "execution_count": 38, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "response = chat.send_message(\n", - " \"Run some code to help with this problem:\\n\\n\"\n", - " \"When 49 g of KClO3 decomposes, the resulting O2 reacts with 10.8 g of impure metal (20% purity) to form metal oxide. \"\n", - " \"Calculate the amount of carbon needed to convert the metal oxide back to pure metal. The metal is amphoteric in nature \"\n", - " \"and is one of the most abundant metals in earth crust.\")\n", - "\n", - "Markdown(response.text)" + "from IPython.display import Markdown\n", + "Markdown(result.text)" ] }, { @@ -605,12 +591,12 @@ "id": "avyoRa0XF5wR" }, "source": [ - "You can also set the `tools` argument on the call to `generate_content`:" + "Note: you can also set the `tools` argument on the call to `generate_content`:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "id": "DL2mRlNTF5JN" }, @@ -654,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "id": "fY062-nsGLBu" }, @@ -700,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "id": "fQY1_501GfP-" }, @@ -739,12 +725,23 @@ }, { "data": { - "text/markdown": "\n``` python\nprint(list(filter(lambda x: x == 'r', 'strawberry')).__len__())\n\n```\n```\n3\n\n```\nThere are **3** letter r in the word strawberry. I used python's `filter` function to filter out all the 'r' in the word and used `__len__` to get the length of the filtered list. \n", + "text/markdown": [ + "\n", + "``` python\n", + "print(list('strawberry').count('r'))\n", + "\n", + "```\n", + "```\n", + "3\n", + "\n", + "```\n", + "There are 3 letter r's in the word strawberry. \n" + ], "text/plain": [ "" ] }, - "execution_count": 28, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -761,12 +758,12 @@ "source": [ "## Chat\n", "\n", - "It works the same with when using a `chat`:" + "It works the same when using a `chat`:" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "id": "_19QkCnQEZSu" }, @@ -810,7 +807,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "id": "VFMAiEH_Dx6E" }, @@ -849,12 +846,45 @@ }, { "data": { - "text/markdown": "\n``` python\nimport random\n\ndef bogo_sort(list_):\n while not is_sorted(list_):\n random.shuffle(list_)\n return list_\n\ndef is_sorted(list_):\n for i in range(len(list_) - 1):\n if list_[i] > list_[i + 1]:\n return False\n return True\n\nlist_ = [2, 34, 1, 65, 4]\nsorted_list = bogo_sort(list_)\nprint(f'{sorted_list=}')\n\n```\n```\nsorted_list=[1, 2, 4, 34, 65]\n\n```\nBogo sort is a very inefficient sorting algorithm. It works by repeatedly shuffling the list until it is sorted. The code above implements the algorithm in Python and prints the sorted list. \n\nBogo sort is not a practical sorting algorithm, but it is a fun example of how inefficient an algorithm can be.\n", + "text/markdown": [ + "\n", + "``` python\n", + "import random\n", + "\n", + "def bogo_sort(arr):\n", + " while not is_sorted(arr):\n", + " random.shuffle(arr)\n", + " return arr\n", + "\n", + "def is_sorted(arr):\n", + " for i in range(len(arr) - 1):\n", + " if arr[i] > arr[i + 1]:\n", + " return False\n", + " return True\n", + "\n", + "arr = [2, 34, 1, 65, 4]\n", + "sorted_arr = bogo_sort(arr)\n", + "print(f'Sorted array: {sorted_arr}')\n", + "\n", + "```\n", + "```\n", + "Sorted array: [1, 2, 4, 34, 65]\n", + "\n", + "```\n", + "The code defines two functions:\n", + "\n", + "1. `bogo_sort`: This function takes a list as input and shuffles it randomly until it is sorted. The `is_sorted` function is called to check if the list is sorted.\n", + "2. `is_sorted`: This function checks if a list is sorted in ascending order by iterating through the list and comparing adjacent elements.\n", + "\n", + "The provided list `[2, 34, 1, 65, 4]` is passed to the `bogo_sort` function, which randomly shuffles the list until it is sorted in ascending order. The final sorted list is then printed as `[1, 2, 4, 34, 65]`. \n", + "\n", + "It's important to note that Bogo sort is a notoriously inefficient sorting algorithm. It has an average time complexity of O(n!), which makes it impractical for sorting even moderately sized lists. \n" + ], "text/plain": [ "" ] }, - "execution_count": 30, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -866,7 +896,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "id": "ANxrYfl0Bk6T" }, @@ -905,12 +935,44 @@ }, { "data": { - "text/markdown": "\n``` python\nimport random\n\ndef bogo_sort(list_):\n iterations = 0\n while not is_sorted(list_):\n random.shuffle(list_)\n iterations += 1\n return list_, iterations\n\ndef is_sorted(list_):\n for i in range(len(list_) - 1):\n if list_[i] > list_[i + 1]:\n return False\n return True\n\nlist_ = [2, 34, 1, 65, 4]\nsorted_list, iterations = bogo_sort(list_)\nprint(f'{sorted_list=}')\nprint(f'{iterations=}')\n\n```\n```\nsorted_list=[1, 2, 4, 34, 65]\niterations=90\n\n```\nI've modified the code to count the iterations by adding a counter variable `iterations` that increments each time the list is shuffled. It took `90` iterations to sort the list. \n\nI should point out that bogo sort is very sensitive to the size of the input list and the order of elements. The number of iterations can vary greatly even for small changes in the input. In this case, it took 90 iterations. In other cases, it could take many more or many fewer iterations to sort the list.", + "text/markdown": [ + "\n", + "``` python\n", + "import random\n", + "\n", + "def bogo_sort(arr):\n", + " iterations = 0\n", + " while not is_sorted(arr):\n", + " random.shuffle(arr)\n", + " iterations += 1\n", + " return arr, iterations\n", + "\n", + "def is_sorted(arr):\n", + " for i in range(len(arr) - 1):\n", + " if arr[i] > arr[i + 1]:\n", + " return False\n", + " return True\n", + "\n", + "arr = [2, 34, 1, 65, 4]\n", + "sorted_arr, iterations = bogo_sort(arr)\n", + "print(f'Sorted array: {sorted_arr}')\n", + "print(f'Iterations: {iterations}')\n", + "\n", + "```\n", + "```\n", + "Sorted array: [1, 2, 4, 34, 65]\n", + "Iterations: 90\n", + "\n", + "```\n", + "The code now includes a counter `iterations` in the `bogo_sort` function. The counter is incremented every time the list is shuffled. When the list is sorted, the number of iterations is printed along with the sorted list.\n", + "\n", + "In this particular run, it took `90` iterations to sort the list. However, since Bogo Sort relies on random shuffling, the number of iterations needed to sort the list can vary significantly. It's important to note that, as we discussed previously, this is a very inefficient algorithm, and for larger lists, the number of iterations could be extremely high. \n" + ], "text/plain": [ "" ] }, - "execution_count": 32, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -940,7 +1002,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "id": "bDg1bDRpAnFR" }, @@ -983,7 +1045,7 @@ "text": [ " % Total % Received % Xferd Average Speed Time Time Time Current\n", " Dload Upload Total Spent Left Speed\n", - "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 24719 100 24719 0 0 184k 0 --:--:-- --:--:-- --:--:-- 185k\n" + "100 24719 100 24719 0 0 394k 0 --:--:-- --:--:-- --:--:-- 395k\n" ] } ], @@ -993,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "id": "1Uhq7nZPEsvO" }, @@ -1032,12 +1094,12 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] }, - "execution_count": 46, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1050,7 +1112,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { "id": "2S0WIddTEzUm" }, @@ -1089,12 +1151,77 @@ }, { "data": { - "text/markdown": "I understand that you want to simulate the Monty Hall Problem 1,000 times to see if it is better to switch doors. I can do that.\n\n\n``` python\nimport random\n\ndef monty_hall_simulation(num_trials):\n wins_switch = 0\n wins_stay = 0\n for _ in range(num_trials):\n # Assign the car and goats randomly\n doors = [0, 1, 2]\n car_door = random.choice(doors)\n \n # Player's initial choice\n player_choice = random.choice(doors)\n \n # Host reveals a goat\n remaining_doors = [door for door in doors if door != player_choice and door != car_door]\n host_reveals = random.choice(remaining_doors)\n \n # Switch or stay\n if player_choice == car_door:\n wins_stay += 1\n else:\n wins_switch += 1\n \n return wins_switch, wins_stay\n\nwins_switch, wins_stay = monty_hall_simulation(1000)\nprint(f\"Wins switching: {wins_switch}\")\nprint(f\"Wins staying: {wins_stay}\")\n\n```\n```\nWins switching: 658\nWins staying: 342\n\n```\nThe results of the simulation show that you win more often by switching doors. This is because when you initially choose a door, you have a 1/3 chance of selecting the door with the car. This means there's a 2/3 chance the car is behind one of the other two doors. When the host reveals a goat, that 2/3 probability is concentrated on the remaining unopened door.\n\nSo, switching doors gives you a 2/3 chance of winning, while staying gives you a 1/3 chance. \n", + "text/markdown": [ + "I can help you with that! \n", + "\n", + "It turns out that switching doors does significantly increase your chances of winning! Here's why, and a simulation of the Monty Hall problem in Python that will demonstrate.\n", + "\n", + "The Monty Hall problem is a bit counterintuitive, but here's why switching doors works:\n", + "\n", + "1. **Initial Choice:** When you first choose a door, you have a 1/3 chance of picking the door with the car and a 2/3 chance of picking a door with a goat.\n", + "\n", + "2. **Host's Action:** The host *always* reveals a goat behind one of the doors you didn't choose. This doesn't change the initial probabilities. Your chosen door still has a 1/3 chance of having the car.\n", + "\n", + "3. **The Switch:** The key is that the remaining unopened door *now* concentrates the remaining 2/3 probability. The host's action has effectively transferred the probability from the revealed goat door to the other unopened door.\n", + "\n", + "Now, let's run a Python simulation to see this in action:\n", + "\n", + "\n", + "``` python\n", + "import random\n", + "\n", + "def play_monty_hall(switch_doors):\n", + " # 1. Choose a door (0, 1, or 2)\n", + " chosen_door = random.randint(0, 2)\n", + "\n", + " # 2. Determine where the car is\n", + " car_door = random.randint(0, 2)\n", + "\n", + " # 3. Host reveals a goat\n", + " if chosen_door == car_door:\n", + " # Host reveals a random goat\n", + " revealed_goat = random.choice([door for door in range(3) if door != chosen_door])\n", + " else:\n", + " # Host reveals the goat behind the other unchosen door\n", + " revealed_goat = [door for door in range(3) if door != chosen_door and door != car_door][0]\n", + "\n", + " # 4. Switch doors?\n", + " if switch_doors:\n", + " remaining_door = [door for door in range(3) if door != chosen_door and door != revealed_goat][0]\n", + " chosen_door = remaining_door\n", + "\n", + " # 5. Check if you won\n", + " return chosen_door == car_door\n", + "\n", + "# Run the simulation\n", + "num_trials = 1000\n", + "switch_wins = 0\n", + "stay_wins = 0\n", + "\n", + "for _ in range(num_trials):\n", + " if play_monty_hall(True):\n", + " switch_wins += 1\n", + " if play_monty_hall(False):\n", + " stay_wins += 1\n", + "\n", + "print(f\"Switching doors: {switch_wins/num_trials:.2%}\")\n", + "print(f\"Staying with initial choice: {stay_wins/num_trials:.2%}\")\n", + "\n", + "```\n", + "```\n", + "Switching doors: 68.50%\n", + "Staying with initial choice: 34.80%\n", + "\n", + "```\n", + "The simulation shows that switching doors wins about 68.5% of the time, while staying with your initial choice wins only about 34.8% of the time. This is consistent with the theoretical probability of switching doors winning (which is 2/3 or about 66.7%).\n", + "\n", + "This simulation confirms that switching doors in the Monty Hall problem is the more advantageous strategy. \n" + ], "text/plain": [ "" ] }, - "execution_count": 49, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1141,7 +1268,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": { "id": "J9s8DPy7GuKN" }, @@ -1185,34 +1312,46 @@ "text: \"I\"\n", "\n", "----------------------------------------\n", - "text: \" can help with that! I\\'ll simulate the Monty Hall problem 1,\"\n", + "text: \" can help you run a simulation of the Monty Hall problem to illustrate the best strategy\"\n", + "\n", + "----------------------------------------\n", + "text: \".\\n\\nHere\\'s how the simulation works:\\n\\n1. **Initialize Variables\"\n", + "\n", + "----------------------------------------\n", + "text: \":** We\\'ll track the number of wins for switching doors and staying with the original choice.\\n2. **Simulate Game:** For each trial:\\n\"\n", + "\n", + "----------------------------------------\n", + "text: \" - Randomly assign the car and goats behind the doors.\\n - The player chooses a door at random.\\n - The host reveals a goat\"\n", + "\n", + "----------------------------------------\n", + "text: \" behind a different door.\\n - The player either stays with their original choice or switches.\\n - The results are recorded based on the player\\'s decision and whether they won or lost.\\n3. **Calculate Results:** After\"\n", "\n", "----------------------------------------\n", - "text: \"000 times and report the results.\\n\\n\"\n", + "text: \" a large number of trials (in this case, 1,000), we\\'ll calculate the winning percentages for both strategies.\\n\\n\"\n", "\n", "----------------------------------------\n", "executable_code {\n", " language: PYTHON\n", - " code: \"\\nimport random\\n\\ndef monty_hall_game(switch):\\n # Choose a door randomly\\n chosen_door = random.randint(1, 3)\\n # Determine the winning door\\n winning_door = random.randint(1, 3)\\n\\n # If the chosen door is the winning door, switching loses\\n if chosen_door == winning_door:\\n return not switch\\n\\n # Otherwise, switching wins\\n else:\\n return switch\\n\\n\\ndef run_simulation(trials):\\n wins_switch = 0\\n wins_no_switch = 0\\n for _ in range(trials):\\n if monty_hall_game(switch=True):\\n wins_switch += 1\\n if monty_hall_game(switch=False):\\n wins_no_switch += 1\\n\\n return wins_switch, wins_no_switch\\n\\nwins_switch, wins_no_switch = run_simulation(1000)\\n\\nprint(f\\'Wins by switching: {wins_switch}\\')\\nprint(f\\'Wins by not switching: {wins_no_switch}\\')\\n\"\n", + " code: \"\\nimport random\\n\\ndef monty_hall_simulation(num_trials):\\n wins_switch = 0\\n wins_stay = 0\\n\\n for _ in range(num_trials):\\n # Randomly assign car and goats\\n doors = [\\'goat\\', \\'goat\\', \\'car\\']\\n random.shuffle(doors)\\n\\n # Player chooses a door\\n player_choice = random.randint(0, 2)\\n\\n # Host reveals a goat\\n host_choice = 0\\n while host_choice == player_choice or doors[host_choice] == \\'car\\':\\n host_choice = random.randint(0, 2)\\n\\n # Player switches or stays\\n stay_choice = player_choice\\n switch_choice = 0\\n while switch_choice == stay_choice or switch_choice == host_choice:\\n switch_choice = random.randint(0, 2)\\n\\n # Determine if the player wins or loses\\n if doors[stay_choice] == \\'car\\':\\n wins_stay += 1\\n if doors[switch_choice] == \\'car\\':\\n wins_switch += 1\\n\\n return wins_stay, wins_switch\\n\\n# Run the simulation\\nnum_trials = 1000\\nwins_stay, wins_switch = monty_hall_simulation(num_trials)\\n\\n# Print the results\\nprint(f\\\"Staying with original choice: Won {wins_stay} out of {num_trials} trials ({wins_stay / num_trials * 100:.2f}%)\\\")\\nprint(f\\\"Switching doors: Won {wins_switch} out of {num_trials} trials ({wins_switch / num_trials * 100:.2f}%)\\\")\\n\"\n", "}\n", "\n", "----------------------------------------\n", "code_execution_result {\n", " outcome: OUTCOME_OK\n", - " output: \"Wins by switching: 678\\nWins by not switching: 349\\n\"\n", + " output: \"Staying with original choice: Won 351 out of 1000 trials (35.10%)\\nSwitching doors: Won 649 out of 1000 trials (64.90%)\\n\"\n", "}\n", "\n", "----------------------------------------\n", "text: \"The\"\n", "\n", "----------------------------------------\n", - "text: \" simulation shows that you win about 68% of the time when you switch\"\n", + "text: \" simulation shows that you\\'re much more likely to win if you switch doors (\"\n", "\n", "----------------------------------------\n", - "text: \" doors, and only about 35% of the time when you stay with\"\n", + "text: \"64.90% win rate) compared to staying with your original choice\"\n", "\n", "----------------------------------------\n", - "text: \" your original choice. This demonstrates that switching is the better strategy in the Monty Hall problem. \\n\"\n", + "text: \" (35.10% win rate). This demonstrates that switching doors is indeed the better strategy in the Monty Hall Problem. \\n\"\n", "\n", "----------------------------------------\n" ] @@ -1236,18 +1375,77 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { "id": "yjUSubFXiaEP" }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text: \"I can help you run a simulation of the Monty Hall problem to illustrate the best strategy.\\n\\nHere\\'s how the simulation works:\\n\\n1. **Initialize Variables:** We\\'ll track the number of wins for switching doors and staying with the original choice.\\n2. **Simulate Game:** For each trial:\\n - Randomly assign the car and goats behind the doors.\\n - The player chooses a door at random.\\n - The host reveals a goat behind a different door.\\n - The player either stays with their original choice or switches.\\n - The results are recorded based on the player\\'s decision and whether they won or lost.\\n3. **Calculate Results:** After a large number of trials (in this case, 1,000), we\\'ll calculate the winning percentages for both strategies.\\n\\n\"\n", + "\n", + "----------------------------------------\n", + "executable_code {\n", + " language: PYTHON\n", + " code: \"\\nimport random\\n\\ndef monty_hall_simulation(num_trials):\\n wins_switch = 0\\n wins_stay = 0\\n\\n for _ in range(num_trials):\\n # Randomly assign car and goats\\n doors = [\\'goat\\', \\'goat\\', \\'car\\']\\n random.shuffle(doors)\\n\\n # Player chooses a door\\n player_choice = random.randint(0, 2)\\n\\n # Host reveals a goat\\n host_choice = 0\\n while host_choice == player_choice or doors[host_choice] == \\'car\\':\\n host_choice = random.randint(0, 2)\\n\\n # Player switches or stays\\n stay_choice = player_choice\\n switch_choice = 0\\n while switch_choice == stay_choice or switch_choice == host_choice:\\n switch_choice = random.randint(0, 2)\\n\\n # Determine if the player wins or loses\\n if doors[stay_choice] == \\'car\\':\\n wins_stay += 1\\n if doors[switch_choice] == \\'car\\':\\n wins_switch += 1\\n\\n return wins_stay, wins_switch\\n\\n# Run the simulation\\nnum_trials = 1000\\nwins_stay, wins_switch = monty_hall_simulation(num_trials)\\n\\n# Print the results\\nprint(f\\\"Staying with original choice: Won {wins_stay} out of {num_trials} trials ({wins_stay / num_trials * 100:.2f}%)\\\")\\nprint(f\\\"Switching doors: Won {wins_switch} out of {num_trials} trials ({wins_switch / num_trials * 100:.2f}%)\\\")\\n\"\n", + "}\n", + "\n", + "----------------------------------------\n", + "code_execution_result {\n", + " outcome: OUTCOME_OK\n", + " output: \"Staying with original choice: Won 351 out of 1000 trials (35.10%)\\nSwitching doors: Won 649 out of 1000 trials (64.90%)\\n\"\n", + "}\n", + "\n", + "----------------------------------------\n", + "text: \"The simulation shows that you\\'re much more likely to win if you switch doors (64.90% win rate) compared to staying with your original choice (35.10% win rate). This demonstrates that switching doors is indeed the better strategy in the Monty Hall Problem. \\n\"\n", + "\n", + "----------------------------------------\n" + ] + } + ], "source": [ - "print(result.candidates[0].content.parts)" + "for part in result.candidates[0].content.parts:\n", + " print(part)\n", + " print('----------------------------------------')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": { "id": "3sJ7LTpVFsqM" }, @@ -1288,50 +1486,69 @@ "name": "stdout", "output_type": "stream", "text": [ - "I can help with that! I'll simulate the Monty Hall problem 1,000 times and report the results.\n", + "I can help you run a simulation of the Monty Hall problem to illustrate the best strategy.\n", + "\n", + "Here's how the simulation works:\n", + "\n", + "1. **Initialize Variables:** We'll track the number of wins for switching doors and staying with the original choice.\n", + "2. **Simulate Game:** For each trial:\n", + " - Randomly assign the car and goats behind the doors.\n", + " - The player chooses a door at random.\n", + " - The host reveals a goat behind a different door.\n", + " - The player either stays with their original choice or switches.\n", + " - The results are recorded based on the player's decision and whether they won or lost.\n", + "3. **Calculate Results:** After a large number of trials (in this case, 1,000), we'll calculate the winning percentages for both strategies.\n", "\n", "\n", "``` python\n", "import random\n", "\n", - "def monty_hall_game(switch):\n", - " # Choose a door randomly\n", - " chosen_door = random.randint(1, 3)\n", - " # Determine the winning door\n", - " winning_door = random.randint(1, 3)\n", + "def monty_hall_simulation(num_trials):\n", + " wins_switch = 0\n", + " wins_stay = 0\n", + "\n", + " for _ in range(num_trials):\n", + " # Randomly assign car and goats\n", + " doors = ['goat', 'goat', 'car']\n", + " random.shuffle(doors)\n", "\n", - " # If the chosen door is the winning door, switching loses\n", - " if chosen_door == winning_door:\n", - " return not switch\n", + " # Player chooses a door\n", + " player_choice = random.randint(0, 2)\n", "\n", - " # Otherwise, switching wins\n", - " else:\n", - " return switch\n", + " # Host reveals a goat\n", + " host_choice = 0\n", + " while host_choice == player_choice or doors[host_choice] == 'car':\n", + " host_choice = random.randint(0, 2)\n", "\n", + " # Player switches or stays\n", + " stay_choice = player_choice\n", + " switch_choice = 0\n", + " while switch_choice == stay_choice or switch_choice == host_choice:\n", + " switch_choice = random.randint(0, 2)\n", "\n", - "def run_simulation(trials):\n", - " wins_switch = 0\n", - " wins_no_switch = 0\n", - " for _ in range(trials):\n", - " if monty_hall_game(switch=True):\n", - " wins_switch += 1\n", - " if monty_hall_game(switch=False):\n", - " wins_no_switch += 1\n", + " # Determine if the player wins or loses\n", + " if doors[stay_choice] == 'car':\n", + " wins_stay += 1\n", + " if doors[switch_choice] == 'car':\n", + " wins_switch += 1\n", "\n", - " return wins_switch, wins_no_switch\n", + " return wins_stay, wins_switch\n", "\n", - "wins_switch, wins_no_switch = run_simulation(1000)\n", + "# Run the simulation\n", + "num_trials = 1000\n", + "wins_stay, wins_switch = monty_hall_simulation(num_trials)\n", "\n", - "print(f'Wins by switching: {wins_switch}')\n", - "print(f'Wins by not switching: {wins_no_switch}')\n", + "# Print the results\n", + "print(f\"Staying with original choice: Won {wins_stay} out of {num_trials} trials ({wins_stay / num_trials * 100:.2f}%)\")\n", + "print(f\"Switching doors: Won {wins_switch} out of {num_trials} trials ({wins_switch / num_trials * 100:.2f}%)\")\n", "\n", "```\n", "```\n", - "Wins by switching: 678\n", - "Wins by not switching: 349\n", + "Staying with original choice: Won 351 out of 1000 trials (35.10%)\n", + "Switching doors: Won 649 out of 1000 trials (64.90%)\n", "\n", "```\n", - "The simulation shows that you win about 68% of the time when you switch doors, and only about 35% of the time when you stay with your original choice. This demonstrates that switching is the better strategy in the Monty Hall problem. \n", + "The simulation shows that you're much more likely to win if you switch doors (64.90% win rate) compared to staying with your original choice (35.10% win rate). This demonstrates that switching doors is indeed the better strategy in the Monty Hall Problem. \n", "\n" ] }