chapter-4/chapter-4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f36f08d2-8518-47e5-9944-0fdaa73e246c",
   "metadata": {},
   "source": [
    "# Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up and spin up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "721661a2-3c5d-4172-a88e-3c2136a9933d",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c8d72c-b011-4360-b368-d540b8d7361a",
   "metadata": {},
   "source": [
    "## Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38339871-7f3d-49d8-9b4f-e77f9e2a88da",
   "metadata": {},
   "source": [
    "### Creating Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c03bfa03-ee78-4267-8d9b-582b98865f88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let days = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"];\n",
    "days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "21af2e95-fe3e-4c88-989d-4ba92ac5b22e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a: [i32; 5] = [1, 2, 3, 4, 5];\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a938a11-c989-4556-ace8-a13a6cbcdb42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let zeros = [0; 5];\n",
    "zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ee276a9-c379-429a-a74d-4d836c693fc5",
   "metadata": {},
   "source": [
    "### Accessing Array Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f1d581b0-8e46-4140-b6e7-474e7cb0cb73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "numbers[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c249b08-e7b8-4827-9952-c9b9a1048f66",
   "metadata": {},
   "source": [
    "### Modifying Array Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f2603982-adb7-4a18-90a0-85c59c3abc3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 3, 4, 5]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut numbers = [1, 2, 3, 4, 5];\n",
    "numbers[1] = 10;\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba4dbcec-92f0-4fbf-85a3-e74d0d66b424",
   "metadata": {},
   "source": [
    "### Iterating Through Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8b0ef968-657a-4362-bf8b-b5094306a085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let seasons = [\"Winter\", \"Spring\", \"Summer\", \"Fall\"];\n",
    "\n",
    "// Using a for-in loop\n",
    "for season in seasons {\n",
    "    println!(\"{season}\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0810da26-8a43-430e-a680-05a1089b07c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// Using a for loop with an index\n",
    "for index in 0..seasons.len() {\n",
    "    println!(\"{}\", seasons[index]);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fc65b806-eb79-4b59-8597-32952b7858bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// Using a for loop with an iterator\n",
    "for season in seasons.iter() {\n",
    "    println!(\"{}\", season);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48c89816-170c-4217-8524-d4cd209a535e",
   "metadata": {},
   "source": [
    "### Slicing Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "44c76084-a061-4cb2-8a25-caf34a77a7bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "{\n",
    "    let slice = &numbers[1..4];\n",
    "    println!(\"{:?}\", slice);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1be15e8-2332-4c13-9ac3-a23c81d50c27",
   "metadata": {},
   "source": [
    "### Multi-dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c55d0397-151c-4073-b2d6-4a967a526b6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial Tic-Tac-Toe Board:\n",
      "  X O \n",
      "O X   \n",
      "X   O \n",
      "Updated Tic-Tac-Toe Board:\n",
      "  X O \n",
      "O X X \n",
      "X O O \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    // Define a 2D array for a tic-tac-toe board\n",
    "    let mut tic_tac_toe: [[char; 3]; 3] = [\n",
    "        [' ', 'X', 'O'],\n",
    "        ['O', 'X', ' '],\n",
    "        ['X', ' ', 'O']\n",
    "    ];\n",
    "\n",
    "    // Display the initial tic-tac-toe board\n",
    "    println!(\"Initial Tic-Tac-Toe Board:\");\n",
    "    print_tic_tac_toe(&tic_tac_toe);\n",
    "\n",
    "    // Update the board and display it again\n",
    "    tic_tac_toe[1][2] = 'X';\n",
    "    tic_tac_toe[2][1] = 'O';\n",
    "\n",
    "    println!(\"Updated Tic-Tac-Toe Board:\");\n",
    "    print_tic_tac_toe(&tic_tac_toe);\n",
    "}\n",
    "\n",
    "// Function to print the tic-tac-toe board\n",
    "fn print_tic_tac_toe(board: &[[char; 3]; 3]) {\n",
    "    for row in board.iter() {\n",
    "        for cell in row.iter() {\n",
    "            print!(\"{} \", cell);\n",
    "        }\n",
    "        println!();\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "990062e2-a934-4776-b582-5c32845d718b",
   "metadata": {},
   "source": [
    "### Working with Array Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "04a4302a-3bf1-4a0c-9b80-8e0402522948",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut numbers = [1, 2, 3, 4, 5];\n",
    "for num in numbers.iter_mut() {\n",
    "    *num *= 2;\n",
    "}\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0ac7e346-e8c2-4d1c-a030-f8ad0792c6b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 7, 9]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut unsorted = [4, 1, 7, 3, 9];\n",
    "unsorted.sort();\n",
    "unsorted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90eaaae1-1b18-4c00-9ebf-425093bf9387",
   "metadata": {},
   "source": [
    "### Array Initialization and Default Values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fdd3d56-b398-43f3-9a15-f33c4374e050",
   "metadata": {},
   "source": [
    "### Initializing with Default Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c8bb4de5-955b-4d45-b152-9785956af0cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let default_values = [0; 10];\n",
    "default_values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb10bda8-4d7e-40fb-9793-8fa41dcc8946",
   "metadata": {},
   "source": [
    "### Generating Patterns with Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1566b9f5-7498-4bff-995e-ae19373bb729",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let original = [1, 2, 3, 4, 5];\n",
    "let mut squared: [i32; 5] = [0; 5]; // Initialize an array of size 5 with zeros\n",
    "\n",
    "let _ = original\n",
    "    .iter()\n",
    "    .enumerate()\n",
    "    .map(|(index, &value)| squared[index] = value * value)\n",
    "    .collect::<Vec<_>>(); // This line is needed but doesn't change the result\n",
    "\n",
    "squared    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f812231-8ad5-4568-ac47-07c04298d820",
   "metadata": {},
   "source": [
    "### Initializing with Computed Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f7f6af1d-acbe-4359-9ef3-6b66c21ff698",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut factorials = [1; 10];\n",
    "\n",
    "for i in 1..10 {\n",
    "    factorials[i] = factorials[i - 1] * (i as i32);\n",
    "}\n",
    "\n",
    "factorials"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "138fe790-46d0-4283-ac70-2c9995ac30bf",
   "metadata": {},
   "source": [
    "### Array Length and Bounds Checking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c5f5e65-407f-4aa9-bb8b-ee92f28d930b",
   "metadata": {},
   "source": [
    "### Obtaining the Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "270d125e-8040-47d5-bece-4419f9756f23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "let length = numbers.len();\n",
    "length"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e9c1838-aad0-4549-b756-353eddb3dd5e",
   "metadata": {},
   "source": [
    "### Bounds Checking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7008ed83-17ff-49da-8b2f-caafc2a110e5",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "this operation will panic at runtime",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[unconditional_panic] Error:\u001b[0m this operation will panic at runtime",
      "   \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_18:1:1\u001b[38;5;246m]\u001b[0m",
      "   \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m3 │\u001b[0m \u001b[38;5;249ml\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249mv\u001b[0m\u001b[38;5;249ma\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249mu\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m=\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;54mn\u001b[0m\u001b[38;5;54mu\u001b[0m\u001b[38;5;54mm\u001b[0m\u001b[38;5;54mb\u001b[0m\u001b[38;5;54me\u001b[0m\u001b[38;5;54mr\u001b[0m\u001b[38;5;54ms\u001b[0m\u001b[38;5;54m[\u001b[0m\u001b[38;5;54mi\u001b[0m\u001b[38;5;54mn\u001b[0m\u001b[38;5;54md\u001b[0m\u001b[38;5;54me\u001b[0m\u001b[38;5;54mx\u001b[0m\u001b[38;5;54m]\u001b[0m\u001b[38;5;249m;\u001b[0m",
      " \u001b[38;5;240m  │\u001b[0m             \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m  ",
      " \u001b[38;5;240m  │\u001b[0m                    \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m index out of bounds: the length is 5 but the index is 10",
      "\u001b[38;5;246m───╯\u001b[0m"
     ]
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "let index = 10;\n",
    "let value = numbers[index];\n",
    "value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bc0873b-a831-4eab-863e-0f7a87a13b60",
   "metadata": {},
   "source": [
    "###  Array Copy and Clone"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b5b4e3-c4e2-4455-8360-ab783eb4d204",
   "metadata": {},
   "source": [
    "### Copying Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cbe7b67f-c4d0-488a-af82-0b91b34c5661",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let original = [1, 2, 3];\n",
    "let copied = original;\n",
    "copied"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daa75af8-2f0b-45f5-aa3b-b6fc8c400103",
   "metadata": {},
   "source": [
    "### Cloning Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "16dc2164-29d9-49a6-9c9b-b907f62be6e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"one\", \"two\", \"three\"]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let original = [\"one\", \"two\", \"three\"];\n",
    "let cloned = original.to_owned();\n",
    "cloned"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "746968df-697c-47a2-a01d-3b71b98f528b",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d832f0ad-f0d7-42bb-b96e-2d4fd66ef135",
   "metadata": {},
   "source": [
    "## Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af9aff09-e0cc-4c0b-b0a3-32b6d69bfb0f",
   "metadata": {},
   "source": [
    "### Creating Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "75833ede-8e81-4ec6-ba7c-2325f2b3260c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let v: Vec<i32> = Vec::new();\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ea1e7251-32c0-484f-8851-0aaf3d8ac5ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d572be81-6780-407a-ae7b-c4e40e722ca5",
   "metadata": {},
   "source": [
    "### Accessing and Modifying Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6f255b85-9547-40b4-95e4-f83e57a4783b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The second element is banana\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\n",
    "    let fruits = vec![\"apple\", \"banana\", \"cherry\", \"date\"];\n",
    "\n",
    "    // Accessing the second element using indexing\n",
    "    let second = &fruits[1];\n",
    "    println!(\"The second element is {}\", second)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "711caed5-af2e-4d04-8274-8671073cd80e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The second element is banana\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\n",
    "    let fruits = vec![\"apple\", \"banana\", \"cherry\", \"date\"];\n",
    "\n",
    "    // Safely accessing the second element using get\n",
    "    let second = fruits.get(1);\n",
    "    match second {\n",
    "        Some(fruit) => println!(\"The second element is {}\", fruit),\n",
    "        None => println!(\"Element not found\"),\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7839fe7c-3f13-4c1b-843c-34a9c41425ee",
   "metadata": {},
   "source": [
    "### Modifying Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f087ca8e-6001-449c-8245-aa8bb337ffd7",
   "metadata": {},
   "source": [
    "### Adding Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d90ec402-f713-4a70-bcd9-7fbf3c73dff7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"apple\", \"banana\", \"cherry\"]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut fruits = vec![\"apple\", \"banana\"];\n",
    "\n",
    "// Adding \"cherry\" to the end of the vector\n",
    "fruits.push(\"cherry\");\n",
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58720c81-3887-4ba5-971b-c7cccba67a83",
   "metadata": {},
   "source": [
    "### Updating Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bbabff4a-8386-4be5-a052-3721224d563e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"apple\", \"pear\"]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut fruits = vec![\"apple\", \"banana\"];\n",
    "\n",
    "// Updating the second element to \"pear\"\n",
    "fruits[1] = \"pear\";\n",
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469e97b4-baa8-429c-8fbd-1279a2ed6a52",
   "metadata": {},
   "source": [
    "### Removing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1a867bbd-4dcb-49fb-9307-cdff2a5e125b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Some(\"cherry\")"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut fruits = vec![\"apple\", \"banana\", \"cherry\"];\n",
    "\n",
    "// Removing and storing the last element\n",
    "let removed_fruit = fruits.pop();\n",
    "removed_fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c7135c0d-66b3-4ec4-988a-892f0e8d5120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"banana\""
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut fruits = vec![\"apple\", \"banana\", \"cherry\"];\n",
    "\n",
    "// Removing the element at index 1 (\"banana\")\n",
    "let removed_fruit = fruits.remove(1);\n",
    "removed_fruit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74c37390-1fb6-4679-9b96-315be9fc0650",
   "metadata": {},
   "source": [
    "### Iterating over Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b674e1b-1576-4153-9611-e14575ae8117",
   "metadata": {},
   "source": [
    "### Using a `for` Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "889085cd-dde4-40c4-9ec6-934a82680785",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = vec![1, 2, 3, 4, 5];\n",
    "for number in &numbers {\n",
    "    println!(\"{}\", number);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61eefc44-a190-410f-8936-c52fbbe3068d",
   "metadata": {},
   "source": [
    "### Using `iter_mut` for Mutable Iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a29bea5f-c2c0-41e7-a61c-a2de290b98ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15, 16]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut numbers = vec![10, 11, 12, 13, 14, 15];\n",
    "for number in numbers.iter_mut() {\n",
    "    *number += 1; // Add 1 to each element\n",
    "}\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24e2704f-c3fa-4da4-9193-6d4a62ccfab7",
   "metadata": {},
   "source": [
    "### Using `enumerate` for Index and Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c1c69d9f-1d4e-450e-8ba6-7508d02194b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0: apple\n",
      "Index 1: banana\n",
      "Index 2: cherry\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let fruits = vec![\"apple\", \"banana\", \"cherry\"];\n",
    "for (index, fruit) in fruits.iter().enumerate() {\n",
    "    println!(\"Index {}: {}\", index, fruit);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a66963-dcfe-4506-a4bb-658d2cb54bc8",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a12c4670-b687-40f4-999b-e4a42884d2b5",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d35d827-9da4-4dd8-860b-bb163ceb4ea9",
   "metadata": {},
   "source": [
    "### Creating and Initializing Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "8796d201-9b01-4e6f-a757-0b83d9a57d73",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Creating and initializing a tuple\n",
    "let person = (\"Mahmoud\", 25, true);\n",
    "\n",
    "// Creating an empty tuple (unit tuple)\n",
    "let empty: () = ();\n",
    "\n",
    "// Type annotation for an empty tuple\n",
    "let another_empty: () = ();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36ea9872-94d6-472d-8f5e-a8360d701f56",
   "metadata": {},
   "source": [
    "### Accessing Tuple Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "51ca7fcf-115b-4cd5-b704-354e8641d1af",
   "metadata": {},
   "outputs": [],
   "source": [
    "let person = (\"Mahmoud\", 25, true);\n",
    "\n",
    "// Accessing the first element of the tuple\n",
    "let name = person.0;\n",
    "\n",
    "// Accessing the second element\n",
    "let age = person.1;\n",
    "\n",
    "// Accessing the third element\n",
    "let employed = person.2;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce815e85-66fa-4b45-ab65-58a08b8cb95a",
   "metadata": {},
   "source": [
    "### Destructuring Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "361f2b9f-bc79-4abe-8f04-1bff4c8aaae7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud is 25 years old and employed.\n"
     ]
    }
   ],
   "source": [
    "let person = (\"Mahmoud\", 25, true);\n",
    "\n",
    "// Destructuring the tuple into variables\n",
    "let (name, age, employed) = person;\n",
    "println!(\"{} is {} years old and employed.\", name, age);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66245d23-cae6-46c1-8e75-7b8fed535a8f",
   "metadata": {},
   "source": [
    "### Tuple Patterns and Advanced Usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a1c220b2-50a6-447a-9e5d-3abc5d4f235d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud is 25 years old and employed.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let person = (\"Mahmoud\", 25, true);\n",
    "\n",
    "// Using a tuple pattern to match and destructure\n",
    "match person {\n",
    "    (name, age, true) => println!(\"{} is {} years old and employed.\", name, age),\n",
    "    (name, age, false) => println!(\"{} is {} years old and not employed.\", name, age),\n",
    "    _ => println!(\"Unknown employment status.\"),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58b3075-a372-460a-86df-c146723a5ffe",
   "metadata": {},
   "source": [
    "### Real-World Use Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d8b4fcbe-9ca6-4a74-80fd-c27a9b383df6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance from the origin: 5\n"
     ]
    }
   ],
   "source": [
    "let point: (f64, f64) = (3.0, 4.0);\n",
    "\n",
    "// Calculate distance from the origin\n",
    "let distance = (point.0.powi(2) + point.1.powi(2)).sqrt();\n",
    "println!(\"Distance from the origin: {}\", distance);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e86147b-5a60-4c0b-af0e-92141cda6236",
   "metadata": {},
   "source": [
    "### Error Handling with Result Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d2a7acc8-dd5d-4c44-92e4-832922d19c95",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Err(\"Division by zero\")"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn divide_with_remainder(dividend: i32, divisor: i32) -> Result<(i32, i32), String> {\n",
    "    if divisor == 0 {\n",
    "        return Err(\"Division by zero\".to_string());\n",
    "    }\n",
    "\n",
    "    let quotient = dividend / divisor;\n",
    "    let remainder = dividend % divisor;\n",
    "\n",
    "    Ok((quotient, remainder))\n",
    "}\n",
    "\n",
    "divide_with_remainder(32, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a90fbafa-de1f-4ea2-b506-af93479a936b",
   "metadata": {},
   "source": [
    "### Tuples in Pattern Matching"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4910081c-be03-415d-9fa9-f58096d6add0",
   "metadata": {},
   "source": [
    "### Matching Tuples with Patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1bee9626-b1ad-468a-b7d7-2a53001ef747",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The point is at coordinates (3, 4).\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let coordinates = (3, 4);\n",
    "\n",
    "match coordinates {\n",
    "    (0, 0) => println!(\"The point is at the origin.\"),\n",
    "    (x, 0) => println!(\"The point is on the x-axis at x = {}.\", x),\n",
    "    (0, y) => println!(\"The point is on the y-axis at y = {}.\", y),\n",
    "    (x, y) => println!(\"The point is at coordinates ({}, {}).\", x, y),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7057b48-da7c-4e2b-b793-0df002a8ed36",
   "metadata": {},
   "source": [
    "### Ignoring Tuple Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5fc55e38-d986-4b39-8c00-88f477323b4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud is a student majoring in Computer Science.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let student = (\"Mahmoud\", 25, \"Computer Science\");\n",
    "\n",
    "match student {\n",
    "    (name, _, major) => println!(\"{} is a student majoring in {}.\", name, major),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa9335a0-a5f4-446f-a7da-0ef39dc73a54",
   "metadata": {},
   "source": [
    "### Nested Tuples and Patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3a07c495-9157-402f-b85b-2a872de8ed35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Mahmoud Harmouch\n",
      "Age: 25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let person = ((\"Mahmoud\", \"Harmouch\"), 25);\n",
    "\n",
    "match person {\n",
    "    ((first_name, last_name), age) => {\n",
    "        println!(\"Name: {} {}\", first_name, last_name);\n",
    "        println!(\"Age: {}\", age);\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e81cedf-48de-457b-92ce-be59824ee414",
   "metadata": {},
   "source": [
    "### Tuple Ownership and Borrowing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5b0a50e-0caa-49c2-b309-076fe6f12440",
   "metadata": {},
   "source": [
    "### Tuple Ownership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "948d9f4f-9c26-469e-94bc-aacb3b68923a",
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "borrow of moved value: `original_tuple`",
     "output_type": "error",
     "traceback": [
      "\u001b[31m[E0382] Error:\u001b[0m borrow of moved value: `original_tuple`",
      "   \u001b[38;5;246m╭\u001b[0m\u001b[38;5;246m─\u001b[0m\u001b[38;5;246m[\u001b[0mcommand_41:1:1\u001b[38;5;246m]\u001b[0m",
      "   \u001b[38;5;246m│\u001b[0m",
      " \u001b[38;5;246m1 │\u001b[0m \u001b[38;5;249ml\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;100mo\u001b[0m\u001b[38;5;100mr\u001b[0m\u001b[38;5;100mi\u001b[0m\u001b[38;5;100mg\u001b[0m\u001b[38;5;100mi\u001b[0m\u001b[38;5;100mn\u001b[0m\u001b[38;5;100ma\u001b[0m\u001b[38;5;100ml\u001b[0m\u001b[38;5;100m_\u001b[0m\u001b[38;5;100mt\u001b[0m\u001b[38;5;100mu\u001b[0m\u001b[38;5;100mp\u001b[0m\u001b[38;5;100ml\u001b[0m\u001b[38;5;100me\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m=\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249mS\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249mg\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249mf\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249mm\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249mH\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249m)\u001b[0m\u001b[38;5;249m,\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249mS\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249mi\u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249mg\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249m:\u001b[0m\u001b[38;5;249mf\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249mm\u001b[0m\u001b[38;5;249m(\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249mW\u001b[0m\u001b[38;5;249mo\u001b[0m\u001b[38;5;249mr\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249md\u001b[0m\u001b[38;5;249m\"\u001b[0m\u001b[38;5;249m)\u001b[0m\u001b[38;5;249m)\u001b[0m\u001b[38;5;249m;\u001b[0m",
      " \u001b[38;5;240m  │\u001b[0m     \u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m┬\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m  ",
      " \u001b[38;5;240m  │\u001b[0m            \u001b[38;5;100m╰\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m\u001b[38;5;100m─\u001b[0m move occurs because `original_tuple` has type `(String, String)`, which does not implement the `Copy` trait",
      " \u001b[38;5;246m2 │\u001b[0m \u001b[38;5;249ml\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249mn\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249mw\u001b[0m\u001b[38;5;249m_\u001b[0m\u001b[38;5;249mt\u001b[0m\u001b[38;5;249mu\u001b[0m\u001b[38;5;249mp\u001b[0m\u001b[38;5;249ml\u001b[0m\u001b[38;5;249me\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;249m=\u001b[0m\u001b[38;5;249m \u001b[0m\u001b[38;5;54mo\u001b[0m\u001b[38;5;54mr\u001b[0m\u001b[38;5;54mi\u001b[0m\u001b[38;5;54mg\u001b[0m\u001b[38;5;54mi\u001b[0m\u001b[38;5;54mn\u001b[0m\u001b[38;5;54ma\u001b[0m\u001b[38;5;54ml\u001b[0m\u001b[38;5;54m_\u001b[0m\u001b[38;5;54mt\u001b[0m\u001b[38;5;54mu\u001b[0m\u001b[38;5;54mp\u001b[0m\u001b[38;5;54ml\u001b[0m\u001b[38;5;54me\u001b[0m\u001b[38;5;249m;\u001b[0m",
      " \u001b[38;5;240m  │\u001b[0m                 \u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m┬\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;68m│\u001b[0m ",
      " \u001b[38;5;240m  │\u001b[0m                        \u001b[38;5;54m╰\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m\u001b[38;5;54m─\u001b[0m value moved here",
      " \u001b[38;5;240m  │\u001b[0m                               \u001b[38;5;68m│\u001b[0m ",
      " \u001b[38;5;240m  │\u001b[0m                               \u001b[38;5;68m╰\u001b[0m\u001b[38;5;68m─\u001b[0m help: consider cloning the value if the performance cost is acceptable: `.clone()`",
      "\u001b[38;5;246m───╯\u001b[0m"
     ]
    }
   ],
   "source": [
    "let original_tuple = (String::from(\"Hello\"), String::from(\"World\"));\n",
    "let new_tuple = original_tuple;\n",
    "\n",
    "// Attempting to use the original tuple causes a compilation error\n",
    "original_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f16220eb-fdfd-4df2-bdb9-ee091891d9c7",
   "metadata": {},
   "source": [
    "### Borrowing Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7954ae8f-2490-4502-9da6-b0d213e47808",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coordinates: (5, 7)\n",
      "Point coordinates: (5, 7)\n"
     ]
    }
   ],
   "source": [
    "fn print_coordinates(coordinates: &(i32, i32)) {\n",
    "    println!(\"Coordinates: {:?}\", coordinates);\n",
    "}\n",
    "\n",
    "let point = (5, 7);\n",
    "\n",
    "// Borrowing a reference to the point tuple\n",
    "print_coordinates(&point);\n",
    "\n",
    "// Point tuple remains usable\n",
    "println!(\"Point coordinates: {:?}\", point);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f04cde6-e6f9-4644-b07c-063a02bc6760",
   "metadata": {},
   "source": [
    "### Tuple Slicing and the Spread Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db90fc09-e541-4610-a604-dbb25dcec0ef",
   "metadata": {},
   "source": [
    "### Creating Tuple Slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "7959d1da-faa3-4e98-838b-a0000ed4fa8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2..5"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = (1, 2, 3, 4, 5);\n",
    "\n",
    "// Creating a tuple slice with elements 2, 3, and 4\n",
    "let slice = numbers.1..numbers.4;\n",
    "\n",
    "slice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee7c980-1cbf-4e98-9494-89c340d0ef0e",
   "metadata": {},
   "source": [
    "### Accessing Tuple Slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c9e51e14-05c6-4623-b0a7-2cc43c6e1e7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Element: 2\n",
      "Last Element: 5\n"
     ]
    }
   ],
   "source": [
    "let numbers = (1, 2, 3, 4, 5);\n",
    "\n",
    "// Creating a tuple slice with elements 2, 3, and 4\n",
    "let slice = numbers.1..numbers.4;\n",
    "\n",
    "// Accessing elements of the tuple slice\n",
    "let first_element = slice.start;\n",
    "let last_element = slice.end;\n",
    "\n",
    "println!(\"First Element: {}\", first_element);\n",
    "println!(\"Last Element: {}\", last_element);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e5be269-46e3-4f83-9bdf-c65c6b8ae66d",
   "metadata": {},
   "source": [
    "### Tuple as Function Arguments and Return Values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92599aa8-e575-4621-aa1e-1bce27d6654b",
   "metadata": {},
   "source": [
    "### Using Tuples as Function Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "87c1c49a-2b90-457a-bb6a-91ddfe583d29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Mahmoud\n",
      "Age: 25\n",
      "Occupation: Software Engineer\n"
     ]
    }
   ],
   "source": [
    "fn print_person_info(person: (&str, i32, &str)) {\n",
    "    let (name, age, occupation) = person;\n",
    "    println!(\"Name: {}\", name);\n",
    "    println!(\"Age: {}\", age);\n",
    "    println!(\"Occupation: {}\", occupation);\n",
    "}\n",
    "\n",
    "let alice_info = (\"Mahmoud\", 25, \"Software Engineer\");\n",
    "\n",
    "// Calling the function with a tuple argument\n",
    "print_person_info(alice_info);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ae74d2-363a-4f2c-846e-d31e9fc487b2",
   "metadata": {},
   "source": [
    "### Returning Tuples from Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7c7dfccf-6aa5-4144-be76-5c62637d22d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Mahmoud\n",
      "Age: 25\n",
      "Occupation: Software Engineer\n"
     ]
    }
   ],
   "source": [
    "fn get_person_info(id: u32) -> (&'static str, i32, &'static str) {\n",
    "    match id {\n",
    "        1 => (\"Mahmoud\", 25, \"Software Engineer\"),\n",
    "        2 => (\"Prime\", 36, \"Netflix Bro\"),\n",
    "        _ => (\"Unknown\", 0, \"N/A\"),\n",
    "    }\n",
    "}\n",
    "\n",
    "let alice = get_person_info(1);\n",
    "\n",
    "println!(\"Name: {}\", alice.0);\n",
    "println!(\"Age: {}\", alice.1);\n",
    "println!(\"Occupation: {}\", alice.2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f55ced-4b5d-4878-b329-00a3ac95dec3",
   "metadata": {},
   "source": [
    "### Tuple Variants in Enums"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ae0fbbc-1f62-4000-ba91-209aa4295b10",
   "metadata": {},
   "source": [
    "### Creating Enum Variants with Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "35d318c5-70e0-4216-b977-bcf3fd46aebf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle with radius: 5\n",
      "Rectangle with length 4 and width 6\n",
      "Triangle with sides 3, 4, and 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enum Shape {\n",
    "    Circle(f64),\n",
    "    Rectangle(f64, f64),\n",
    "    Triangle(f64, f64, f64),\n",
    "}\n",
    "\n",
    "let circle = Shape::Circle(5.0);\n",
    "let rectangle = Shape::Rectangle(4.0, 6.0);\n",
    "let triangle = Shape::Triangle(3.0, 4.0, 5.0);\n",
    "\n",
    "// Pattern matching to extract values from enum variants\n",
    "match circle {\n",
    "    Shape::Circle(radius) => println!(\"Circle with radius: {}\", radius),\n",
    "    _ => (),\n",
    "}\n",
    "\n",
    "match rectangle {\n",
    "    Shape::Rectangle(length, width) => println!(\"Rectangle with length {} and width {}\", length, width),\n",
    "    _ => (),\n",
    "}\n",
    "\n",
    "match triangle {\n",
    "    Shape::Triangle(a, b, c) => println!(\"Triangle with sides {}, {}, and {}\", a, b, c),\n",
    "    _ => (),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf2c4a26-6268-48f9-b848-8120d1df894a",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee14f56-427d-4eeb-b812-b38dd2e2d75b",
   "metadata": {},
   "source": [
    "## Slices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa8e4b23-0272-4a0d-ad6c-59c37664fc14",
   "metadata": {},
   "source": [
    "### Creating Slices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f07ab8f-afee-4ccb-a3e9-73d551eee5de",
   "metadata": {},
   "source": [
    "### Creating a slice from an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "1eaa027b-b0c6-454c-95b0-0bbd75c44d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slice array: [2, 3, 4]\n",
      "Slice vector: [2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"Hello\""
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\n",
    "    // Creating a slice from an array\n",
    "    let arr: [i32; 5] = [1, 2, 3, 4, 5];\n",
    "    let slice_arr: &[i32] = &arr[1..4];\n",
    "    println!(\"Slice array: {:?}\", slice_arr);\n",
    "    \n",
    "    // Creating a slice from a vector\n",
    "    let vec = vec![1, 2, 3, 4, 5];\n",
    "    let slice_vec: &[i32] = &vec[1..4];\n",
    "    println!(\"Slice vector: {:?}\", slice_arr);\n",
    "}\n",
    "// Creating a slice from a string\n",
    "let text: &str = \"Hello, Rust!\";\n",
    "let slice_text: &str = &text[0..5];\n",
    "slice_text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73461645-2616-4db8-8eaf-c5b23363075e",
   "metadata": {},
   "source": [
    "### Accessing Slice Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "005dbbae-2682-4277-aa8d-21c3678c6221",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element: 20\n",
      "Element: 30\n",
      "Element: 40\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let data: [i32; 5] = [10, 20, 30, 40, 50];\n",
    "    let slice: &[i32] = &data[1..4];\n",
    "\n",
    "    // Accessing elements by index\n",
    "    let second_element = slice[0];\n",
    "    let third_element = slice[1];\n",
    "    let fourth_element = slice[2];\n",
    "\n",
    "    // Iterating through the slice\n",
    "    for element in slice.iter() {\n",
    "        println!(\"Element: {}\", element);\n",
    "    }\n",
    "}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a50f769b-360f-442f-97c5-196c0a92f7fa",
   "metadata": {},
   "source": [
    "### Modifying Slice Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "fb52ecfd-a65c-4462-9bf2-133b280292a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Vector:\n",
      "10\n",
      "99\n",
      "30\n",
      "40\n",
      "50\n",
      "Slice:\n",
      "99\n",
      "30\n",
      "40\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn modify_data(data: &mut Vec<i32>) {\n",
    "    let slice = &mut data[1..4];\n",
    "    // Modifying elements\n",
    "    slice[0] = 99;\n",
    "\n",
    "    // Simulating adding elements\n",
    "    let new_elements = [60];\n",
    "    data.insert(4, new_elements[0]);\n",
    "\n",
    "    // Simulating removing elements\n",
    "    let _removed_element = data.remove(4);\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut data: Vec<i32> = vec![10, 20, 30, 40, 50];\n",
    "    modify_data(&mut data);\n",
    "\n",
    "    // Print the data vector\n",
    "    println!(\"Data Vector:\");\n",
    "    for element in &data {\n",
    "        println!(\"{}\", element);\n",
    "    }\n",
    "\n",
    "    // Print the slice\n",
    "    let slice = &mut data[1..4];\n",
    "    println!(\"Slice:\");\n",
    "    for element in slice.iter() {\n",
    "        println!(\"{}\", element);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60db0ca9-88da-40f3-bb0f-fdb8c2a12948",
   "metadata": {},
   "source": [
    "### Real-World Applications"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3eaadba-b665-41f8-8d2e-a86c42b1b45d",
   "metadata": {},
   "source": [
    "### String Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "4c613201-0879-4e27-9212-6a222d375db0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File extension: txt\n"
     ]
    }
   ],
   "source": [
    "let filename = \"example.txt\";\n",
    "let extension: &str = &filename[filename.len() - 3..];\n",
    "println!(\"File extension: {}\", extension);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a8390e-4e5d-4a66-b7a9-4bb1d5fbfe35",
   "metadata": {},
   "source": [
    "### Data Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5a69aec0-9b67-464a-9016-ddf25d1120ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average: 2.62\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn calculate_average(slice: &[f64]) -> f64 {\n",
    "    let sum: f64 = slice.iter().sum();\n",
    "    sum / slice.len() as f64\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let data: [f64; 6] = [2.5, 3.0, 1.5, 4.0, 2.0, 3.5];\n",
    "    let slice: &[f64] = &data[1..5];\n",
    "    let average = calculate_average(slice);\n",
    "    println!(\"Average: {:.2}\", average);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aea8230b-882e-4ad4-a112-86a791a9b21f",
   "metadata": {},
   "source": [
    "### Text Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8f4ddc7b-692b-4e12-a160-580d89b8b331",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words: [\"Rust\", \"is\", \"a\", \"systems\", \"programming\", \"language.\"]\n"
     ]
    }
   ],
   "source": [
    "fn tokenize_sentence(sentence: &str) -> Vec<&str> {\n",
    "    sentence.split_whitespace().collect()\n",
    "}\n",
    "\n",
    "let text: &str = \"Rust is a systems programming language.\";\n",
    "let words = tokenize_sentence(text);\n",
    "println!(\"Words: {:?}\", words);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18d82a46-c0df-46c1-b5c9-1292e4fba278",
   "metadata": {},
   "source": [
    "### Binary Data Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "e54ddc55-06b7-455c-8889-c4a823cc62e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn parse_header(header_data: &[u8]) {\n",
    "    // Parse the binary header data here\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let binary_data: [u8; 16] = [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20, 0x52, 0x75, 0x73, 0x74, 0x21, 0x00, 0x00, 0x0A, 0x0D];\n",
    "    let header_slice: &[u8] = &binary_data[0..8];\n",
    "    parse_header(header_slice);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00f1730a-7bbf-4e2d-9b4a-9a51285f38db",
   "metadata": {},
   "source": [
    "### Memory Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "1ccf9c1b-af36-4bc5-9635-1498befd68df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read 11 bytes: [72, 101, 108, 108, 111, 10, 87, 111, 114, 108, 100]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::{self, Read};\n",
    "\n",
    "fn main() -> io::Result<()> {\n",
    "    let mut file = File::open(\"file.txt\")?;\n",
    "    let mut buffer = [0; 1024];\n",
    "\n",
    "    // Read a portion of the file into a buffer\n",
    "    let bytes_read = file.read(&mut buffer)?;\n",
    "\n",
    "    // Process the buffer as a slice\n",
    "    let slice = &buffer[0..bytes_read];\n",
    "    println!(\"Read {} bytes: {:?}\", bytes_read, slice);\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa1ff0ba-db55-4a47-95f7-ef59be4b6918",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d342fbd7-5a17-45f2-8e9c-0cd830357f94",
   "metadata": {},
   "source": [
    "## Hash Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ade7d23-5586-4a84-a86c-069f46632a9d",
   "metadata": {},
   "source": [
    "### Creating a Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f3132d22-5472-4f3a-84af-4be220665d8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "// empty hash set\n",
    "let mut my_set: HashSet<i32> = HashSet::new();\n",
    "\n",
    "// from a vector\n",
    "let my_vector = vec![1, 2, 3, 4];\n",
    "let my_set: HashSet<i32> = my_vector.into_iter().collect();\n",
    "\n",
    "// from an array\n",
    "let a = HashSet::from([1, 2, 3]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb7fc98f-a68d-44d4-90e4-c331c7cd1867",
   "metadata": {},
   "source": [
    "### Updating a Set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90a74a46-9ab4-48f4-9263-f9968d4c5f93",
   "metadata": {},
   "source": [
    "### Adding Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "3abac9b6-5962-49ee-853f-7894117396fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 2, 1}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let mut my_set: HashSet<i32> = HashSet::new();\n",
    "my_set.insert(1);\n",
    "my_set.insert(2);\n",
    "my_set.insert(3);\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8784eb4c-b223-473a-9c53-edfd859414e1",
   "metadata": {},
   "source": [
    "### Removing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b33a5ea6-fa2e-48af-875c-12453a1dd0da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 1, 3}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let mut my_set = HashSet::from([1, 2, 3, 4]);\n",
    "my_set.remove(&2);\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97dc67b1-5f94-4b60-a693-18affb28632e",
   "metadata": {},
   "source": [
    "### Advanced Set Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "212c14af-b208-41e8-bd0b-0ffca814e197",
   "metadata": {},
   "source": [
    "### Symmetric Difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1a5a27f2-f82c-407e-839d-0d3c4e09585d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "6\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let set_x = HashSet::from([1, 2, 3, 4]);\n",
    "let set_y = HashSet::from([3, 4, 5, 6]);\n",
    "\n",
    "let symmetric_difference = set_x.symmetric_difference(&set_y);\n",
    "\n",
    "for element in symmetric_difference {\n",
    "    println!(\"{}\", element);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9505d85-0120-4402-a725-f04b5290ca8a",
   "metadata": {},
   "source": [
    "### Subset and Superset Checking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "23766aed-c5da-4e9e-b5c8-1790ca005c57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is set_a a subset of set_b? true\n",
      "Is set_b a superset of set_a? true\n"
     ]
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let set_a = HashSet::from([1, 2, 3]);\n",
    "let set_b = HashSet::from([1, 2, 3, 4, 5]);\n",
    "\n",
    "let is_subset = set_a.is_subset(&set_b);\n",
    "let is_superset = set_b.is_superset(&set_a);\n",
    "\n",
    "println!(\"Is set_a a subset of set_b? {}\", is_subset);\n",
    "println!(\"Is set_b a superset of set_a? {}\", is_superset);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388e1f08-cf9a-40d8-af44-7f48b7d82ff1",
   "metadata": {},
   "source": [
    "### Real-World Applications"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf8ccfea-8512-41b5-b70c-ea31a42623d7",
   "metadata": {},
   "source": [
    "#### Deduplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "32562881-1c7e-4d43-b6f9-86c890da5804",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4, 2, 5, 1}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let duplicates = vec![1, 2, 2, 3, 4, 4, 5];\n",
    "\n",
    "let unique_elements: HashSet<i32> = duplicates.into_iter().collect();\n",
    "\n",
    "unique_elements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28bf869-4944-48b8-ac9b-d1d026c0d46d",
   "metadata": {},
   "source": [
    "#### Membership Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "4b71df97-86d2-4721-a09c-e852ee85d1a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item 42 found in the dataset.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "let large_dataset: HashSet<i32> = (1..10001).collect(); // Create a set with numbers from 1 to 10,000\n",
    "let item_to_find = 42;\n",
    "\n",
    "if large_dataset.contains(&item_to_find) {\n",
    "    println!(\"Item {} found in the dataset.\", item_to_find);\n",
    "} else {\n",
    "    println!(\"Item {} not found in the dataset.\", item_to_find);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1457a71-46d8-4bcd-a9b5-d549ccd59aeb",
   "metadata": {},
   "source": [
    "#### Caching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "7363fa01-3e1c-417b-a077-149a6f14f255",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All tests passed!\n"
     ]
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "fn expensive_computation(input: i32) -> i32 {\n",
    "    // Simulating a costly computation\n",
    "    input * 2\n",
    "}\n",
    "\n",
    "// Global cache to store computed values\n",
    "static mut CACHE: Option<HashSet<i32>> = None;\n",
    "\n",
    "fn get_or_compute(input: i32) -> i32 {\n",
    "    // Using unsafe block to initialize the cache if it's not already initialized\n",
    "    unsafe {\n",
    "        if CACHE.is_none() {\n",
    "            CACHE = Some(HashSet::new());\n",
    "        }\n",
    "\n",
    "        let cache = CACHE.as_mut().unwrap();\n",
    "\n",
    "        if cache.contains(&input) {\n",
    "            *cache.get(&input).unwrap()\n",
    "        } else {\n",
    "            let result = expensive_computation(input);\n",
    "            cache.insert(result);\n",
    "            result\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "// Test Case 1\n",
    "let result1 = get_or_compute(5);\n",
    "assert_eq!(result1, 10);\n",
    "\n",
    "// Test Case 2\n",
    "let result2 = get_or_compute(7);\n",
    "assert_eq!(result2, 14);\n",
    "\n",
    "// Test Case 3: Testing caching behavior\n",
    "let cached_result = get_or_compute(5);\n",
    "assert_eq!(cached_result, 10);\n",
    "\n",
    "println!(\"All tests passed!\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af9f766-8816-457c-a867-b01fb3bd09cd",
   "metadata": {},
   "source": [
    "### Graph Algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "97abdfe9-5561-403a-b900-2b928852fe02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodes visited in BFS starting from node 0: {5, 1, 3, 4, 0, 2}\n"
     ]
    }
   ],
   "source": [
    "use std::collections::{HashSet, VecDeque};\n",
    "\n",
    "// Define a simple graph represented as an adjacency list\n",
    "struct Graph {\n",
    "    adjacency_list: Vec<Vec<usize>>,\n",
    "}\n",
    "\n",
    "impl Graph {\n",
    "    fn new(num_nodes: usize) -> Self {\n",
    "        Self {\n",
    "            adjacency_list: vec![vec![]; num_nodes],\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn add_edge(&mut self, u: usize, v: usize) {\n",
    "        self.adjacency_list[u].push(v);\n",
    "        self.adjacency_list[v].push(u);\n",
    "    }\n",
    "\n",
    "    fn bfs(&self, start_node: usize) -> HashSet<usize> {\n",
    "        let mut visited = HashSet::new();\n",
    "        let mut queue = VecDeque::new();\n",
    "\n",
    "        // Start BFS from the given node\n",
    "        queue.push_back(start_node);\n",
    "        visited.insert(start_node);\n",
    "\n",
    "        while let Some(node) = queue.pop_front() {\n",
    "            for &neighbor in &self.adjacency_list[node] {\n",
    "                if !visited.contains(&neighbor) {\n",
    "                    visited.insert(neighbor);\n",
    "                    queue.push_back(neighbor);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "\n",
    "        visited\n",
    "    }\n",
    "}\n",
    "\n",
    "// Create a graph\n",
    "let mut graph = Graph::new(6);\n",
    "\n",
    "// Add edges to the graph\n",
    "graph.add_edge(0, 1);\n",
    "graph.add_edge(0, 2);\n",
    "graph.add_edge(1, 3);\n",
    "graph.add_edge(1, 4);\n",
    "graph.add_edge(2, 5);\n",
    "\n",
    "// Perform BFS starting from node 0\n",
    "let start_node = 0;\n",
    "let visited_nodes = graph.bfs(start_node);\n",
    "\n",
    "println!(\"Nodes visited in BFS starting from node {}: {:?}\", start_node, visited_nodes);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca37ac4f-dd4f-4d83-82c4-e2c7c0cf842b",
   "metadata": {},
   "source": [
    "#### Set Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "56f0e5be-8f9f-4094-955a-7b056902fc4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set A: {4, 5, 1, 2, 3}\n",
      "Set B: {7, 3, 6, 4, 5}\n",
      "Union: {2, 1, 5, 3, 4, 7, 6}\n",
      "Intersection: {3, 5, 4}\n",
      "Difference: {1, 2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "fn main() {\n",
    "    let set_a: HashSet<i32> = HashSet::from([1, 2, 3, 4, 5]);\n",
    "    let set_b: HashSet<i32> = HashSet::from([3, 4, 5, 6, 7]);\n",
    "\n",
    "    let union = set_a.union(&set_b).collect::<HashSet<_>>(); // Union\n",
    "    let intersection = set_a.intersection(&set_b).collect::<HashSet<_>>(); // Intersection\n",
    "    let difference = set_a.difference(&set_b).collect::<HashSet<_>>(); // Difference\n",
    "\n",
    "    println!(\"Set A: {:?}\", set_a);\n",
    "    println!(\"Set B: {:?}\", set_b);\n",
    "    println!(\"Union: {:?}\", union);\n",
    "    println!(\"Intersection: {:?}\", intersection);\n",
    "    println!(\"Difference: {:?}\", difference);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "187c5ea1-5701-49f0-97e6-e36128967cef",
   "metadata": {},
   "source": [
    "#### Tagging and Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "15aed5a6-1a0b-4b54-838c-ae903faf3428",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{Item { id: 1, tags: {\"rust\", \"programming\"} }}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::{HashSet, hash_map::DefaultHasher};\n",
    "use std::hash::{Hash, Hasher};\n",
    "\n",
    "#[derive(Clone, Eq, PartialEq, Debug)]\n",
    "struct Item {\n",
    "    id: i32,\n",
    "    tags: HashSet<String>,\n",
    "}\n",
    "\n",
    "impl Hash for Item {\n",
    "    fn hash<H: Hasher>(&self, state: &mut H) {\n",
    "        self.id.hash(state);\n",
    "    }\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut items = HashSet::new();\n",
    "\n",
    "    items.insert(Item {\n",
    "        id: 1,\n",
    "        tags: [\"rust\", \"programming\"]\n",
    "            .iter()\n",
    "            .map(|s| s.to_string())\n",
    "            .collect(),\n",
    "    });\n",
    "\n",
    "    items.insert(Item {\n",
    "        id: 2,\n",
    "        tags: [\"python\", \"programming\"]\n",
    "            .iter()\n",
    "            .map(|s| s.to_string())\n",
    "            .collect(),\n",
    "    });\n",
    "\n",
    "    let rust_items: HashSet<_> = items\n",
    "        .iter()\n",
    "        .filter(|item| item.tags.contains(\"rust\"))\n",
    "        .cloned()\n",
    "        .collect();\n",
    "\n",
    "    println!(\"{:?}\", rust_items);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47787d41-77e7-40d0-9ae8-ae0e89e30c0c",
   "metadata": {},
   "source": [
    "#### Tracking Unique Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e54ee014-1c12-4a92-9cb1-9bbf5ffbc14b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New unique value: 1\n",
      "New unique value: 2\n",
      "New unique value: 3\n",
      "New unique value: 4\n",
      "New unique value: 5\n",
      "New unique value: 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "\n",
    "fn main() {\n",
    "    let mut unique_values = HashSet::new();\n",
    "\n",
    "    // Process a stream of values\n",
    "    let values = vec![1, 2, 3, 4, 3, 2, 5, 6];\n",
    "\n",
    "    for value in values {\n",
    "        if unique_values.insert(value) {\n",
    "            println!(\"New unique value: {}\", value);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fbed0c4-3ae8-4cb3-9b06-3c14012b77a7",
   "metadata": {},
   "source": [
    "### Concurrency Considerations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f9b759a-a103-45a1-ba4f-8ea615da6f82",
   "metadata": {},
   "source": [
    "#### Mutexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b4c88b96-f4fe-4546-a33b-032da5bb7adc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set contents: {1, 0, 3, 2}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "use std::sync::{Mutex, Arc};\n",
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    // Create a hash set wrapped in a mutex.\n",
    "    let my_set = Arc::new(Mutex::new(HashSet::<i32>::new()));\n",
    "\n",
    "    // Spawn multiple threads to insert elements into the set.\n",
    "    let num_threads = 4;\n",
    "    let mut handles = vec![];\n",
    "\n",
    "    for i in 0..num_threads {\n",
    "        let set_clone = Arc::clone(&my_set);\n",
    "        let handle = thread::spawn(move || {\n",
    "            // Lock the mutex to access the set.\n",
    "            let mut set = set_clone.lock().unwrap();\n",
    "            set.insert(i);\n",
    "            // Mutex is automatically released here when 'set' goes out of scope.\n",
    "        });\n",
    "        handles.push(handle);\n",
    "    }\n",
    "\n",
    "    // Wait for all threads to finish.\n",
    "    for handle in handles {\n",
    "        handle.join().unwrap();\n",
    "    }\n",
    "\n",
    "    // Lock the mutex to access and print the contents of the set.\n",
    "    let set = my_set.lock().unwrap();\n",
    "    println!(\"Set contents: {:?}\", *set);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "298f12d5-e7a3-4e95-8b41-aa219584d0b6",
   "metadata": {},
   "source": [
    "#### Atomic Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "45c07c88-118d-456a-9fcf-1001d74fcfab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element: 100\n",
      "Element: 42\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashSet;\n",
    "use std::sync::atomic::{AtomicPtr, Ordering};\n",
    "\n",
    "fn main() {\n",
    "    // Create an AtomicPtr to store the pointer to the HashSet.\n",
    "    let my_set = AtomicPtr::new(std::ptr::null_mut());\n",
    "\n",
    "    // Create a new HashSet and box it.\n",
    "    let new_set = Box::into_raw(Box::new(HashSet::<i32>::new()));\n",
    "\n",
    "    // Atomically store the pointer to the new set.\n",
    "    my_set.store(new_set, Ordering::Relaxed);\n",
    "\n",
    "    // Access the HashSet using the AtomicPtr.\n",
    "    let set_ptr = my_set.load(Ordering::Relaxed);\n",
    "\n",
    "    if !set_ptr.is_null() {\n",
    "        let set_ref: &mut HashSet<i32> = unsafe { &mut *set_ptr };\n",
    "\n",
    "        // Perform operations on the HashSet.\n",
    "        set_ref.insert(42);\n",
    "        set_ref.insert(100);\n",
    "\n",
    "        // Print the HashSet contents.\n",
    "        for elem in set_ref.iter() {\n",
    "            println!(\"Element: {}\", elem);\n",
    "        }\n",
    "    } else {\n",
    "        println!(\"HashSet pointer is null.\");\n",
    "    }\n",
    "\n",
    "    // Clean up the HashSet.\n",
    "    if !set_ptr.is_null() {\n",
    "        // Convert the pointer back to a Box and deallocate it.\n",
    "        let _boxed_set: Box<HashSet<i32>> = unsafe { Box::from_raw(set_ptr) };\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89bc9450-7f30-4a24-b5af-6495f13cd4e5",
   "metadata": {},
   "source": [
    "### Serialization and Deserialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d6b98c77-3cdf-4e83-a12b-e92c65cf87ea",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep serde = {version = \"1.0.190\", features = [\"derive\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9ceeb28d-03b5-43c5-97ec-ecb26e1fc637",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep serde_json = {version = \"1.0.108\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "47a46312-beae-4421-9904-e51d6ae5aff7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 2, 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use serde::{Serialize, Deserialize};\n",
    "use std::collections::HashSet;\n",
    "use std::fs::File;\n",
    "use std::io::{Read, Write};\n",
    "\n",
    "// Define a struct to hold the hash set\n",
    "#[derive(Serialize, Deserialize)]\n",
    "struct MyData {\n",
    "    my_set: HashSet<i32>,\n",
    "}\n",
    "\n",
    "fn main() -> Result<(), Box<dyn std::error::Error>> {\n",
    "    // Create a hash set\n",
    "    let mut my_set = HashSet::new();\n",
    "    my_set.insert(1);\n",
    "    my_set.insert(2);\n",
    "    my_set.insert(3);\n",
    "\n",
    "    // Serialize the hash set to a JSON file\n",
    "    let data = MyData { my_set };\n",
    "    let serialized = serde_json::to_string(&data)?;\n",
    "    let mut file = File::create(\"my_set.json\")?;\n",
    "    file.write_all(serialized.as_bytes())?;\n",
    "\n",
    "    // Deserialize the hash set from the JSON file\n",
    "    let mut file = File::open(\"my_set.json\")?;\n",
    "    let mut contents = String::new();\n",
    "    file.read_to_string(&mut contents)?;\n",
    "    let deserialized: MyData = serde_json::from_str(&contents)?;\n",
    "\n",
    "    println!(\"{:?}\", deserialized.my_set);\n",
    "\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "461529f8-f07f-40b4-bf30-8a3680bd8717",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e5aafd3-e6d5-4a0c-a695-5b4385462bf8",
   "metadata": {},
   "source": [
    "## Hash Maps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ac6a71f-62d4-4d98-9806-a9b3d955c800",
   "metadata": {},
   "source": [
    "### Creating a Hash Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f4244e88-9485-48fb-b607-d523c0f1d25f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let mut scores: HashMap<&str, i32> = HashMap::new();\n",
    "scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "44f14f0d-9bdc-48da-b3ae-1e76b9ed5eb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Prime\": 36, \"Mahmoud\": 25}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let ages = HashMap::from([\n",
    "    (\"Mahmoud\", 25),\n",
    "    (\"Prime\", 36),\n",
    "]);\n",
    "\n",
    "ages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "2973949e-f2e0-4aab-8b12-2b957bf4c26f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Prime\": 36, \"Mahmoud\": 25}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let data = vec![(\"Mahmoud\", 25), (\"Prime\", 36)];\n",
    "let name_age_map: HashMap<&str, i32> = data.iter().cloned().collect();\n",
    "\n",
    "name_age_map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e89f7498-e4c5-4a37-a06c-c32b1d72e05b",
   "metadata": {},
   "source": [
    "### Updating a Hash Map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad6dc58-efcc-4d15-bc3d-b9b1b65b35c1",
   "metadata": {},
   "source": [
    "#### Adding Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "badd3e4d-b8d9-4523-a90d-393e7725adb6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Mahmoud\": 25, \"Prime\": 36}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let mut scores = HashMap::new();\n",
    "\n",
    "scores.insert(\"Mahmoud\", 25);\n",
    "scores.insert(\"Prime\", 36);\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89cb13fc-936e-49ea-b663-9ee11f9ac86a",
   "metadata": {},
   "source": [
    "#### Removing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "acc2aa8a-a258-4c96-9b03-d586a2847d93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Mahmoud\": 25}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let mut scores = HashMap::new();\n",
    "\n",
    "scores.insert(\"Mahmoud\", 25);\n",
    "scores.insert(\"Prime\", 36);\n",
    "\n",
    "scores.remove(\"Prime\");\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "884d9b4b-95e3-47fb-9511-98f8b2fe48d4",
   "metadata": {},
   "source": [
    "#### Updating an Element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "f2376947-ed07-4238-ac47-ae4bbd8fe351",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Mahmoud\": 25, \"Prime\": 46}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "let mut scores = HashMap::new();\n",
    "\n",
    "scores.insert(\"Mahmoud\", 25);\n",
    "scores.insert(\"Prime\", 36);\n",
    "scores.insert(\"Prime\", 46);\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "555949de-dc3a-4787-a569-7abed8602edf",
   "metadata": {},
   "source": [
    "### Accessing Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "1f063c85-9db7-4e54-a2db-3101fcc98ab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud score: 25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let scores = HashMap::from([\n",
    "        (\"Mahmoud\", 25),\n",
    "        (\"Prime\", 36),\n",
    "    ]);\n",
    "    \n",
    "    let mahmoud_score = scores.get(\"Mahmoud\").unwrap();\n",
    "    println!(\"Mahmoud score: {:?}\", mahmoud_score);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38ac46a6-9a18-4872-ac4c-271b81b974f2",
   "metadata": {},
   "source": [
    "### Iterating over Hash Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "d2a4174b-6a6e-4348-b700-f7de5c6e1e15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud: 25\n",
      "Prime: 36\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let scores = HashMap::from([\n",
    "        (\"Mahmoud\", 25),\n",
    "        (\"Prime\", 36),\n",
    "    ]);\n",
    "\n",
    "    for (name, score) in &scores {\n",
    "        println!(\"{}: {}\", name, score);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "13b79e62-f01e-43b0-adb1-34c1911584ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Prime\n",
      "Name: Mahmoud\n",
      "Score: 36\n",
      "Score: 25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let scores = HashMap::from([\n",
    "        (\"Mahmoud\", 25),\n",
    "        (\"Prime\", 36),\n",
    "    ]);\n",
    "\n",
    "    for name in scores.keys() {\n",
    "        println!(\"Name: {}\", name);\n",
    "    }\n",
    "\n",
    "    for score in scores.values() {\n",
    "        println!(\"Score: {}\", score);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "599608ea-052b-4e66-bd74-6823cd45001a",
   "metadata": {},
   "source": [
    "### Advanced Hash Map Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d103861b-d2c2-45a3-bc0f-928a57010dc4",
   "metadata": {},
   "source": [
    "#### Checking for Key Existence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "986fa94d-a686-4bc7-834c-9a1bf9992208",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud's score is: 25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let scores = HashMap::from([\n",
    "        (\"Mahmoud\", 25),\n",
    "        (\"Prime\", 36),\n",
    "    ]);\n",
    "\n",
    "    let name = \"Mahmoud\";\n",
    "\n",
    "    if scores.contains_key(name) {\n",
    "        println!(\"{}'s score is: {}\", name, scores[name]);\n",
    "    } else {\n",
    "        println!(\"{} is not found.\", name);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e4fba29-33d7-4154-965d-3a11225b739a",
   "metadata": {},
   "source": [
    "#### Entry API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "762bf5f7-028c-4743-b330-b70615128838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahmoud's updated score is: 35\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut scores = HashMap::new();\n",
    "\n",
    "    scores.insert(\"Mahmoud\", 25);\n",
    "\n",
    "    let name = \"Mahmoud\";\n",
    "    let new_score = 10;\n",
    "\n",
    "    scores\n",
    "        .entry(name)\n",
    "        .and_modify(|score| *score += new_score)\n",
    "        .or_insert(new_score);\n",
    "\n",
    "    println!(\"{}'s updated score is: {}\", name, scores[name]);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e09086c-dda0-4692-a961-f709360ad3a5",
   "metadata": {},
   "source": [
    "#### Clearing a Hash Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "0dfeee03-8138-4810-9ddb-115dee914fc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Hash Map is empty.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut scores = HashMap::new();\n",
    "\n",
    "    scores.insert(\"Mahmoud\", 25);\n",
    "    scores.insert(\"Prime\", 36);\n",
    "\n",
    "    scores.clear();\n",
    "\n",
    "    if scores.is_empty() {\n",
    "        println!(\"The Hash Map is empty.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47ca0919-1d45-4683-8bf9-1a922f33e39a",
   "metadata": {},
   "source": [
    "#### Hash Map Capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "6bbf448c-ca32-4664-9a38-42eed6d88f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Capacity: 3\n",
      "Number of Entries: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut scores = HashMap::new();\n",
    "\n",
    "    scores.insert(\"Mahmoud\", 25);\n",
    "    scores.insert(\"Prime\", 36);\n",
    "\n",
    "    let current_capacity = scores.capacity();\n",
    "    let number_of_entries = scores.len();\n",
    "\n",
    "    println!(\"Current Capacity: {}\", current_capacity);\n",
    "    println!(\"Number of Entries: {}\", number_of_entries);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a02d55d-bd4b-4415-8e38-42194efdf81f",
   "metadata": {},
   "source": [
    "### Real-World Applications"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d448d88-e5c8-4157-a938-66e1b63f3a9a",
   "metadata": {},
   "source": [
    "#### Counting Occurrences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "26965b1f-52eb-4662-a6ad-6f84c2231c9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"awesome\": 1, \"is\": 2, \"Rust\": 2, \"dope\": 1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut word_counts = HashMap::new();\n",
    "\n",
    "    let text = \"Rust is awesome Rust is dope\";\n",
    "    for word in text.split_whitespace() {\n",
    "        let count = word_counts.entry(word).or_insert(0);\n",
    "        *count += 1;\n",
    "    }\n",
    "\n",
    "    println!(\"{:?}\", word_counts);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8fe603c-1947-4fb3-a377-3992dcc21265",
   "metadata": {},
   "source": [
    "#### Memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "59869fdf-3423-49df-aa05-1b1acfeabc01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fibonacci(20) = 6765\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn fibonacci_memoization(n: u64, memo: &mut HashMap<u64, u64>) -> u64 {\n",
    "    if let Some(&result) = memo.get(&n) {\n",
    "        return result;\n",
    "    }\n",
    "\n",
    "    let result = match n {\n",
    "        0 => 0,\n",
    "        1 => 1,\n",
    "        _ => fibonacci_memoization(n - 1, memo) + fibonacci_memoization(n - 2, memo),\n",
    "    };\n",
    "\n",
    "    memo.insert(n, result);\n",
    "    result\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut memo = HashMap::new();\n",
    "    let n = 20;\n",
    "\n",
    "    let result = fibonacci_memoization(n, &mut memo);\n",
    "\n",
    "    println!(\"Fibonacci({}) = {}\", n, result);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0503000-0ccd-47f4-9290-3b952873bace",
   "metadata": {},
   "source": [
    "#### Caching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "66416439-68ea-4bcc-a4d9-051aa231fc79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: 84\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn expensive_calculation(input: u32) -> u32 {\n",
    "    // Simulate a time-consuming calculation\n",
    "    input * 2\n",
    "}\n",
    "\n",
    "fn main() {\n",
    "    let mut cache = HashMap::new();\n",
    "    let input = 42;\n",
    "\n",
    "    let result = cache.entry(input).or_insert_with(|| expensive_calculation(input));\n",
    "\n",
    "    println!(\"Result: {}\", result);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e034ae4-f216-4371-bef2-ca935f977b17",
   "metadata": {},
   "source": [
    "#### Configuration Management"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "4d18bb7d-f2da-4ed0-90ec-4e79b6036f62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "API Key: your_api_key\n",
      "Port: 8080\n",
      "Debug Mode: true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut config = HashMap::new();\n",
    "\n",
    "    config.insert(\"api_key\", \"your_api_key\");\n",
    "    config.insert(\"port\", \"8080\");\n",
    "    config.insert(\"debug_mode\", \"true\");\n",
    "\n",
    "    let api_key = config.get(\"api_key\").map(|s| s.to_string()).unwrap_or_default();\n",
    "    let port = config.get(\"port\").map(|s| s.to_string()).unwrap_or_default();\n",
    "    let debug_mode = config.get(\"debug_mode\").map(|s| s.to_string()).unwrap_or_default();\n",
    "\n",
    "    println!(\"API Key: {}\", api_key);\n",
    "    println!(\"Port: {}\", port);\n",
    "    println!(\"Debug Mode: {}\", debug_mode);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bcd32a3-a079-487a-addc-578e99705f6b",
   "metadata": {},
   "source": [
    "#### Data Transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "40d935db-be1c-4dbb-b2d0-dd8214d23fdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currency Conversion: USD => US Dollar\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut conversion_table = HashMap::new();\n",
    "\n",
    "    conversion_table.insert(\"USD\", \"US Dollar\");\n",
    "    conversion_table.insert(\"EUR\", \"Euro\");\n",
    "    conversion_table.insert(\"JPY\", \"Japanese Yen\");\n",
    "\n",
    "    let input_currency = \"USD\";\n",
    "    let output_currency = conversion_table.get(input_currency).unwrap_or(&\"Unknown\");\n",
    "\n",
    "    println!(\"Currency Conversion: {} => {}\", input_currency, output_currency);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbd62f4b-1397-4acb-8347-c5857ad28fdf",
   "metadata": {},
   "source": [
    "#### Grouping Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "dc24c08a-c8e7-4da7-bb97-20121d3a76b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{25: [\"Alice\", \"Charlie\"], 35: [\"David\"], 30: [\"Bob\"]}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut people_by_age = HashMap::new();\n",
    "\n",
    "    let people = vec![\n",
    "        (\"Alice\", 25),\n",
    "        (\"Bob\", 30),\n",
    "        (\"Charlie\", 25),\n",
    "        (\"David\", 35),\n",
    "    ];\n",
    "\n",
    "    for (name, age) in people {\n",
    "        people_by_age\n",
    "            .entry(age)\n",
    "            .or_insert_with(Vec::new)\n",
    "            .push(name);\n",
    "    }\n",
    "\n",
    "    println!(\"{:?}\", people_by_age);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8845077-10dc-4aee-bbbd-f6dbe132e3cd",
   "metadata": {},
   "source": [
    "#### Graph Algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "96e5e4a9-a290-4bc2-9bf2-f4c41f956733",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"D\": [], \"C\": [\"D\"], \"B\": [\"C\", \"D\"], \"A\": [\"B\", \"C\"]}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut graph = HashMap::new();\n",
    "\n",
    "    // Define a directed graph\n",
    "    graph.insert(\"A\", vec![\"B\", \"C\"]);\n",
    "    graph.insert(\"B\", vec![\"C\", \"D\"]);\n",
    "    graph.insert(\"C\", vec![\"D\"]);\n",
    "    graph.insert(\"D\", vec![]);\n",
    "\n",
    "    println!(\"{:?}\", graph);\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b91dd50-32f2-44f0-a0ba-770488de40ac",
   "metadata": {},
   "source": [
    "#### Database Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "3d775f57-d048-42cc-9995-967ee5dba745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User Info for mahmoud: Mahmoud Harmouch\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn main() {\n",
    "    let mut database_index = HashMap::new();\n",
    "\n",
    "    // Indexing user records by username\n",
    "    let users = vec![\n",
    "        (\"mahmoud\", \"Mahmoud Harmouch\"),\n",
    "        (\"prime\", \"The Primeagen\"),\n",
    "    ];\n",
    "\n",
    "    for (username, user_info) in users {\n",
    "        database_index.insert(username, user_info);\n",
    "    }\n",
    "\n",
    "    let username_to_lookup = \"mahmoud\";\n",
    "    if let Some(user_info) = database_index.get(username_to_lookup) {\n",
    "        println!(\"User Info for {}: {}\", username_to_lookup, user_info);\n",
    "    } else {\n",
    "        println!(\"User not found: {}\", username_to_lookup);\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb7d6c2-7514-4652-ae01-329df90832ff",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}