The Gemini API code execution feature enables the model to generate and run Python code based on plain-text instructions that you give it, and even output graphs. It can learn iteratively from the results until it arrives at a final output.
This notebook is a walk through:
Install the Google GenAI SDK from npm.
$ npm install @google/genaiYou can create your API key using Google AI Studio with a single click.
Remember to treat your API key like a password. Don’t accidentally save it in a notebook or source file you later commit to GitHub. In this notebook we will be storing the API key in a .env file. You can also set it as an environment variable or use a secret manager.
Here’s how to set it up in a .env file:
$ touch .env
$ echo "GEMINI_API_KEY=<YOUR_API_KEY>" >> .envAnother option is to set the API key as an environment variable. You can do this in your terminal with the following command:
$ export GEMINI_API_KEY="<YOUR_API_KEY>"To load the API key from the .env file, we will use the dotenv package. This package loads environment variables from a .env file into process.env.
$ npm install dotenvThen, we can load the API key in our code:
const dotenv = require("dotenv") as typeof import("dotenv");
dotenv.config({
path: "../.env",
});
const GEMINI_API_KEY = process.env.GEMINI_API_KEY ?? "";
if (!GEMINI_API_KEY) {
throw new Error("GEMINI_API_KEY is not set in the environment variables");
}
console.log("GEMINI_API_KEY is set in the environment variables");GEMINI_API_KEY is set in the environment variablesIn our particular case the .env is is one directory up from the notebook, hence we need to use ../ to go up one directory. If the .env file is in the same directory as the notebook, you can omit it altogether.
│
├── .env
└── quickstarts
└── Code_Execution.ipynbWith the new SDK, now you only need to initialize a client with you API key (or OAuth if using Vertex AI). The model is now set in each call.
const google = require("@google/genai") as typeof import("@google/genai");
const ai = new google.GoogleGenAI({ apiKey: GEMINI_API_KEY });Now select the model you want to use in this guide, either by selecting one in the list or writing it down. Keep in mind that some models, like the 2.5 ones are thinking models and thus take slightly more time to respond (cf. thinking notebook for more details and in particular learn how to switch the thiking off).
const tslab = require("tslab") as typeof import("tslab");
const MODEL_ID = "gemini-2.5-flash-preview-05-20";When using code execution as a tool, the model returns a list of parts including text, executableCode, executionResult, and inlineData parts. Use the function below to help you visualize and better display the code execution results. Here are a few details about the different fields of the results:
text: Inline text generated by the model.executableCode: Code generated by the model that is meant to be executed.codeExecutionResult: Result of the executable_code.inlineData: Inline media generated by the model.import { GenerateContentResponse } from "@google/genai";
function displayCodeExecutionResult(code_response: GenerateContentResponse) {
const code_response_parts = (code_response.candidates ? code_response.candidates[0]?.content?.parts : []) ?? [];
for (const part of code_response_parts) {
if (part.text) {
tslab.display.markdown(part.text);
}
if (part.executableCode) {
tslab.display.markdown(`\`\`\`python\n${part.executableCode.code}\n\`\`\``);
}
if (part.codeExecutionResult) {
tslab.display.markdown(`\`\`\`\n${part.codeExecutionResult.output}\n\`\`\``);
}
if (part.inlineData) {
const imageData = part.inlineData.data!;
const buffer = Buffer.from(imageData, "base64");
tslab.display.png(buffer);
}
}
}codeExecution with a single callWhen initiating the model, pass codeExecution as a tool to tell the model that it is allowed to generate and run code.
const code_response_1 = await ai.models.generateContent({
model: MODEL_ID,
contents: [
`
What is the sum of the first 50 prime numbers?
Generate and run code for the calculation, and make sure you get all 50.
`,
],
config: {
tools: [{ codeExecution: {} }],
},
});
displayCodeExecutionResult(code_response_1);To find the sum of the first 50 prime numbers, I will generate the primes using a primality test function and then sum them up.
import math
def is_prime(n):
"""Checks if a number is prime."""
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(math.sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
primes = []
num = 2
while len(primes) < 50:
if is_prime(num):
primes.append(num)
num += 1
sum_of_primes = sum(primes)
print(f"The first 50 prime numbers are: {primes}")
print(f"The count of prime numbers found is: {len(primes)}")
print(f"The sum of the first 50 prime numbers is: {sum_of_primes}")The first 50 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]
The count of prime numbers found is: 50
The sum of the first 50 prime numbers is: 5117
The first 50 prime numbers have been identified and listed, and their count has been verified to be 50.
The sum of the first 50 prime numbers is 5117.
The dataset you will use in this guide comes from the StatLib from the Department of Statistics at Carnegie Mellon University. It is made available by the scikit-learn under the 3-Clause BSD license.
It provides 20k information on various blocks in Californina, including the location (longitute/lattitude), average income, housing average age, average rooms, average bedrooms, population, average occupation.
Here’s a breakdown of the columns and what the attributes represent:
Code execution functionality works best with a .csv or .txt file.
const danfojs = require("danfojs-node") as typeof import("danfojs-node");
const DATASET_URL =
"https://raw.githubusercontent.com/javascriptdata/scikit.js/refs/heads/main/docs/static/data/california_housing.csv";
console.log("Loading California housing dataset from:", DATASET_URL);
const california_housing = await danfojs.readCSV(DATASET_URL);Loading California housing dataset from: https://raw.githubusercontent.com/javascriptdata/scikit.js/refs/heads/main/docs/static/data/california_housing.csvconst path = require("path") as typeof import("path");
const houses_data = california_housing.head(5000);
houses_data.print();
const csvFilePath = path.join("../assets", "california_housing.csv");
danfojs.toCSV(houses_data, { filePath: csvFilePath });╔════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
║ │ MedInc │ HouseAge │ AveRooms │ AveBedrms │ Population │ AveOccup │ Latitude │ Longitude │ MedHouseVal ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 0 │ 8.3252 │ 41 │ 6.9841269841269… │ 1.0238095238095… │ 322 │ 2.5555555555555… │ 37.88 │ -122.23 │ 4.526 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 1 │ 8.3014 │ 21 │ 6.2381370826010… │ 0.9718804920913… │ 2401 │ 2.1098418277680… │ 37.86 │ -122.22 │ 3.585 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 2 │ 7.2574 │ 52 │ 8.2881355932203… │ 1.0734463276836… │ 496 │ 2.8022598870056… │ 37.85 │ -122.24 │ 3.521 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 3 │ 5.6431 │ 52 │ 5.8173515981735… │ 1.0730593607305… │ 558 │ 2.5479452054794… │ 37.85 │ -122.25 │ 3.413 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 4 │ 3.8462 │ 52 │ 6.2818532818532… │ 1.0810810810810… │ 565 │ 2.1814671814671… │ 37.85 │ -122.25 │ 3.422 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 5 │ 4.0368 │ 52 │ 4.7616580310880… │ 1.1036269430051… │ 413 │ 2.1398963730569… │ 37.85 │ -122.25 │ 2.697 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 6 │ 3.6591 │ 52 │ 4.9319066147859… │ 0.9513618677042… │ 1094 │ 2.1284046692607… │ 37.84 │ -122.25 │ 2.992 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 7 │ 3.12 │ 52 │ 4.7975270479134… │ 1.0618238021638… │ 1157 │ 1.7882534775888… │ 37.84 │ -122.25 │ 2.414 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 8 │ 2.0804 │ 42 │ 4.2941176470588… │ 1.1176470588235… │ 1206 │ 2.0268907563025… │ 37.84 │ -122.26 │ 2.267 ║
╟────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 9 │ 3.6912 │ 52 │ 4.9705882352941… │ 0.9901960784313… │ 1551 │ 2.1722689075630… │ 37.84 │ -122.25 │ 2.611 ║
╚════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╝
const houses_file = await ai.files.upload({
file: csvFilePath,
config: {
displayName: "california_housing.csv",
mimeType: "text/csv",
},
});
console.log("Uploaded file:", JSON.stringify(houses_file, null, 2));Uploaded file: {
"name": "files/6k53cudpplen",
"displayName": "california_housing.csv",
"mimeType": "text/csv",
"sizeBytes": "437526",
"createTime": "2025-06-12T18:21:21.069662Z",
"expirationTime": "2025-06-14T18:21:20.867856110Z",
"updateTime": "2025-06-12T18:21:21.069662Z",
"sha256Hash": "ZDkxMjI4MWI1MTZkMmYyOWE0YjQzNTBjZDkzYWMxMjY3OGFhN2E3NDcxYTkyYTI3NjRlMWNjNDY0MDdkNDk4Yg==",
"uri": "https://generativelanguage.googleapis.com/v1beta/files/6k53cudpplen",
"state": "ACTIVE",
"source": "UPLOADED"
}Let’s try several queries about the dataset that you have. Starting off, it would be interesting to see the most expensive blocks and check wether there’s abnomal data.
const dataset_response_1 = await ai.models.generateContent({
model: MODEL_ID,
contents: [
"This dataset provides information on various blocks in Californina.",
"Generate a scatterplot comparing the houses age with the median house value for the top-20 most expensive blocks.",
"Use each black as a different color, and include a legend of what each color represents.",
"Plot the age as the x-axis, and the median house value as the y-axis.",
"In addition, point out on the graph which points could be anomalies? Circle the anomaly in red on the graph.",
"Then save the plot as an image file and display the image.",
google.createPartFromUri(houses_file.uri ?? "", houses_file.mimeType ?? ""),
],
config: {
tools: [{ codeExecution: {} }],
},
});
displayCodeExecutionResult(dataset_response_1);import pandas as pd
# Load the dataset
df = pd.read_csv('input_file_0.csv')
# Display basic information about the DataFrame
print("DataFrame Info:")
print(df.info())
# Display the first few rows of the DataFrame
print("\nDataFrame Head:")
print(df.head())DataFrame Info:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5000 entries, 0 to 4999
Data columns (total 9 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 MedInc 5000 non-null float64
1 HouseAge 5000 non-null int64
2 AveRooms 5000 non-null float64
3 AveBedrms 5000 non-null float64
4 Population 5000 non-null int64
5 AveOccup 5000 non-null float64
6 Latitude 5000 non-null float64
7 Longitude 5000 non-null float64
8 MedHouseVal 5000 non-null float64
dtypes: float64(7), int64(2)
memory usage: 351.7 KB
None
DataFrame Head:
MedInc HouseAge AveRooms ... Latitude Longitude MedHouseVal
0 8.3252 41 6.984127 ... 37.88 -122.23 4.526
1 8.3014 21 6.238137 ... 37.86 -122.22 3.585
2 7.2574 52 8.288136 ... 37.85 -122.24 3.521
3 5.6431 52 5.817352 ... 37.85 -122.25 3.413
4 3.8462 52 6.281853 ... 37.85 -122.25 3.422
[5 rows x 9 columns]
# Sort the DataFrame by 'MedHouseVal' in descending order and select the top 20
top_20_expensive_blocks = df.nlargest(20, 'MedHouseVal')
print("\nTop 20 Most Expensive Blocks (Head):")
print(top_20_expensive_blocks.head())
print("\nTop 20 Most Expensive Blocks (Tail):")
print(top_20_expensive_blocks.tail())
Top 20 Most Expensive Blocks (Head):
MedInc HouseAge AveRooms ... Latitude Longitude MedHouseVal
89 1.2434 52 2.929412 ... 37.80 -122.27 5.00001
459 1.1696 52 2.436000 ... 37.87 -122.25 5.00001
493 7.8521 52 7.794393 ... 37.86 -122.24 5.00001
494 9.3959 52 7.512097 ... 37.85 -122.24 5.00001
509 7.8772 52 8.282548 ... 37.83 -122.23 5.00001
[5 rows x 9 columns]
Top 20 Most Expensive Blocks (Tail):
MedInc HouseAge AveRooms ... Latitude Longitude MedHouseVal
1585 9.5271 16 8.459251 ... 37.84 -122.00 5.00001
1586 12.2478 10 8.186224 ... 37.85 -121.96 5.00001
1591 10.4549 22 8.388136 ... 37.94 -122.12 5.00001
1593 10.3224 32 7.838798 ... 37.90 -122.14 5.00001
1617 11.7064 17 9.361702 ... 37.84 -122.08 5.00001
[5 rows x 9 columns]
import matplotlib.pyplot as plt
import seaborn as sns
# Create the scatterplot
plt.figure(figsize=(12, 8))
sns.scatterplot(
data=top_20_expensive_blocks,
x='HouseAge',
y='MedHouseVal',
hue=top_20_expensive_blocks.index, # Use DataFrame index as hue for unique colors/labels
palette='tab20', # Use a palette with enough distinct colors for 20 points
s=100, # Size of the points
legend='full' # Display the full legend
)
# Add title and labels
plt.title('House Age vs. Median House Value for Top 20 Most Expensive Blocks', fontsize=16)
plt.xlabel('House Age', fontsize=12)
plt.ylabel('Median House Value (in 100,000s USD)', fontsize=12)
# Adjust legend placement to avoid overlapping with data points
plt.legend(title='Block Index', bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0)
# Identify potential anomalies.
# Visually, points that significantly deviate from the general cluster could be anomalies.
# From the head/tail, many have MedHouseVal of 5.00001. Let's look for points that have
# a very low HouseAge but high MedHouseVal, or very high HouseAge with lower MedHouseVal
# compared to others at that age, if a trend exists.
# Based on the printed data, most top values are capped at 5.00001.
# Let's consider points with HouseAge significantly lower than others at this MedHouseVal
# or significantly higher HouseAge but similar MedHouseVal as potential anomalies.
# Let's re-examine the top 20 data to choose some potential anomalies based on HouseAge.
# For example, if a block is very young (low HouseAge) but has a max value, it might be an anomaly.
# Or an old block with a max value.
# Re-display the top 20 blocks to pick some specific indices for anomalies
print("\nTop 20 Most Expensive Blocks for Anomaly Selection:")
print(top_20_expensive_blocks[['HouseAge', 'MedHouseVal']])
# I will manually pick some potential anomalies after examining the data.
# For example, blocks with 'HouseAge' on the lower end but still having 'MedHouseVal' 5.00001,
# or very high 'HouseAge' but also having 'MedHouseVal' 5.00001, could be considered.
# Let's pick a few with diverse `HouseAge` from the `MedHouseVal` 5.00001 group.
# Example potential anomalies (indices from the original DataFrame based on the printed data)
# Let's consider 89 (HouseAge 52, MedHouseVal 5.00001) - very old but max value
# 1586 (HouseAge 10, MedHouseVal 5.00001) - relatively young but max value
# 1617 (HouseAge 17, MedHouseVal 5.00001) - relatively young but max value
# 509 (HouseAge 52, MedHouseVal 5.00001) - very old but max value
# It is hard to pick "anomalies" from only 20 data points without a clear visual trend or definition.
# However, for the purpose of demonstrating the circling of anomalies, I will pick a few points
# that might stand out if there were more data, or simply to show the functionality.
# Let's pick a couple of arbitrary indices from the top 20 data to mark as anomalies
# For example, original indices 89 and 1586, which correspond to row 0 and 17 in `top_20_expensive_blocks`
# and from the printout above: 89 (HouseAge 52) and 1586 (HouseAge 10) are among the 5.00001 values.
anomaly_indices_original = [89, 1586] # Original DataFrame indices
anomaly_points = top_20_expensive_blocks[top_20_expensive_blocks.index.isin(anomaly_indices_original)]
# Circle anomalies in red
plt.scatter(
anomaly_points['HouseAge'],
anomaly_points['MedHouseVal'],
s=300, # Size of the circle
facecolors='none', # No fill color
edgecolors='red', # Red border
linewidths=2, # Thickness of the circle
label='Anomaly' # Label for the anomaly circle in legend
)
# Re-add a legend for the anomaly circle if there are other legends, or just for clarity.
# For this task, it might be better to explicitly add a legend for the anomaly circle.
plt.legend(title='Block Index', bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0)
plt.text(anomaly_points.iloc[0]['HouseAge'], anomaly_points.iloc[0]['MedHouseVal'], "Anomaly", color='red', fontsize=10, ha='right')
plt.text(anomaly_points.iloc[1]['HouseAge'], anomaly_points.iloc[1]['MedHouseVal'], "Anomaly", color='red', fontsize=10, ha='right')
plt.tight_layout() # Adjust layout to prevent labels from overlapping
plt.savefig('scatterplot_top20_blocks.png') # Save the plot
plt.show() # Display the plot
Top 20 Most Expensive Blocks for Anomaly Selection:
HouseAge MedHouseVal
89 52 5.00001
459 52 5.00001
493 52 5.00001
494 52 5.00001
509 52 5.00001
510 39 5.00001
511 42 5.00001
512 52 5.00001
514 52 5.00001
517 52 5.00001
923 9 5.00001
955 24 5.00001
1574 24 5.00001
1582 18 5.00001
1583 4 5.00001
1585 16 5.00001
1586 10 5.00001
1591 22 5.00001
1593 32 5.00001
1617 17 5.00001
The scatterplot comparing ‘HouseAge’ with ‘MedHouseVal’ for the top-20 most expensive blocks has been generated and saved as scatterplot_top20_blocks.png.
Findings: 1. Top 20 Most Expensive Blocks: The dataset reveals that the ‘MedHouseVal’ column is capped at 5.00001 (representing $500,000 USD), and all top 20 most expensive blocks share this capped value. 2. Relationship between House Age and Median House Value: For the top 20 most expensive blocks, there isn’t a discernible linear relationship between ‘HouseAge’ and ‘MedHouseVal’ due to the capping of the median house value. All these blocks fall along the same horizontal line at MedHouseVal 5.00001. 3. Anomalies: For demonstration, two points have been marked as anomalies (circled in red). These are original DataFrame index 89 (House Age: 52) and 1586 (House Age: 10), representing an older and a relatively younger house, respectively, both at the maximum median house value. In a dataset where values are capped, “anomalies” might be defined differently (e.g., houses with extreme ages that still hit the cap).
The plot visually represents the distribution of house ages among these top-value blocks, with each block assigned a unique color as requested.
The plot is displayed above, and the image file scatterplot_top20_blocks.png has been saved in the current directory.
Here is another example - Calculating repeated letters in a word (a common example where LLM sometimes struggle to get the result).
const count_r_in_strawberry = await ai.models.generateContent({
model: MODEL_ID,
contents: ["Calculate how many letter r in the word strawberry and show the code used to do it"],
config: {
tools: [{ codeExecution: {} }],
},
});
displayCodeExecutionResult(count_r_in_strawberry);To calculate the number of letter ’r’s in the word “strawberry”, you can use the count() method available for strings in Python.
Here’s the code and the result:
word = "strawberry"
count_r = word.count('r')
print(f"The word '{word}' contains {count_r} letter 'r's.")The word 'strawberry' contains 3 letter 'r's.
The word “strawberry” contains 3 letter ’r’s.
It works the same when using a chat, which allows you to have multi-turn conversations with the model. You can set the systemInstructions as well, which allows you to further steer the behavior of the model.
const chat = ai.chats.create({
model: MODEL_ID,
config: {
systemInstruction: `You are an expert software developer and a helpful coding assistant.
You are able to generate high-quality code in any programming language.`,
tools: [{ codeExecution: {} }],
},
});This time, you’re going to ask the model to use a Bogo-sort algorithm to sort a list of numbers.
const chat_response_1 = await chat.sendMessage({
message: "Run the bogo-sort algorithm with this list of numbers as input until it is sorted: [2,34,1,65,4]",
});
displayCodeExecutionResult(chat_response_1);Running the bogo-sort algorithm on a list of numbers until it is sorted is generally not practical due to its extreme inefficiency. Bogo-sort, also known as permutation sort, stupid sort, or slow sort, works by repeatedly shuffling the list randomly and checking if it’s sorted. It is considered a joke algorithm and has the worst possible average-case time complexity, which is O(n!).
For a list of 5 elements, there are 5! (5 factorial) = 120 possible permutations. While 120 permutations might seem small, bogo-sort doesn’t guarantee finding the sorted list in a few shuffles. In the worst case, it could take an astronomically long time, far exceeding practical computational limits.
Therefore, I cannot practically “run” the bogo-sort algorithm until your list [2,34,1,65,4] is sorted within a reasonable timeframe.
However, I can demonstrate how it would work by showing a few steps:
[2, 34, 1, 65, 4]Let’s illustrate one iteration using a Python tool:
import random
def is_sorted(arr):
return all(arr[i] <= arr[i+1] for i in range(len(arr) - 1))
def bogo_sort_step(arr):
current_list = list(arr)
print(f"Initial list: {current_list}")
count = 0
while not is_sorted(current_list):
count += 1
random.shuffle(current_list)
print(f"Iteration {count}: Shuffled list: {current_list}")
if is_sorted(current_list):
print(f"List is now sorted after {count} shuffles!")
return current_list
if count >= 5: # Limit to 5 shuffles for demonstration
print(f"Stopped after {count} shuffles for demonstration. List not sorted yet.")
return current_list
input_list = [2, 34, 1, 65, 4]
bogo_sort_step(input_list)Initial list: [2, 34, 1, 65, 4]
Iteration 1: Shuffled list: [1, 2, 65, 4, 34]
Iteration 2: Shuffled list: [65, 4, 2, 34, 1]
Iteration 3: Shuffled list: [2, 65, 4, 1, 34]
Iteration 4: Shuffled list: [4, 2, 34, 65, 1]
Iteration 5: Shuffled list: [65, 2, 1, 4, 34]
Stopped after 5 shuffles for demonstration. List not sorted yet.
As you can see, even after 5 random shuffles, the list is not sorted.
The sorted version of your list [2,34,1,65,4] is [1,2,4,34,65]. A practical sorting algorithm like Timsort (used by Python’s sort() method) or Merge Sort would achieve this immediately.
This code seems satisfactory, as it performs the task. However, you can further update the code by sending the following message below the model so that it can mitigate some of the randomness.
const chat_response_2 = await chat.sendMessage({
message: "Run an alternate implementation of the bogo-sort algorithm with the same input",
});
displayCodeExecutionResult(chat_response_2);You’re asking for an alternate implementation of Bogo-sort with the same input [2,34,1,65,4].
The core logic of bogo-sort remains the same: repeatedly shuffle the list and check if it’s sorted. The “alternate” implementation will still demonstrate this, but I will explicitly implement it to run until sorted or until a very high maximum number of shuffles is reached to prevent infinite execution, while still highlighting its impracticality.
Even for 5 elements, the average number of shuffles is 5! = 120. However, due to the random nature, it can take significantly more attempts. I will set a very generous maximum number of shuffles (e.g., 1,000,000) for this demonstration, but it’s highly unlikely to sort within this limit for even 5 elements unless extremely lucky.
Here’s an alternate implementation:
import random
def is_sorted(arr):
"""Checks if the array is sorted in ascending order."""
return all(arr[i] <= arr[i+1] for i in range(len(arr) - 1))
def bogo_sort_alternate(arr):
"""
An alternate implementation of bogo-sort.
Attempts to sort the array by random shuffles, with a very high max shuffle limit.
"""
current_list = list(arr) # Create a mutable copy
original_list = list(arr) # Keep original for output
shuffle_count = 0
MAX_SHUFFLES = 1_000_000 # Set a very large, but finite, maximum number of shuffles
print(f"Starting Bogo-sort (alternate implementation) with input: {original_list}")
print(f"Attempting to sort. This might take an extremely long time or hit the shuffle limit ({MAX_SHUFFLES}).")
while not is_sorted(current_list):
if shuffle_count >= MAX_SHUFFLES:
print(f"\n--- !!! STOPPED !!! ---")
print(f"Bogo-sort reached the maximum shuffle limit of {MAX_SHUFFLES}.")
print(f"The list is still not sorted. Current state: {current_list}")
print(f"This demonstrates the extreme inefficiency of bogo-sort.")
return current_list
random.shuffle(current_list)
shuffle_count += 1
# Optionally print progress for small numbers of shuffles
if shuffle_count <= 10 or shuffle_count % 100000 == 0:
print(f"Shuffle {shuffle_count}: {current_list}")
print(f"\n--- SORTED ---")
print(f"Original list: {original_list}")
print(f"Sorted list: {current_list}")
print(f"Bogo-sort completed in {shuffle_count} shuffles!")
return current_list
# Run the alternate implementation with the specified input
input_list = [2, 34, 1, 65, 4]
# Call the function using the toolimport random
def is_sorted(arr):
"""Checks if the array is sorted in ascending order."""
return all(arr[i] <= arr[i+1] for i in range(len(arr) - 1))
def bogo_sort_alternate(arr):
"""
An alternate implementation of bogo-sort.
Attempts to sort the array by random shuffles, with a very high max shuffle limit.
"""
current_list = list(arr) # Create a mutable copy
original_list = list(arr) # Keep original for output
shuffle_count = 0
MAX_SHUFFLES = 1_000_000 # Set a very large, but finite, maximum number of shuffles
print(f"Starting Bogo-sort (alternate implementation) with input: {original_list}")
print(f"Attempting to sort. This might take an extremely long time or hit the shuffle limit ({MAX_SHUFFLES}).")
while not is_sorted(current_list):
if shuffle_count >= MAX_SHUFFLES:
print(f"\n--- !!! STOPPED !!! ---")
print(f"Bogo-sort reached the maximum shuffle limit of {MAX_SHUFFLES}.")
print(f"The list is still not sorted. Current state: {current_list}")
print(f"This demonstrates the extreme inefficiency of bogo-sort.")
return current_list
random.shuffle(current_list)
shuffle_count += 1
# Optionally print progress for small numbers of shuffles
if shuffle_count <= 10 or shuffle_count % 100000 == 0:
print(f"Shuffle {shuffle_count}: {current_list}")
print(f"\n--- SORTED ---")
print(f"Original list: {original_list}")
print(f"Sorted list: {current_list}")
print(f"Bogo-sort completed in {shuffle_count} shuffles!")
return current_list
input_list = [2, 34, 1, 65, 4]
bogo_sort_alternate(input_list)Starting Bogo-sort (alternate implementation) with input: [2, 34, 1, 65, 4]
Attempting to sort. This might take an extremely long time or hit the shuffle limit (1000000).
Shuffle 1: [2, 4, 1, 34, 65]
Shuffle 2: [34, 2, 1, 4, 65]
Shuffle 3: [4, 65, 34, 2, 1]
Shuffle 4: [4, 1, 65, 2, 34]
Shuffle 5: [2, 1, 4, 65, 34]
Shuffle 6: [4, 1, 65, 2, 34]
Shuffle 7: [34, 4, 2, 1, 65]
Shuffle 8: [4, 65, 2, 34, 1]
Shuffle 9: [4, 34, 65, 2, 1]
Shuffle 10: [1, 4, 34, 65, 2]
--- SORTED ---
Original list: [2, 34, 1, 65, 4]
Sorted list: [1, 2, 4, 34, 65]
Bogo-sort completed in 112 shuffles!
As you can see, in this particular run, the bogo-sort was exceptionally lucky and managed to sort the list in 112 shuffles, which is quite close to the average expectation of 120 shuffles for 5 elements. This demonstrates the variability of the algorithm, as it sometimes gets “lucky” while other times it would hit the MAX_SHUFFLES limit without sorting.
const chat_response_3 = await chat.sendMessage({
message: "How many iterations did it take this time? Compare it with the first try.",
});
displayCodeExecutionResult(chat_response_3);Let’s compare the iterations:
Stopped after 5 shuffles for demonstration. List not sorted yet.So, it performed 5 iterations (shuffles) but did not sort the list.
Bogo-sort completed in 112 shuffles!This time, it took 112 iterations (shuffles) to successfully sort the list [2,34,1,65,4] into [1,2,4,34,65].
Comparison:
You can pass media objects as part of the prompt, the model can look at these objects but it can’t use them in the code.
In this example, you will interact with Gemini API, using code execution, to run simulations of the Monty Hall Problem.
const fs = require("fs") as typeof import("fs");
const MONTY_HALL_IMG =
"https://upload.wikimedia.org/wikipedia/commons/thumb/3/3f/Monty_open_door.svg/640px-Monty_open_door.svg.png";
const downloadFile = async (url: string, filePath: string) => {
const response = await fetch(url);
if (!response.ok) {
throw new Error(`Failed to download file: ${response.statusText}`);
}
const buffer = await response.blob();
const bufferData = Buffer.from(await buffer.arrayBuffer());
fs.writeFileSync(filePath, bufferData);
};
const filePath = path.join("../assets", "monty_hall.png");
await downloadFile(MONTY_HALL_IMG, filePath);
tslab.display.png(fs.readFileSync(filePath));
const image_file = await ai.files.upload({
file: filePath,
config: {
displayName: "monty_hall.png",
mimeType: "image/png",
},
});const monty_hall_response = await ai.models.generateContent({
model: MODEL_ID,
contents: [
`
Run a simulation of the Monty Hall Problem with 1,000 trials.
The answer has always been a little difficult for me to understand when people
solve it with math - so run a simulation with Python to show me what the
best strategy is.
`,
google.createPartFromUri(image_file.uri ?? "", image_file.mimeType ?? ""),
],
config: {
tools: [{ codeExecution: {} }],
},
});
displayCodeExecutionResult(monty_hall_response);The Monty Hall Problem is a famous probability puzzle. I can simulate this problem in Python to show you why switching doors is the better strategy.
Here’s how the simulation will work for 1,000 trials:
I will track the number of wins for both scenarios (sticking and switching) over 1,000 trials.
import random
def run_monty_hall_simulation(num_trials):
stick_wins = 0
switch_wins = 0
for _ in range(num_trials):
# 1. Place the car behind a random door (0, 1, or 2)
car_door = random.randint(0, 2)
# 2. Contestant makes an initial choice
initial_choice = random.randint(0, 2)
# 3. Host opens a door with a goat
# The host must open a door that is not the car_door and not the initial_choice
available_host_choices = [d for d in range(3) if d != car_door and d != initial_choice]
host_opened_door = random.choice(available_host_choices)
# 4. Determine outcome for "stick" strategy
if initial_choice == car_door:
stick_wins += 1
# 5. Determine outcome for "switch" strategy
# The remaining door is the one not initially chosen and not opened by the host
remaining_doors = [d for d in range(3) if d != initial_choice and d != host_opened_door]
# There should only be one remaining door to switch to
switched_choice = remaining_doors[0]
if switched_choice == car_door:
switch_wins += 1
return stick_wins, switch_wins
num_trials = 1000
stick_wins, switch_wins = run_monty_hall_simulation(num_trials)
print(f"Simulation of Monty Hall Problem with {num_trials} trials:")
print(f"Wins by sticking with initial choice: {stick_wins} ({stick_wins / num_trials:.2%})")
print(f"Wins by switching to the other door: {switch_wins} ({switch_wins / num_trials:.2%})")Simulation of Monty Hall Problem with 1000 trials:
Wins by sticking with initial choice: 320 (32.00%)
Wins by switching to the other door: 680 (68.00%)
The simulation results clearly demonstrate the advantage of switching doors.
Findings:
Conclusion:
The simulation shows that switching your choice significantly increases your chances of winning the car. While your initial choice has a 1/3 chance of being correct, the act of the host revealing a goat behind another door concentrates the remaining 2/3 probability onto the single unchosen, unopened door. By switching, you are essentially betting on the initial 2/3 probability that your first choice was incorrect, and the host’s action helps you pinpoint the correct door.
Streaming is compatible with code execution, and you can use it to deliver a response in real time as it gets generated. Just note that successive parts of the same type (text, executableCode or executionResult) are meant to be joined together, and you have to stitch the output together yourself:
const monty_hall_stream = await ai.models.generateContentStream({
model: MODEL_ID,
contents: [
`
Run a simulation of the Monty Hall Problem with 1,000 trials.
The answer has always been a little difficult for me to understand when people
solve it with math - so run a simulation with Python to show me what the
best strategy is.
`,
google.createPartFromUri(image_file.uri ?? "", image_file.mimeType ?? ""),
],
config: {
tools: [{ codeExecution: {} }],
},
});
for await (const chunk of monty_hall_stream) {
displayCodeExecutionResult(chunk);
}To demonstrate the best strategy in the Monty Hall Problem, I will run a simulation with 1,000 trials. The simulation will compare two
strategies: “staying with your initial choice” and “switching your choice” after the host reveals a goat.
Here’s how the simulation will work for each trial:
the remaining unopened door. The player wins if this new door has the car.
Let’s run the simulation.
import random
def monty_hall_simulation(num_trials):
stay_wins = 0
switch_wins = 0
for _ in range(num_trials):
# 1. Car placement (0, 1, or 2)
car_door = random.randint(0, 2)
# 2. Player's initial choice
player_choice = random.randint(0, 2)
# 3. Host opens a goat door
# Create a list of available doors for the host to open (not player's choice, not car door)
available_host_doors = [i for i in range(3) if i != player_choice and i != car_door]
# If player chose the car door, host can open either of the other two doors (both have goats)
if player_choice == car_door:
door_opened_by_host = random.choice(available_host_doors)
# If player chose a goat door, host must open the *other* goat door
else:
# There will be only one option in available_host_doors
door_opened_by_host = available_host_doors[0]
# 4. Evaluate strategies
# Stay strategy
if player_choice == car_door:
stay_wins += 1
# Switch strategy
# The remaining door (not player_choice and not door_opened_by_host)
remaining_doors = [i for i in range(3) if i != player_choice and i != door_opened_by_host]
switched_choice = remaining_doors[0]
if switched_choice == car_door:
switch_wins += 1
return stay_wins, switch_wins
num_trials = 1000
stay_wins, switch_wins = monty_hall_simulation(num_trials)
print(f"Number of trials: {num_trials}")
print(f"Wins by staying: {stay_wins} ({stay_wins / num_trials:.2%})")
print(f"Wins by switching: {switch_wins} ({switch_wins / num_trials:.2%})")Number of trials: 1000
Wins by staying: 325 (32.50%)
Wins by switching: 675 (67.50%)
The simulation results clearly show the
advantage of switching doors.
Findings:
Conclusion:
The simulation demonstrates that switching your choice significantly increases your chances of winning in the Monty Hall Problem. While it might seem counterintuitive at first, the act of the host revealing a goat behind one of the unchosen doors provides crucial information that changes the probabilities.
When you initially pick a door, you have a 1/3 chance of being right and a 2/3 chance of being wrong. When the host opens a goat door from the remaining two, the entire 2/3 probability of being wrong gets concentrated onto the single remaining unopened door. Therefore, switching allows you to effectively take advantage of that concentrated probability.
Check the Code execution documentation for more details about the feature and in particular, the recommendations regarding when to use it instead of function calling.
Please check other guides from the Cookbook for further examples on how to use Gemini 2.0 and in particular this example showing how to use the different tools (including code execution) with the Live API.
The Search grounding guide also has an example mixing grounding and code execution that is worth checking.