LAB-ALL-ASSIGNMENTS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7c6cca2b",
   "metadata": {},
   "source": [
    "### Hillman(key exchange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "id": "d2073cd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USER A : PUBLIC KEY = 2 AND PRIVATE KEY = 6 AND SHARED KEY = 9\n",
      "USER B : PUBLIC KEY = 7 AND PRIVATE KEY = 15 AND SHARED KEY = 9\n"
     ]
    }
   ],
   "source": [
    "# functions: generate_key(p,q), generate_shared_key(pub,priv,p)\n",
    "# p,q,priv,pub\n",
    "import random\n",
    "def generate_key(p,q):\n",
    "    priv = random.randint(2,p-2) # should be less than p\n",
    "    pub = pow(q,priv,p)  #(q^priv)%p\n",
    "    return pub,priv\n",
    "\n",
    "def generate_shared_key(priv,pub,p):\n",
    "    return pow(pub,priv,p)\n",
    "p = 17 #prime number\n",
    "q = 5 #primitive root of p\n",
    "\n",
    "#generate pub and priv keys\n",
    "#userA\n",
    "A_pub,A_priv = generate_key(p,q)\n",
    "#userB\n",
    "B_pub, B_priv = generate_key(p,q)\n",
    "\n",
    "#generate shared keys for both the users\n",
    "#userA\n",
    "A_key = generate_shared_key(A_priv,B_pub,p)\n",
    "#userB\n",
    "B_key = generate_shared_key(B_priv,A_pub,p)\n",
    "\n",
    "print(\"USER A : PUBLIC KEY = {} AND PRIVATE KEY = {} AND SHARED KEY = {}\".format(A_pub,A_priv,A_key))\n",
    "print(\"USER B : PUBLIC KEY = {} AND PRIVATE KEY = {} AND SHARED KEY = {}\".format(B_pub,B_priv,B_key))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d028d6fa",
   "metadata": {},
   "source": [
    "### RSA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "id": "5fab3283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "enc:  [2098, 103, 75, 75, 1858, 2244, 227, 1858, 843, 75, 1176]      dec: hello world\n"
     ]
    }
   ],
   "source": [
    "# generate_keys(p,q), encrypt(msg,public_key), decrypt(enc_msg,private_key), gcd(a,b)\n",
    "import random\n",
    "def gcd(a, b):\n",
    "    while b != 0:\n",
    "        a, b = b, a % b\n",
    "    return a\n",
    "\n",
    "def generate_keys(p, q):\n",
    "    n = p * q\n",
    "    phi = (p - 1) * (q - 1)\n",
    "    \n",
    "    e = random.randrange(2, phi)\n",
    "    while gcd(e, phi) != 1:\n",
    "        e = random.randrange(2, phi)\n",
    "    \n",
    "    d = pow(e, -1, phi)\n",
    "    return ((e, n), (d, n))\n",
    "\n",
    "def encrypt(msg, public):\n",
    "    enc = []\n",
    "    e, n = public\n",
    "    for c in msg:\n",
    "        enc.append(pow(ord(c), e, n))\n",
    "    return enc\n",
    "\n",
    "def decrypt(enc, private):\n",
    "    dec = []\n",
    "    d, n = private\n",
    "    for c in enc:\n",
    "        dec.append(chr(pow(c, d, n)))\n",
    "    return ''.join(dec)\n",
    "\n",
    "p, q = 43, 53 \n",
    "public_key, private_key = generate_keys(p, q)\n",
    "message = input()\n",
    "encrypted_message = encrypt(message, public_key)\n",
    "decrypted_message = decrypt(encrypted_message, private_key)\n",
    "\n",
    "print(\"enc: \",encrypted_message,\"     dec:\",decrypted_message)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "264ea43d",
   "metadata": {},
   "source": [
    "### Transposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "id": "d5c8d614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enc: hloel \n",
      "\n",
      "--------------------------------------------------------------------------------------------------------------\n",
      "dec: hello \n"
     ]
    }
   ],
   "source": [
    "#enc -> row col, col row\n",
    "#dec -> col row, row col\n",
    "\n",
    "def encrypt(text,key):\n",
    "    # add padding\n",
    "    while len(text)% key !=0:\n",
    "        text+=' '\n",
    "    \n",
    "    cols = len(text) // key\n",
    "    rows = key\n",
    "    grid=[]\n",
    "    for _ in range(rows):\n",
    "        grid.append(['']*cols)\n",
    "    \n",
    "    i = 0\n",
    "    for row in range(rows):\n",
    "        for col in range(cols):\n",
    "            grid[row][col] = text[i]\n",
    "            i+=1\n",
    "    res = \"\"\n",
    "    for col in range(cols):\n",
    "        for row in range(rows):\n",
    "            res+=grid[row][col]\n",
    "    return res\n",
    "\n",
    "\n",
    "def decrypt(text,key):\n",
    "    cols = len(text) // key\n",
    "    rows = key\n",
    "    grid=[]\n",
    "    for _ in range(rows):\n",
    "        grid.append(['']*cols)\n",
    "    \n",
    "    i = 0\n",
    "    for col in range(cols):\n",
    "        for row in range(rows):\n",
    "            grid[row][col] = text[i]\n",
    "            i+=1\n",
    "    res = \"\"\n",
    "    for row in range(rows):\n",
    "        for col in range(cols):\n",
    "            res+=grid[row][col]\n",
    "    return res\n",
    "\n",
    "text = \"hello\"\n",
    "key = 3\n",
    "enc = encrypt(text,key)\n",
    "dec = decrypt(enc,key)\n",
    "\n",
    "print(\"enc:\",enc)\n",
    "print()\n",
    "print(\"--------------------------------------------------------------------------------------------------------------\")\n",
    "print(\"dec:\",dec)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e2e0366",
   "metadata": {},
   "source": [
    "### DES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "id": "f80a3089",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 bit key: 1011010101\n",
      "message 8 bit: 10101010\n",
      "CT: 10110010\n",
      "PT: 10101010\n"
     ]
    }
   ],
   "source": [
    "# apply_table\n",
    "def apply_table(inp,table):\n",
    "    res = \"\"\n",
    "    for i in table:\n",
    "        res+=inp[i-1]\n",
    "    return res\n",
    "    \n",
    "# lcs function\n",
    "def lcs(data):\n",
    "    return data[1:] + data[0]\n",
    "\n",
    "def xor(a, b):\n",
    "    res = \"\"\n",
    "    for i in range(len(a)):\n",
    "        if a[i] == b[i]:\n",
    "            res += \"0\"\n",
    "        else:\n",
    "            res += \"1\"\n",
    "    return res\n",
    "\n",
    "\n",
    "def apply_sbox(s, data): \n",
    "    row = int(\"0b\" + data[0] + data[-1], 2) # taking the first and last element as row and into decimal\n",
    "    col = int(\"0b\" + data[1:3], 2) \n",
    "    \n",
    "    \n",
    "    return bin(s[row][col])[2:] \n",
    "\n",
    "#function\n",
    "def function(EP,s0,s1,key,msg):\n",
    "    left = msg[:4]\n",
    "    right = msg[4:]\n",
    "    temp = apply_table(right,EP)\n",
    "    temp = xor(temp,key)\n",
    "    l = apply_sbox(s0,temp[:4])\n",
    "    r = apply_sbox(s1,temp[4:])\n",
    "    l = \"0\"*(2-len(l)) + l\n",
    "    r = \"0\"*(2-len(r)) + r\n",
    "    temp = apply_table(l+r,p4_table)\n",
    "    temp = xor(left,temp)\n",
    "    return temp + right\n",
    "    \n",
    "#p10,p8,p4,IP,EP,s0,s1\n",
    "p8_table = [6, 3, 7, 4, 8, 5, 10, 9]\n",
    "p10_table = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]\n",
    "p4_table = [2, 4, 3, 1]\n",
    "IP = [2, 6, 3, 1, 4, 8, 5, 7]\n",
    "IP_inv = [4, 1, 3, 5, 7, 2, 8, 6]\n",
    "EP = [4, 1, 2, 3, 2, 3, 4, 1]\n",
    "s0 = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]\n",
    "s1 = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]\n",
    "\n",
    "# key generation (key1 and key2)\n",
    "key = input(\"10 bit key: \")\n",
    "temp = apply_table(key,p10_table)\n",
    "left = temp[:5]\n",
    "right = temp[5:]\n",
    "left = lcs(left)\n",
    "right = lcs(right)\n",
    "key1 = apply_table(left+right,p8_table)\n",
    "left = lcs(left)\n",
    "right = lcs(right)\n",
    "left = lcs(left)\n",
    "right = lcs(right)\n",
    "key2 = apply_table(left + right, p8_table)\n",
    "\n",
    "# encryption\n",
    "msg = input(\"message 8 bit: \")\n",
    "temp = apply_table(msg,IP)\n",
    "temp = function(EP,s0,s1,key1,temp)\n",
    "temp = temp[4:] + temp[:4] #swap\n",
    "temp = function(EP,s0,s1,key2,temp)\n",
    "CT = apply_table(temp,IP_inv)\n",
    "print(\"CT:\",CT)\n",
    "\n",
    "temp = apply_table(CT,IP)\n",
    "temp = function(EP,s0,s1,key2,temp)\n",
    "temp = temp[4:] + temp[:4] #swap\n",
    "temp = function(EP,s0,s1,key1,temp)\n",
    "PT = apply_table(temp,IP_inv)\n",
    "print(\"PT:\",PT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d1ed7c7",
   "metadata": {},
   "source": [
    "### Scheduling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "id": "817456df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'a', 'e', 'd']\n"
     ]
    }
   ],
   "source": [
    "arr = [['a', 2, 20], \n",
    "       ['b', 2, 15],\n",
    "       ['c', 1, 10],\n",
    "       ['d', 4, 5],\n",
    "       ['e', 3, 1]]\n",
    "t = 4\n",
    "n = len(arr)\n",
    "slots = [False]*t\n",
    "result = ['-1']*t\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(n-1-i):\n",
    "        if arr[j][2] < arr[j+1][2]:\n",
    "            arr[j],arr[j+1] = arr[j+1],arr[j]\n",
    "\n",
    "for i in range(len(arr)):\n",
    "    for j in range(min(arr[i][1]-1,t-1),-1,-1):\n",
    "        if slots[j] == False:\n",
    "            slots[j] = True\n",
    "            result[j] = arr[i][0]\n",
    "            break\n",
    "            \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64ba3cf1",
   "metadata": {},
   "source": [
    "### Nqueens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "e6149d3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total solutions for 4-queens problem: 2\n",
      "Solution 1:\n",
      "[0, 0, 1, 0]\n",
      "[1, 0, 0, 0]\n",
      "[0, 0, 0, 1]\n",
      "[0, 1, 0, 0]\n",
      "\n",
      "Solution 2:\n",
      "[0, 1, 0, 0]\n",
      "[0, 0, 0, 1]\n",
      "[1, 0, 0, 0]\n",
      "[0, 0, 1, 0]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def is_safe(board, row, col):\n",
    "    n = len(board)\n",
    "    \n",
    "    # Check the row\n",
    "    for i in range(col):\n",
    "        if board[row][i] == 1:\n",
    "            return False\n",
    "        \n",
    "    # Check the upper diagonal\n",
    "    r, c = row, col\n",
    "    while r >= 0 and c >= 0:\n",
    "        if board[r][c] == 1:\n",
    "            return False\n",
    "        r -= 1\n",
    "        c -= 1\n",
    "\n",
    "    # Check the lower diagonal\n",
    "    r, c = row, col\n",
    "    while r < n and c >= 0:\n",
    "        if board[r][c] == 1:\n",
    "            return False\n",
    "        r += 1\n",
    "        c -= 1\n",
    "\n",
    "    # If no conflicts found, it's safe to place a queen\n",
    "    return True\n",
    "\n",
    "def backtrack(board, col, solutions):\n",
    "    n = len(board)\n",
    "    \n",
    "    # If all queens are placed, a valid solution is found\n",
    "    if col == n:\n",
    "        solutions.append([row[:] for row in board])\n",
    "        return\n",
    "\n",
    "    # Explore all possible positions in the current column\n",
    "    for row in range(n):\n",
    "        if is_safe(board, row, col):\n",
    "            board[row][col] = 1  # Place a queen\n",
    "\n",
    "            # Recursively move to the next column\n",
    "            backtrack(board, col + 1, solutions)\n",
    "\n",
    "            board[row][col] = 0  # Remove the queen (backtrack)\n",
    "\n",
    "def solve_nqueens(n):\n",
    "    board = [[0] * n for _ in range(n)]\n",
    "    solutions = []\n",
    "    backtrack(board, 0, solutions)\n",
    "    return solutions\n",
    "\n",
    "# Example usage\n",
    "n = 4\n",
    "solutions = solve_nqueens(n)\n",
    "\n",
    "print(f\"Total solutions for {n}-queens problem: {len(solutions)}\")\n",
    "for i, solution in enumerate(solutions):\n",
    "    print(f\"Solution {i+1}:\")\n",
    "    for row in solution:\n",
    "        print(row)\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3debd774",
   "metadata": {},
   "source": [
    "### ChatBot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "id": "b4dfea04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">    hello\n",
      "Hello!\n",
      ">    weather\n",
      "sunny\n",
      ">    time\n",
      "The time is 00:23\n",
      ">    date\n",
      "The date is 2023-05-27\n",
      ">    name\n",
      "Myself HarshBot\n",
      ">    lala\n",
      "idk\n",
      ">    bye\n",
      "Have a good day!\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "greetings = ['Hello!','Hi!']\n",
    "salutations = ['Bye!','See you soon!','Have a good day!']\n",
    "others = {\"weather\" : [\"sunny\",\"chilly\",\"rainy\"],\n",
    "          \"name\" : [\"My name is HarshBot\",\"Myself HarshBot\",\"People call me HarshBot\"]\n",
    "         }\n",
    "def greet():\n",
    "    print(random.choice(greetings))\n",
    "def farewell():\n",
    "    print(random.choice(salutations))\n",
    "def date():\n",
    "    print(\"The date is\",str(datetime.datetime.now())[:10])\n",
    "def time():\n",
    "     print(\"The time is\",str(datetime.datetime.now())[11:16])\n",
    "def process(inp):\n",
    "    if \"hello\" in inp.lower():\n",
    "        greet()\n",
    "    elif \"bye\" in inp.lower():\n",
    "        farewell()\n",
    "        return True\n",
    "    elif \"date\" in inp.lower():\n",
    "        date()\n",
    "    elif \"time\" in inp.lower():\n",
    "        time()\n",
    "    else:\n",
    "        found_response = False\n",
    "        for key,value in others.items():\n",
    "            if key in inp.lower():\n",
    "                print(random.choice(value))\n",
    "                found_response = True\n",
    "                break\n",
    "        if not found_response:\n",
    "            print(\"idk\")\n",
    "            \n",
    "    return False      \n",
    "\n",
    "finished = False\n",
    "while not finished:\n",
    "    inp = input(\">    \")\n",
    "    finished = process(inp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e72adf0f",
   "metadata": {},
   "source": [
    "### Expert System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "id": "cd6cac9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "attendance: 9\n",
      "creative: 10\n",
      "Excellent Employee!\n"
     ]
    }
   ],
   "source": [
    "rules = {\n",
    "    \"rule1\": {\n",
    "        \"condition\" : lambda data : data[\"attendance\"] >=7.5 and data[\"creative\"] >= 7,\n",
    "        \"output\" : \"Excellent Employee!\"\n",
    "    },\n",
    "    \"rule2\" : {\n",
    "        \"condition\" : lambda  data : data[\"attendance\"] >= 5 and data[\"creative\"] >=6 ,\n",
    "        \"output\" : \"Average Employee\"\n",
    "    },\n",
    "    \"rule3\" : {\n",
    "        \"condition\" : lambda data: data[\"attendance\"] <5 and data[\"creative\"] <5,\n",
    "        \"output\" : \"Poor\"\n",
    "    }\n",
    "}\n",
    "def evaluate(data):\n",
    "    for rule in rules.values():\n",
    "        if rule['condition'](data):\n",
    "            return rule['output']\n",
    "    return \"Need more details\"\n",
    "\n",
    "data = {\n",
    "    \"attendance\" : int(input(\"attendance: \")),\n",
    "    \"creative\" : int(input(\"creative: \"))\n",
    "    }\n",
    "     \n",
    "perf = evaluate(data)\n",
    "print(perf)    \n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "054cac6f",
   "metadata": {},
   "source": [
    "### BFS AND DFS IN JAVA"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6c7d57d7",
   "metadata": {},
   "source": [
    "import java.util.*;\n",
    "\n",
    "public class Main\n",
    "{\n",
    "    private int V;\n",
    "    private LinkedList<Integer> [] adjList;\n",
    "    \n",
    "    public Main(int V)\n",
    "    {\n",
    "        this.V = V;\n",
    "        adjList = new LinkedList[V];\n",
    "        for(int i=0;i<V;++i)\n",
    "        {\n",
    "            adjList[i] = new LinkedList<>();\n",
    "        }\n",
    "    }\n",
    "    void addEdge(int x,int y)\n",
    "    {\n",
    "        adjList[x].add(y);\n",
    "        adjList[y].add(x);\n",
    "    }\n",
    "    \n",
    "    void DFS(int v)\n",
    "    {\n",
    "        boolean [] visited = new boolean[V];\n",
    "        DFSUtil(v,visited);\n",
    "        \n",
    "    }\n",
    "    void DFSUtil(int v,boolean [] visited)\n",
    "    {\n",
    "        visited[v] = true;\n",
    "        System.out.print(v + \" \");\n",
    "        for (int n:adjList[v])\n",
    "        {\n",
    "            if (!visited[n])\n",
    "            {\n",
    "                DFSUtil(n,visited);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    void BFS(int v)\n",
    "    {\n",
    "        boolean [] visited = new boolean[V];\n",
    "        LinkedList<Integer> queue = new LinkedList<>();\n",
    "        \n",
    "        visited[v] = true;\n",
    "        queue.add(v);\n",
    "        \n",
    "        while (!queue.isEmpty())\n",
    "        {\n",
    "            int currIndex = queue.poll();\n",
    "            System.out.print(currIndex+\" \");\n",
    "            for (int n:adjList[currIndex])\n",
    "            {\n",
    "                if (!visited[n])\n",
    "                {\n",
    "                    visited[n] = true;\n",
    "                    queue.add(n);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        Main graph = new Main(4);\n",
    "        graph.addEdge(0,1);\n",
    "        graph.addEdge(1,2);\n",
    "        graph.addEdge(2,3);\n",
    "        graph.addEdge(3,0);\n",
    "        graph.DFS(0);\n",
    "        System.out.println();\n",
    "        graph.BFS(0);\n",
    "}\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2e70d49",
   "metadata": {},
   "source": [
    "### Astar Algo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "id": "5b7c1493",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Path found:\n",
      "(0, 0)\n",
      "(1, 0)\n",
      "(2, 0)\n",
      "(3, 0)\n",
      "(3, 1)\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "def astar(start,goal,grid):\n",
    "    OL,CL=[],[]\n",
    "    OL.append((start,None,0,abs(start[0]-goal[0])+abs(start[1]-goal[1])))\n",
    "    #processing\n",
    "    while OL:\n",
    "        #lowest f \n",
    "        curr_node = min(OL,key = lambda node:node[2])\n",
    "        #add in CL\n",
    "        CL.append(curr_node)\n",
    "        OL.remove(curr_node)\n",
    "        #is goal?\n",
    "        if curr_node[0] == goal:\n",
    "            path = []\n",
    "            while curr_node:\n",
    "                path.append(curr_node[0])\n",
    "                curr_node = curr_node[1]\n",
    "            return path[::-1]\n",
    "        #generate neighbors\n",
    "        neighbors=[]\n",
    "        x,y = curr_node[0]\n",
    "        moves = [(0,1),(1,0),(-1,0),(0,-1)]\n",
    "        for move in moves:\n",
    "            new_x = x + move[0]\n",
    "            new_y = y + move[1]\n",
    "            if (0<= new_x < len(grid) and 0 <= new_y < len(grid) and grid[new_x][new_y]!=\"#\"):\n",
    "                neighbors.append(((new_x,new_y),curr_node,curr_node[2]+1,abs(new_x - goal[0])+abs(new_y - goal[1])))\n",
    "        #process each neighbor\n",
    "        for neighbor in neighbors:\n",
    "            if neighbor in CL:\n",
    "                continue\n",
    "            found_duplicate = False\n",
    "            for node in OL:\n",
    "                if (neighbor[0]==node[0] and neighbor[2] == node[2]):\n",
    "                    found_duplicate = True\n",
    "                    break\n",
    "            if not found_duplicate:\n",
    "                OL.append(neighbor)\n",
    "    return None\n",
    "\n",
    "grid = [\n",
    "    ['S','.','#','.','.'],\n",
    "    ['.','.','.','.','.'],\n",
    "    ['.','#','#','.','.'],\n",
    "    ['.','.','G','.','.'],\n",
    "    ['.','.','.','.','.']\n",
    "    ]\n",
    "\n",
    "start = (0, 0)  # Starting position\n",
    "goal = (3, 2)  # Goal position\n",
    "\n",
    "path = astar(start, goal, grid)\n",
    "if path:\n",
    "    print(\"Path found:\")\n",
    "    for position in path:\n",
    "        print(position)\n",
    "else:\n",
    "    print(\"No path found.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf712736",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}