{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# नोटबुक 1: ज्यूपिटर नोटबुक की शुरुआती जानकारी और एआई समस्या समाधान\n",
        "\n",
        "लोकटेक (Loktech) की पहली व्यावहारिक (Interactive) एआई नोटबुक में आपका स्वागत है!\n",
        "\n",
        "यदि आपने पहले कभी कोई प्रोग्रामिंग कोड नहीं लिखा है या कभी ज्यूपिटर नोटबुक (Jupyter Notebook) नहीं खोली है, तो आप बिल्कुल सही जगह पर हैं। हम यह मानकर चल रहे हैं कि आपको कोडिंग का पूर्व ज्ञान नहीं है।\n",
        "\n",
        "### ज्यूपिटर नोटबुक क्या होती है?\n",
        "यह एक ऐसा दस्तावेज़ है जो अलग-अलग **खानों (Cells)** से मिलकर बनता है:\n",
        "1. **टेक्स्ट सेल (Markdown Cell):** जैसे यह खाना जिसे आप पढ़ रहे हैं, इसमें समझाने के लिए टेक्स्ट होता है।\n",
        "2. **कोड सेल (Code Cell):** वह खाना जिसमें कंप्यूटर के चलाने के लिए छोटे-छोटे आदेश (Python code) लिखे होते हैं।\n",
        "\n",
        "### सेल को कैसे चलाएँ (Run करें)?\n",
        "किसी भी कोड सेल को चलाने के लिए:\n",
        "- नीचे दिए गए ग्रे रंग के कोड बॉक्स में कहीं भी क्लिक करें।\n",
        "- अपने कीबोर्ड पर **Shift + Enter** एक साथ दबाएँ (या सेल के ऊपर बाईं ओर बने प्ले/रन तीर के निशान को दबाएँ)।\n",
        "\n",
        "**घबराएँ नहीं:** कोड चलाने या कोई गलती करने से आपका कंप्यूटर या वेबसाइट कभी खराब नहीं होगी! यदि कुछ गड़बड़ लगे तो बस पेज को रिफ्रेश कर लें।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# आइए अपना पहला पायथन (Python) कोड चलाते हैं!\n",
        "# इस सेल पर क्लिक करें और Shift + Enter दबाएँ।\n",
        "\n",
        "print(\"राम राम! लोकटेक एआई नोटबुक 1 में आपका स्वागत है!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# पायथन एक तुरंत काम करने वाले कैलकुलेटर की तरह भी काम करता है।\n",
        "# नंबरों को बदलकर फिर से Shift + Enter दबाएँ!\n",
        "\n",
        "result = 25 + 10 * 3\n",
        "print(\"गणना का परिणाम है:\", result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## प्रयोग 1: स्टेट स्पेस सर्च (हमारे गाँव में रास्ता खोजना)\n",
        "\n",
        "अध्याय 2 में हमने **स्टेट स्पेस (State Space)** के बारे में सीखा कि कैसे कोई एआई शुरुआत के बिंदु से लेकर लक्ष्य (Goal) तक कदम-दर-कदम रास्ता खोजता है।\n",
        "\n",
        "आइए अपने गाँव के रास्तों का एक छोटा नक्शा पायथन में बनाते हैं, और देखते हैं कि कंप्यूटर हमारे `घर` (Home) से `ओरण` (Oran) तक पहुँचने का रास्ता कैसे खोजता है।"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# कदम 1: हमारे गाँव का नक्शा (कौन किस जगह से जुड़ा है)\n",
        "village_map = {\n",
        "    \"Home\": [\"Well\", \"Field\"],\n",
        "    \"Well\": [\"Home\", \"Naka\", \"Oran\"],\n",
        "    \"Field\": [\"Home\", \"Naka\"],\n",
        "    \"Naka\": [\"Well\", \"Field\", \"Oran\"],\n",
        "    \"Oran\": [\"Well\", \"Naka\"]\n",
        "}\n",
        "\n",
        "print(\"हमारे गाँव के रास्तों का कनेक्शन तैयार है:\", village_map)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# कदम 2: रास्ता खोजने का एक आसान फंक्शन (Function)\n",
        "def find_path(map_data, current, destination, visited=None):\n",
        "    if visited is None:\n",
        "        visited = []\n",
        "    visited = visited + [current]\n",
        "    \n",
        "    if current == destination:\n",
        "        return visited\n",
        "        \n",
        "    for neighbor in map_data.get(current, []):\n",
        "        if neighbor not in visited:\n",
        "            path = find_path(map_data, neighbor, destination, visited)\n",
        "            if path:\n",
        "                return path\n",
        "    return None\n",
        "\n",
        "# कंप्यूटर को घर से ओरण तक रास्ता खोजने दें!\n",
        "path = find_path(village_map, \"Home\", \"Oran\")\n",
        "print(\"एआई ने हमारे गाँव में यह रास्ता खोजा:\", \" -> \".join(path))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## प्रयोग 2: ह्युरिस्टिक (अनुमान लगाकर छोटा रास्ता चुनना)\n",
        "\n",
        "बिना सोचे-समझे हर रास्ते पर भटकने के बजाय, एआई **ह्युरिस्टिक (Heuristic - व्यावहारिक अनुमान)** का इस्तेमाल करता है ताकि वह पहले उसी दिशा को चुने जो लक्ष्य के ज्यादा करीब हो।\n",
        "\n",
        "आइए ग्रिड (Grid) पर दो स्थानों के बीच अनुमानित दूरी निकालते हैं!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "# ह्युरिस्टिक दूरी का फॉर्मूला (दो बिंदुओं के बीच कदम गिनना)\n",
        "def heuristic_distance(x1, y1, x2, y2):\n",
        "    return abs(x1 - x2) + abs(y1 - y2)\n",
        "\n",
        "# मान लीजिए हमारा घर (0, 0) पर है और ओरण (3, 4) पर है\n",
        "home_pos = (0, 0)\n",
        "oran_pos = (3, 4)\n",
        "distance_estimate = heuristic_distance(home_pos[0], home_pos[1], oran_pos[0], oran_pos[1])\n",
        "\n",
        "print(f\"घर से ओरण की अनुमानित दूरी: {distance_estimate} कदम\")"
      ],
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}