Practice.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPQ9ZYiFg4QS5Vit4wIHizF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NotHumans211/latihan/blob/main/Practice.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**Latihan ini bertujuan untuk melatih fundamental python saya**\n",
        "\n",
        "\n",
        "Python memiliki beberapa jenis data utama yang dapat digunakan untuk menyimpan data, yaitu:\n",
        "\n",
        "\n",
        "Number (angka)\n",
        "\n",
        "Integer (angka bulat)\n",
        "Float (angka real)\n",
        "String (teks)\n",
        "\n",
        "Boolean (boolean)\n",
        "\n",
        "List (array)\n",
        "\n",
        "Tuple (array tidak dapat diubah)\n",
        "\n",
        "Dictionary (hash table)\n",
        "\n",
        "Set (kumpulan elemen unik)"
      ],
      "metadata": {
        "id": "SUjzkqO_dzPz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Number"
      ],
      "metadata": {
        "id": "2gO1lipa16ej"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Integer\n",
        "x = 10\n",
        "y = -5\n",
        "\n",
        "#Float\n",
        "pi = 3.14159\n",
        "temperature = 25.5\n",
        "\n",
        "result = x + y\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hnHWl_zv2Agu",
        "outputId": "a79e6eba-b452-483c-eebd-70027bc5a455"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#String"
      ],
      "metadata": {
        "id": "XiBXsYE52vad"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nama = \"Yahya\"\n",
        "kalimat = \"Ini adalah sebuah kalimat.\"\n",
        "\n",
        "#Menggabungkan string\n",
        "sapaan = \"Halo, \" + nama + \"!\"\n",
        "print(sapaan)\n",
        "\n",
        "#Mengakses karakter individual\n",
        "huruf_pertama = nama[1]\n",
        "print(huruf_pertama)\n",
        "\n",
        "#Mengiris string\n",
        "substring = kalimat[0:10]\n",
        "print(substring)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vOvwPoK2y-n",
        "outputId": "24eccf3c-fdd2-4deb-fd3b-451d29d41c21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Halo, Yahya!\n",
            "a\n",
            "Ini adalah\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Boolean"
      ],
      "metadata": {
        "id": "jsSebeQm3jag"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = True\n",
        "y = False\n",
        "\n",
        "print(x)  # Output: True\n",
        "print(y)  # Output: False\n",
        "\n",
        "# Contoh penggunaan dalam ekspresi kondisional\n",
        "if x:\n",
        "    print(\"x adalah True\")\n",
        "else:\n",
        "    print(\"x adalah False\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "whYcrELN3ntx",
        "outputId": "37084378-a4ac-464f-ac03-70fe1fb4c363"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "x adalah True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Boolean perbandingan\n",
        "a = 5\n",
        "b = 10\n",
        "\n",
        "print(a > b)  # Output: False\n",
        "print(a < b)  # Output: True\n",
        "print(a == b)  # Output: False\n",
        "print(a != b)  # Output: True"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YusVGNgn3uLJ",
        "outputId": "a87b0d93-738d-4ee7-e172-63ec52bef8fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Dictionary"
      ],
      "metadata": {
        "id": "OonJ4PBN3_8e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "orang = {\n",
        "    \"nama\": \"Yahya\",\n",
        "    \"umur\": 20,\n",
        "    \"kota\": \"Surabaya\"\n",
        "}\n",
        "\n",
        "print(orang[\"nama\"])\n",
        "print(orang[\"umur\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J_b_LYnQ4CuR",
        "outputId": "b7a86440-6784-46b3-a2f3-31247a137d87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yahya\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Menambahkan pasangan kunci-nilai baru\n",
        "orang[\"pekerjaan\"] = \"Programmer\"\n",
        "\n",
        "# Mengubah nilai yang ada\n",
        "orang[\"umur\"] = 20\n",
        "\n",
        "# Menghapus pasangan kunci-nilai jika ada\n",
        "if \"kota\" in orang:\n",
        "    del orang[\"kota\"]\n",
        "\n",
        "# Mengakses semua pasangan kunci-nilai\n",
        "for key, value in orang.items():\n",
        "    print(key, value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dIJarMcx4KoN",
        "outputId": "cd9e222a-1c27-4af7-c435-b14fe295c918"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nama Yahya\n",
            "umur 20\n",
            "pekerjaan Programmer\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Set"
      ],
      "metadata": {
        "id": "eQQd0Ctl46kl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "orang_keys = {\"nama\", \"umur\", \"kota\"}\n",
        "\n",
        "# To remove a key:\n",
        "if \"kota\" in orang_keys:\n",
        "    orang_keys.remove(\"kota\")\n",
        "    # Only try to delete from 'orang' if it's still present\n",
        "    if \"kota\" in orang:\n",
        "        del orang[\"kota\"]\n",
        "    print(orang_keys)"
      ],
      "metadata": {
        "id": "1UqNgtsR5SnH",
        "outputId": "7e843a41-2032-4f47-a3b6-cf3816e9ca51",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'umur', 'nama'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Variables and Data Types:"
      ],
      "metadata": {
        "id": "OWNHhNbecj0Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Declaring a Variable\n",
        "x = 10\n",
        "y = \"Hello\"\n",
        "\n",
        "# Printing a Variable\n",
        "print(x)  # Output: 10\n",
        "print(y)  # Output: Hello\n",
        "\n",
        "# Data Types\n",
        "print(type(x))  # Output: <class 'int'>\n",
        "print(type(y))  # Output: <class 'str'>\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o4WO4vnYcgzh",
        "outputId": "3fe3c20a-c7a4-4bd4-df53-b8903b5c4a15"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "Hello\n",
            "<class 'int'>\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Arithmetic Operations"
      ],
      "metadata": {
        "id": "hSuXQ-ifcpik"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Addition\n",
        "a = 5 + 3\n",
        "print(a)  # Output: 8\n",
        "\n",
        "# Subtraction\n",
        "b = 10 - 5\n",
        "print(b)  # Output: 5\n",
        "\n",
        "# Multiplication\n",
        "c = 2 * 3\n",
        "print(c)  # Output: 6\n",
        "\n",
        "# Division\n",
        "d = 10 / 2\n",
        "print(d)  # Output: 5.0 (since 10 is divided by 2)\n",
        "\n",
        "# Modulus (remainder)\n",
        "e = 7 % 3\n",
        "print(e)  # Output: 1 (since 7 is divided by 3 with remainder 1)\n",
        "\n",
        "# Exponentiation\n",
        "f = 2 ** 3\n",
        "print(f)  # Output: 8 (since 2 raised to the power of 3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4bBHhZxEcrgb",
        "outputId": "8c4a4d34-381f-45ae-c634-ae5629fab58d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "5\n",
            "6\n",
            "5.0\n",
            "1\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Comparison Operators"
      ],
      "metadata": {
        "id": "EyU7N3Ghcw1H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Equal to\n",
        "x = 5\n",
        "y = 5\n",
        "print(x == y)  # Output: True\n",
        "\n",
        "# Not Equal to\n",
        "x = 5\n",
        "y = 6\n",
        "print(x != y)  # Output: True\n",
        "\n",
        "# Greater than\n",
        "x = 5\n",
        "y = 6\n",
        "print(x > y)  # Output: False\n",
        "\n",
        "# Less than\n",
        "x = 5\n",
        "y = 6\n",
        "print(x < y)  # Output: True\n",
        "\n",
        "# Greater than or equal to\n",
        "x = 5\n",
        "y = 5\n",
        "print(x >= y)  # Output: True\n",
        "\n",
        "# Less than or equal to\n",
        "x = 5\n",
        "y = 5\n",
        "print(x <= y)  # Output: True\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X4UgCk8_cynM",
        "outputId": "72210449-c191-40c4-9183-a03072583a54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "True\n",
            "False\n",
            "True\n",
            "True\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Logical Operators:"
      ],
      "metadata": {
        "id": "HTyYnHG6c9Ol"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Logical AND (and)\n",
        "x = True\n",
        "y = False\n",
        "z = x and y\n",
        "print(z)  # Output: False\n",
        "\n",
        "# Logical OR (or)\n",
        "x = True\n",
        "y = False\n",
        "z = x or y\n",
        "print(z)  # Output: True\n",
        "\n",
        "# Logical NOT (not)\n",
        "x = True\n",
        "z = not x\n",
        "print(z)  # Output: False\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gW0IX3XqdDFr",
        "outputId": "6f7ffed5-dd66-4d1c-9759-8e4d229ecb3b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Conditional Statements"
      ],
      "metadata": {
        "id": "qZMLv7TBdHLu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# If-Else Statement\n",
        "x = 5\n",
        "if x > 0:\n",
        "    print(\"x is positive\")\n",
        "else:\n",
        "    print(\"x is not positive\")\n",
        "\n",
        "# If-Elif-Else Statement\n",
        "x = -10\n",
        "if x > 0:\n",
        "    print(\"x is positive\")\n",
        "elif x < 0:\n",
        "    print(\"x is negative\")\n",
        "else:\n",
        "    print(\"x is zero\")\n",
        "\n",
        "# If-Elif-Else Ladder\n",
        "for i in range(-5, 6):\n",
        "    if i > 0:\n",
        "        if i < 10:\n",
        "            print(i)\n",
        "    elif i == 0:\n",
        "        print(\"0\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gj1ZnXPPdKKs",
        "outputId": "81121048-cba2-4f6b-9463-dd7173f48d28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x is positive\n",
            "x is negative\n",
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Loops"
      ],
      "metadata": {
        "id": "T7BxONEddPPk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# For Loop\n",
        "for i in range(1, 6):\n",
        "    print(i)\n",
        "\n",
        "# While Loop\n",
        "i = 1\n",
        "while i <= 5:\n",
        "    print(i)\n",
        "    i += 1\n",
        "\n",
        "# Using Break in For Loop\n",
        "for i in range(1, 6):\n",
        "    if i == 3:\n",
        "        break\n",
        "    print(i)\n",
        "\n",
        "# Using Continue in For Loop\n",
        "for i in range(1, 6):\n",
        "    if i == 3:\n",
        "        continue\n",
        "    print(i)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9tCrVuk7dRPD",
        "outputId": "3d7a6a75-919d-41dd-e245-21416c8c5314"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "1\n",
            "2\n",
            "1\n",
            "2\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Functions"
      ],
      "metadata": {
        "id": "zwESTl9ZdWr9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Simple Function\n",
        "def my_function():\n",
        "    print(\"Hello from my_function!\")\n",
        "\n",
        "my_function()\n",
        "\n",
        "# Function with arguments\n",
        "def greet(name):\n",
        "    print(f\"Hello, {name}!\")\n",
        "\n",
        "greet(\"Yahya\")\n",
        "\n",
        "# Function with multiple arguments\n",
        "def add_numbers(num1, num2):\n",
        "    return num1 + num2\n",
        "\n",
        "result = add_numbers(5, 3)\n",
        "print(result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DuKbHbjodYJU",
        "outputId": "8357377b-d7ce-4d5a-cc1b-66de9c24126c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello from my_function!\n",
            "Hello, Yahya!\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Lists\n",
        "List adalah sebuah tipe data yang dapat menyimpan beberapa elemen dengan indeks numerik. List dapat berisi elemen dari berbagai jenis data, seperti angka, string, boolean, ataupun objek lain. List dapat diubah selama proses penggunaannya, dan elemen list dapat diubah ataupun dihapus dengan mudah."
      ],
      "metadata": {
        "id": "nAdLd4pydgjA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a List\n",
        "my_list = [1, 2, 3, 4, 5]\n",
        "print(my_list)  # Output: [1, 2, 3, 4, 5]\n",
        "\n",
        "# Accessing an Element in a List\n",
        "print(my_list[0])  # Prints the first element of the list\n",
        "\n",
        "# Adding a Value to a List\n",
        "my_list.append(6)\n",
        "print(my_list)  # Output: [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "# Removing a Value from a List\n",
        "my_list.remove(3)\n",
        "print(my_list)  # Output: [1, 2, 4, 5, 6]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZYI3ikhmdiYc",
        "outputId": "250f0570-6b28-4d76-8215-42b93bba2e2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n",
            "1\n",
            "[1, 2, 3, 4, 5, 6]\n",
            "[1, 2, 4, 5, 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Tuple\n",
        "Dalam Python, tuples agak sama dengan lists, tuples dapat menyimpan beberapa elemen yang berupa dari berbagai jenis data, seperti angka, string, boolean, ataupun objek lain. Tuple dapat dicria dengan tanda koma (\n",
        ",\n",
        ") dengan tidak ada spasi yang ada di belakang koma."
      ],
      "metadata": {
        "id": "RdBmPV58e4zv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple = (1, 2, 3, \"Hello\", True)\n"
      ],
      "metadata": {
        "id": "5fbvq5zufEq5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple = (1, 2, 3, \"Hello\", True)\n",
        "print(my_tuple[0])  # Output: 1\n",
        "print(my_tuple[2])  # Output: 3\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J8OBgICFfH0I",
        "outputId": "d742e270-8ee6-4caa-c50e-5c1743fedd0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_tuple = (1, 2, 3, \"Hello\", True)\n",
        "for elemen in my_tuple:\n",
        "    print(elemen)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eOLBeAJGfKzx",
        "outputId": "32460032-0655-4f77-f1e4-8ae355d2d57f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "Hello\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Probabilitas & Statistika"
      ],
      "metadata": {
        "id": "PxrYdELrt9kC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import statistics\n",
        "data = [1, 2, 3, 4, 5]\n",
        "mean = statistics.mean(data)\n",
        "median = statistics.median(data)\n",
        "mode = statistics.mode(data)\n",
        "print(\"Mean:\", mean)\n",
        "print(\"Median:\", median)\n",
        "print(\"Mode:\", mode)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qKdDgSTeuGes",
        "outputId": "03b770b4-2854-4cde-83ee-fd7c942b779e"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean: 3\n",
            "Median: 3\n",
            "Mode: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "data = np.array([1, 2, 3, 4, 5])\n",
        "percentile_25 = np.percentile(data, 25)\n",
        "percentile_75 = np.percentile(data, 75)\n",
        "print(\"25th Percentile:\", percentile_25)\n",
        "print(\"75th Percentile:\", percentile_75)\n",
        "iqr = percentile_75 - percentile_25\n",
        "print(iqr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GaM7VCxfugzO",
        "outputId": "e57ef199-788c-47f8-88cc-32ae2ae55463"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25th Percentile: 2.0\n",
            "75th Percentile: 4.0\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Simulasi prob**"
      ],
      "metadata": {
        "id": "PJbCPfxNvGXv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "#pelemparan koin 10 kali\n",
        "hasil_lemparan = []\n",
        "for i in range(10):\n",
        "  lemparan = random.choice([\"kepala\", \"angka\"])\n",
        "  hasil_lemparan.append(lemparan)\n",
        "\n",
        "print(hasil_lemparan)\n",
        "\n",
        "#hitung jumlang kemunculan \"kepala\"\n",
        "jumlah_kepala = hasil_lemparan.count(\"kepala\")\n",
        "print(f\"jumlah_kepala: {jumlah_kepala}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kSG31bVYvQCi",
        "outputId": "44a56584-869d-40ce-9b98-4debee7d3763"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['kepala', 'angka', 'angka', 'angka', 'kepala', 'kepala', 'kepala', 'kepala', 'kepala', 'kepala']\n",
            "jumlah_kepala: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#probabilitas kemunculan \"angka\"\n",
        "probabilitas_kepala = jumlah_kepala / len(hasil_lemparan)\n",
        "print(f\"probabilitas_kepala: {probabilitas_kepala}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PSovVaAPwX6k",
        "outputId": "c2f125e5-7376-4d1f-a313-80bc030bf381"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "probabilitas_kepala: 0.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Algoritma\n",
        "**Algoritma adalah serangkaian langkah-langkah terstruktur untuk menyelesaikan suatu masalah**"
      ],
      "metadata": {
        "id": "qjaro3psxR0C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Algoritma Pengurutan (Sorting)\n",
        "\n",
        "#Bubble Sort\n",
        "def bubble_sort(arr):\n",
        "    n = len(arr)\n",
        "    for i in range(n):\n",
        "        for j in range(0, n-i-1):\n",
        "            if arr[j] > arr[j+1]:\n",
        "                arr[j], arr[j+1] = arr[j+1], arr[j]\n",
        "    return arr\n",
        "data = [64, 34, 25, 12, 22, 11, 90]\n",
        "sorted_data = bubble_sort(data)\n",
        "print(sorted_data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YUsGJ7_3xdau",
        "outputId": "476e1ed8-995f-4021-d7d7-bf2cc9acaae8"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[11, 12, 22, 25, 34, 64, 90]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Insertion Sort\n",
        "def insertion_sort(arr):\n",
        "    for i in range(1, len(arr)):\n",
        "        key = arr[i]\n",
        "        j = i-1\n",
        "        while j >= 0 and key < arr[j]:\n",
        "            arr[j+1] = arr[j]\n",
        "            j -= 1\n",
        "        arr[j+1] = key\n",
        "        return arr\n",
        "data = [64, 34, 25, 12, 22, 11, 90]\n",
        "sorted_data = insertion_sort(data)\n",
        "print(\"Data terurut\",sorted_data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P5J3mczKyH1O",
        "outputId": "46b26d34-eb05-4b80-8d95-874447bcd41f"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data terurut [34, 64, 25, 12, 22, 11, 90]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Algoritma Graph"
      ],
      "metadata": {
        "id": "G5XPqOdgywya"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Breadth First Search (BFS):**"
      ],
      "metadata": {
        "id": "1RPRVVtMzI3u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import deque\n",
        "def bfs(graph, start):\n",
        "    visited = set()\n",
        "    queue = deque([start])\n",
        "    while queue:\n",
        "        vertex = queue.popleft()\n",
        "        print(vertex, end=\" \")\n",
        "        for neighbor in graph[vertex]:\n",
        "            if neighbor not in visited:\n",
        "                visited.add(neighbor)\n",
        "                queue.append(neighbor)\n",
        " graph = {\n",
        "     'A': ['B', 'C'],\n",
        "     'B': ['D', 'E'],\n",
        "     'C': ['F'],\n",
        "     'D': [],\n",
        "     'E': ['F'],\n",
        "     'F': []\n",
        "}\n",
        "\n",
        "bfs(graph, 'A')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G8f8FJNYzRCu",
        "outputId": "f0e6f406-3991-48ce-d074-6dca0cb1e455"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A B C D E F "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Algoritma Rekursi**\n",
        "\n",
        "Menghitung Faktorial"
      ],
      "metadata": {
        "id": "CuC6xGSx1PjF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def factorial(n):\n",
        "    if n == 0:\n",
        "        return 1\n",
        "    else:\n",
        "        return n * factorial(n-1)\n",
        "\n",
        "num = 5\n",
        "print(\"Faktorial dari\", num, \"adalah\", factorial(num))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "skrJArNu1YdP",
        "outputId": "7a249dcd-f766-4168-b74d-ed6e34e8a269"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Faktorial dari 5 adalah 120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Arithmetic Operations\n",
        "a = 10\n",
        "b = 3\n",
        "\n",
        "addition = a + b       # Addition\n",
        "subtraction = a - b    # Subtraction\n",
        "multiplication = a * b # Multiplication\n",
        "division = a / b       # Division (float)\n",
        "modulus = a % b        # Remainder\n",
        "\n",
        "# String Manipulation\n",
        "greeting = \"Hello\"\n",
        "name = \"World\"\n",
        "message = greeting + \", \" + name + \"!\"  # String concatenation\n",
        "\n",
        "# Basic Conditional\n",
        "if a > b:\n",
        "    comparison = f\"{a} is greater than {b}\"\n",
        "else:\n",
        "    comparison = f\"{a} is not greater than {b}\"\n",
        "\n",
        "# Print Results\n",
        "print(f\"Addition: {addition}\")\n",
        "print(f\"Subtraction: {subtraction}\")\n",
        "print(f\"Multiplication: {multiplication}\")\n",
        "print(f\"Division: {division}\")\n",
        "print(f\"Modulus: {modulus}\")\n",
        "print(f\"Message: {message}\")\n",
        "print(comparison)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LByclbRBZp_s",
        "outputId": "e9a5c90e-9117-462f-d562-8f7965e8a5fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Addition: 13\n",
            "Subtraction: 7\n",
            "Multiplication: 30\n",
            "Division: 3.3333333333333335\n",
            "Modulus: 1\n",
            "Message: Hello, World!\n",
            "10 is greater than 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U9BBQlxpRQ6A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf0f9789-dc26-45e6-daff-44561b8e0442"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iteration 1\n",
            "Iteration 2\n",
            "Iteration 3\n",
            "Hello Yahya, you are an adult.\n"
          ]
        }
      ],
      "source": [
        "# Variable Declaration\n",
        "name = \"Yahya\"\n",
        "age = 25\n",
        "\n",
        "# Function Definition\n",
        "def greet_user(username, user_age):\n",
        "    if user_age < 18:\n",
        "        print(f\"Hello {username}, you are a minor.\")\n",
        "    else:\n",
        "        print(f\"Hello {username}, you are an adult.\")\n",
        "\n",
        "# Looping through a range\n",
        "for i in range(1, 4):\n",
        "    print(f\"Iteration {i}\")\n",
        "\n",
        "# Function Call\n",
        "greet_user(name, age)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# List of numbers\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "# Dictionary of a person\n",
        "person = {\n",
        "    \"nama\": \"Yahya\",\n",
        "    \"umur\": 20,\n",
        "    \"kota\": \"Pasuruan\"\n",
        "}\n",
        "\n",
        "# Function to calculate square of a number\n",
        "def square(x):\n",
        "    return x * x\n",
        "\n",
        "# Using list comprehension to get squares of numbers\n",
        "squares = [square(num) for num in numbers]\n",
        "\n",
        "# Accessing dictionary values\n",
        "person_info = f\"{person['nama']} is {person['umur']} years old and lives in {person['kota']}.\"\n",
        "\n",
        "# Printing results\n",
        "print(f\"Squares: {squares}\")\n",
        "print(person_info)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aKcODcr_YtZx",
        "outputId": "2a917b63-0c62-4e89-a964-fa8f74919e58"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Squares: [1, 4, 9, 16, 25]\n",
            "Yahya is 20 years old and lives in Pasuruan.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Comparison Operators\n",
        "x = 15\n",
        "y = 10\n",
        "\n",
        "is_equal = (x == y)      # Checks if x is equal to y\n",
        "is_not_equal = (x != y)  # Checks if x is not equal to y\n",
        "is_greater = (x > y)     # Checks if x is greater than y\n",
        "is_lesser = (x < y)      # Checks if x is less than y\n",
        "\n",
        "# Logical Operators\n",
        "and_operation = (x > 10 and y < 20)  # Both conditions must be true\n",
        "or_operation = (x > 10 or y > 20)    # One of the conditions must be true\n",
        "not_operation = not (x == y)         # Reverses the condition\n",
        "\n",
        "# List Operations\n",
        "numbers = [1, 2, 3, 4, 5]\n",
        "\n",
        "sum_of_numbers = sum(numbers)         # Sums all elements in the list\n",
        "length_of_list = len(numbers)         # Returns the number of elements in the list\n",
        "first_element = numbers[0]            # Accesses the first element in the list\n",
        "last_element = numbers[-1]            # Accesses the last element in the list\n",
        "\n",
        "# Print Results\n",
        "print(f\"Is Equal: {is_equal}\")\n",
        "print(f\"Is Not Equal: {is_not_equal}\")\n",
        "print(f\"Is Greater: {is_greater}\")\n",
        "print(f\"Is Lesser: {is_lesser}\")\n",
        "\n",
        "print(f\"AND Operation: {and_operation}\")\n",
        "print(f\"OR Operation: {or_operation}\")\n",
        "print(f\"NOT Operation: {not_operation}\")\n",
        "\n",
        "print(f\"Sum of Numbers: {sum_of_numbers}\")\n",
        "print(f\"Length of List: {length_of_list}\")\n",
        "print(f\"First Element: {first_element}\")\n",
        "print(f\"Last Element: {last_element}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jqAn1MzDaUdJ",
        "outputId": "870972fe-123b-473c-ad53-899831e658ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is Equal: False\n",
            "Is Not Equal: True\n",
            "Is Greater: True\n",
            "Is Lesser: False\n",
            "AND Operation: True\n",
            "OR Operation: True\n",
            "NOT Operation: True\n",
            "Sum of Numbers: 15\n",
            "Length of List: 5\n",
            "First Element: 1\n",
            "Last Element: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Type Conversion\n",
        "num_str = \"100\"           # String type\n",
        "num_int = int(num_str)    # Convert string to integer\n",
        "num_float = float(num_int) # Convert integer to float\n",
        "\n",
        "# User Input\n",
        "user_input = input(\"Enter your name: \")  # Takes user input (string)\n",
        "\n",
        "# Loop - For loop\n",
        "for i in range(1, 6):   # Loop from 1 to 5\n",
        "    print(f\"Iteration {i}\")\n",
        "\n",
        "# Loop - While loop\n",
        "counter = 0\n",
        "while counter < 3:      # Loops until the condition is false\n",
        "    print(f\"While Loop Counter: {counter}\")\n",
        "    counter += 1        # Increment the counter\n",
        "\n",
        "# Print the results\n",
        "print(f\"Integer: {num_int}, Float: {num_float}\")\n",
        "print(f\"Hello, {user_input}!\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k3oNHoLtayHs",
        "outputId": "bd29d4f1-c098-46c2-8074-639cc674ca07"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your name: Yahya\n",
            "Iteration 1\n",
            "Iteration 2\n",
            "Iteration 3\n",
            "Iteration 4\n",
            "Iteration 5\n",
            "While Loop Counter: 0\n",
            "While Loop Counter: 1\n",
            "While Loop Counter: 2\n",
            "Integer: 100, Float: 100.0\n",
            "Hello, Yahya!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a Function\n",
        "def divide(a, b):\n",
        "    try:\n",
        "        result = a / b   # Division operation\n",
        "    except ZeroDivisionError:\n",
        "        return \"Error: Division by zero is not allowed!\"\n",
        "    return result\n",
        "\n",
        "# List Operations\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "\n",
        "# Add an item to the list\n",
        "fruits.append(\"orange\")\n",
        "\n",
        "# Remove an item from the list\n",
        "fruits.remove(\"banana\")\n",
        "\n",
        "# Accessing items from the list\n",
        "first_fruit = fruits[0]  # First item\n",
        "last_fruit = fruits[-1]  # Last item\n",
        "\n",
        "# Function Call\n",
        "division_result = divide(10, 2)  # Valid division\n",
        "division_by_zero = divide(10, 0)  # Invalid division\n",
        "\n",
        "# Print Results\n",
        "print(f\"Fruits List: {fruits}\")\n",
        "print(f\"First Fruit: {first_fruit}, Last Fruit: {last_fruit}\")\n",
        "print(f\"Division Result: {division_result}\")\n",
        "print(f\"Division by Zero: {division_by_zero}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J4kJpo-wblnR",
        "outputId": "1d5404c8-7520-4e3b-9fd3-c2dad20335ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fruits List: ['apple', 'cherry', 'orange']\n",
            "First Fruit: apple, Last Fruit: orange\n",
            "Division Result: 5.0\n",
            "Division by Zero: Error: Division by zero is not allowed!\n"
          ]
        }
      ]
    }
  ]
}