Data_structure_and_algorithm.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Data_structure_and_algorithm.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/riskydav/Belajar-Python/blob/main/Data_structure_and_algorithm.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fguxx7jYd5Vz"
      },
      "source": [
        "# **Data Structure and Algorithm**\n",
        "\n",
        "Pada pembelajaran data structure dan algorithm ini kita akan menggunakan google colab untuk editor sekaligus untuk run programnya."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "St8kbJq-_cMm"
      },
      "source": [
        "## Kendali program, lanjutan\n",
        "1. if bersarang\n",
        "2. pass\n",
        "3. defining function\n",
        "4. break & continue"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hvklws6E_x1u"
      },
      "source": [
        "1. if bersarang\n",
        "\n",
        "statemen seleksi if…else bersarang untuk beberapa kasus dilakukan dengan menempatkan statemen if…else didalam statemen if…else lain.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2XC2Kukyoczo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf5bb2a8-1cbd-439c-9c88-f9c12bbaa47b"
      },
      "source": [
        "# Ubah saja variabel a dan b sesuai dengan kebutuhan untuk contoh lainnya\n",
        "\n",
        "a = 4\n",
        "b = 3\n",
        "if(a == b):\n",
        "    if(a != 4):\n",
        "        print(\"Nilai A sama dengan B namun bukan angka 4\")\n",
        "    else:\n",
        "        print(\"Nilai A sama dengan B\")\n",
        "elif(a > b):\n",
        "    print(\"Nilai A lebih besar dari B\")\n",
        "else:\n",
        "    print(\"Nilai A lebih kecil dari B\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nilai A lebih besar dari B\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1rmWrzXqZaIZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ae2d5b6-1ce2-4192-e686-9c3a39b671f0"
      },
      "source": [
        "### COBA DISINI!!! ###\n",
        "\n",
        "a = 3\n",
        "b = 3\n",
        "\n",
        "if():\n",
        "  if(a != 4):\n",
        "    print(\"Nilai A sama dengan B namun bukan angka 4\")\n",
        "  else:\n",
        "    print(\"Nilai A sama dengan B\")\n",
        "elif(a > b):\n",
        "  print(\"Nilai A lebih besar dari B\")\n",
        "else:\n",
        "  print(\"Nilai A lebih kecil dari B\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nilai A lebih kecil dari B\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMB0o4CnAITe"
      },
      "source": [
        "2. pass\n",
        "\n",
        "Statemen pass tidak melakukan proses apa-apa. Statement ini dapat digunakan ketika pernyataan diperlukan secara sintaksis tetapi program tidak memerlukan Tindakan apapun."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-yUCObsbALQL"
      },
      "source": [
        "# Ubah saja variabel x sesuai dengan kebutuhan untuk contoh lainnya\n",
        "x = 10\n",
        "\n",
        "if (x < 5):\n",
        "  x = 3\n",
        "  print(x)\n",
        "else:\n",
        "  pass"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L8Ok4lxXaZVQ"
      },
      "source": [
        "### COBA DISINI!!! ###\n",
        "x = 6\n",
        "\n",
        "if (x < 5):\n",
        "  x = 3\n",
        "  print(x)\n",
        "else:\n",
        "  pass"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rxRMYiTxBCcW"
      },
      "source": [
        "3. defining function\n",
        "\n",
        "Pernyataan def  merupakan sebuah definisi fungsi. Pernyataan def harus diikuti dengan nama fungsi dan daftar parameter formal dalam kurung. Pernyataan-pernyataan yang membentuk badan fungsi dimulai pada baris berikutnya, dan harus diindentasi (penulisan baris berikutnya harus menjorok kedalam satu tab)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "COEeLlbcLqvG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75659078-2196-4676-d743-16b8e36babeb"
      },
      "source": [
        "# Pada baris kedua setelah baris fungsi def maka harus menjorok 1 tab kedalam\n",
        "\n",
        "def fib(n):    # write Fibonacci series up to n\n",
        "  a, b = 0, 1  # Pada baris kedua setelah baris fungsi def maka harus emnjorok 1 tab kedalam\n",
        "  while a < n:\n",
        "    print(a, end=' ')\n",
        "    a, b = b, a+b\n",
        "\n",
        "# Now call the function we just defined:\n",
        "fib(2000)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UD_V4sQMax3r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a8c6d087-c875-40ba-a68d-f14373b9b62c"
      },
      "source": [
        "def fib(n):\n",
        "  a, b = 0, 1\n",
        "  while a < n:\n",
        "    print(a, end=' ')\n",
        "    a, b = b , a+b\n",
        "\n",
        "fib(200)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 1 2 3 5 8 13 21 34 55 89 144 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzkR-VX4tQuJ"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RF0Kwco5Bt9G"
      },
      "source": [
        "4. Break\n",
        "\n",
        "Pernyataan break, sama seperti dalam Bahasa C, yaitu digunakan untuk keluar dari looping for atau looping while."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aRZb8jQdvK_X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbc8d8e6-dcf5-4028-c2d2-1b517d8ea325"
      },
      "source": [
        "for n in range(2, 10):\n",
        "  for x in range(2, n):\n",
        "    if n % x == 0:\n",
        "      print(n, 'sama dengan', x, '*', n//x)\n",
        "      break\n",
        "    else:\n",
        "      # loop fell through without finding a factor\n",
        "      print(n, 'ini adalah sebuah bilangan prima')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 ini adalah sebuah bilangan prima\n",
            "4 sama dengan 2 * 2\n",
            "5 ini adalah sebuah bilangan prima\n",
            "5 ini adalah sebuah bilangan prima\n",
            "5 ini adalah sebuah bilangan prima\n",
            "6 sama dengan 2 * 3\n",
            "7 ini adalah sebuah bilangan prima\n",
            "7 ini adalah sebuah bilangan prima\n",
            "7 ini adalah sebuah bilangan prima\n",
            "7 ini adalah sebuah bilangan prima\n",
            "7 ini adalah sebuah bilangan prima\n",
            "8 sama dengan 2 * 4\n",
            "9 ini adalah sebuah bilangan prima\n",
            "9 sama dengan 3 * 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iRifpYbqcIDz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66ad1fab-0e90-4d8a-d537-022f7f98e423"
      },
      "source": [
        "for n in range(2, 10):\n",
        "  for x in range(2, n):\n",
        "    if n % x == 0:\n",
        "      print(n, 'sama dengan', x, '*', n//x)\n",
        "      break"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 sama dengan 2 * 2\n",
            "6 sama dengan 2 * 3\n",
            "8 sama dengan 2 * 4\n",
            "9 sama dengan 3 * 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sqm8vUGYDnEQ"
      },
      "source": [
        "5. Break\n",
        "\n",
        "Sedangkan continue untuk melanjutkan ke iterasi berikutnya dari sebuah loop.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KjxR9y-8fF7l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddb8b085-2365-4840-ada4-7172a81095ae"
      },
      "source": [
        "### COBA DISINI!!! ###\n",
        "\n",
        "for num in range(2, 10):\n",
        "  if num % 2 == 0:\n",
        "    print(\"Nomor genap ditemukan\", num)\n",
        "    continue\n",
        "  print(\"Nomor ganjil ditemukan\", num)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nomor genap ditemukan 2\n",
            "Nomor ganjil ditemukan 3\n",
            "Nomor genap ditemukan 4\n",
            "Nomor ganjil ditemukan 5\n",
            "Nomor genap ditemukan 6\n",
            "Nomor ganjil ditemukan 7\n",
            "Nomor genap ditemukan 8\n",
            "Nomor ganjil ditemukan 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_HqrfJIDEsvq"
      },
      "source": [
        "## Object-Oriented Programming (OOP) - Intro\n",
        "\n",
        "Pemrograman berorientasi objek atau dalam bahasa inggris disebut Object Oriented Programming (OOP) adalah paradigma atau teknik pemrograman di mana semua hal dalam program dimodelkan seperti objek dalam dunia nyata. Objek di dunia nyata memiliki ciri atau attribut dan juga aksi atau kelakuan (behaviour)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CxAcnGZy4GqY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a3c0392-56bf-40ab-98dc-d39d284a6c7c"
      },
      "source": [
        "class Segitiga:\n",
        "  def __init__(self, alas, tinggi):\n",
        "    self.alas = alas\n",
        "    self.tinggi = tinggi\n",
        "\n",
        "  def get_luas(self):\n",
        "    return 0.5 * self.alas * self.tinggi\n",
        "\n",
        "segitiga1 = Segitiga(5, 10)\n",
        "segitiga2 = Segitiga(10, 10)\n",
        "\n",
        "print('luas segitiga1:', segitiga1.get_luas())\n",
        "print('luas segitiga2:', segitiga2.get_luas())    "
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "luas segitiga1: 25.0\n",
            "luas segitiga2: 50.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1CxRXQa3zPdm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67d2dd83-bd99-4375-a566-20fd8f721510"
      },
      "source": [
        "### COBA DISINI!!! ###\n",
        "\n",
        "class Segitiga():\n",
        "  def __init__(self, nilai_alas, nilai_tinggi):\n",
        "    self.alas = nilai_alas\n",
        "    self.tinggi = nilai_tinggi\n",
        "  \n",
        "  def get_luas(self):\n",
        "    return 0.5 * self.alas * self.tinggi\n",
        "\n",
        "segitiga1 = Segitiga(5, 10)\n",
        "segitiga2 = Segitiga(10, 10)\n",
        "\n",
        "print('luas segitiga1:', segitiga1.get_luas())\n",
        "print('luas segitiga2:', segitiga2.get_luas())"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "luas segitiga1: 25.0\n",
            "luas segitiga2: 50.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_7S2cQrsMzlv"
      },
      "source": [
        "# Algoritma\n",
        "\n",
        "1. Tree Traversal Algorithm\n",
        "2. Sorting Algorithm\n",
        "3. Searching Algorithm"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SiTBZb_XOx6v"
      },
      "source": [
        "## 1. Tree Traversal Algorithm\n",
        "### a. In-Order Traversal\n",
        "### b. Pre-Order Traversal\n",
        "### c. Post-Order Traversal"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ciFyTa0iOo3N"
      },
      "source": [
        "# create the class Node and the attrbutes \n",
        "class Node:\n",
        "    def __init__(self, letter):\n",
        "        self.childleft = None\n",
        "        self.childright = None\n",
        "        self.nodedata = letter\n",
        "\n",
        "# create the nodes for the tree\n",
        "root = Node('A')\n",
        "root.childleft = Node('B')\n",
        "root.childright = Node('C')\n",
        "root.childleft.childleft = Node('D')\n",
        "root.childleft.childright = Node('E')"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LtpWlFMVPAKo"
      },
      "source": [
        "A. In-Order Traversal"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ktEbcjxjPH7k",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cfb2eaf9-ed7d-4a5f-821a-a9bde39ccf1a"
      },
      "source": [
        "def InOrd(root):\n",
        "   if root:\n",
        "        InOrd(root.childleft)\n",
        "        print(root.nodedata)\n",
        "        InOrd(root.childright)\n",
        "InOrd(root)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "D\n",
            "B\n",
            "E\n",
            "A\n",
            "C\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WOrAaUJBPK3J"
      },
      "source": [
        "B. Pre-Order Traversal"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8YPeZxIXPTix",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9384af10-5aa0-494b-b42e-c019066caf4f"
      },
      "source": [
        "def PreOrd(root):\n",
        "    if root:\n",
        "        PreOrd(root.childleft)\n",
        "        PreOrd(root.childright)\n",
        "        print(root.nodedata)\n",
        "PreOrd(root)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "D\n",
            "E\n",
            "B\n",
            "C\n",
            "A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ag7-RIOTPZ_p"
      },
      "source": [
        "C. Post-Order Traversal"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_7i72INioO1",
        "outputId": "fdcc21d2-ca4e-4e0d-abf9-f80e85f8887e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def PostOrd(root):\n",
        "    if root:\n",
        "        PostOrd(root.childleft)\n",
        "        PostOrd(root.childright)\n",
        "        print(root.nodedata)\n",
        "PostOrd(root)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "D\n",
            "E\n",
            "B\n",
            "C\n",
            "A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ze50C8EHPhmY"
      },
      "source": [
        "## 2. Sorting Algorithm\n",
        "### a. Merge Sort\n",
        "### b. Bubble Sort"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXKhyPL4JpN5"
      },
      "source": [
        "### Contoh dari Merge Sort\n",
        "\n",
        "Masukkan nilai input misalnya 12 1 6 3 9 20 50 (kasih spasi setiap nilai)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pz2exT0tJplC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7eead9d2-4134-4581-cbbb-1c41e827553b"
      },
      "source": [
        "#Masukkan nilai input misalnya 12 1 6 3 9 20 50 (kasih spasi setiap nilai)\n",
        "\n",
        "def merge_sort(ourlist, left, right): #left and right corresponds to starting and ending element of ourlist\n",
        "    if right -left > 1: # check if the length of ourlist is greater than 1\n",
        "        middle = (left + right) // 2 # we divide the length in two parts\n",
        "        merge_sort(ourlist, left, middle) # recursevely I call the merge_sort function from left to middle\n",
        "        merge_sort(ourlist, middle, right) # then from middle to right\n",
        "        merge_list(ourlist, left, middle, right) # finally I create ourlist in complete form(left, middle and right) \n",
        "        \n",
        "def merge_list(ourlist, left, middle, right):# I create the function merged_list\n",
        "    leftlist = ourlist[left:middle] # I define the leftlist\n",
        "    rightlist = ourlist[middle:right] # I define the right list\n",
        "    k = left # it is the the temporary variable\n",
        "    i = 0 # this variable that corespond to the index of the first group help me to iterate from left to right\n",
        "    j = 0 # this variable that corespond to the index of the second group help me to iterate from left to right\n",
        "    while (left + i < middle and middle+ j < right): # the condition that I want to achive before to stop my iteration\n",
        "        if (leftlist[i] <= rightlist[j]): #if the element in the leftlist is less or equal to the element in the rightlist\n",
        "            ourlist[k] = leftlist[i] # In this case I fill the value of the leftlist in ourlist with index k\n",
        "            i = i + 1 #now I have to increment the value by 1\n",
        "        else: # if the above codition is not match\n",
        "            ourlist[k] = rightlist[j] # I fill the rightlist element in ourlist with index k\n",
        "            j = j + 1 # I increment index j by 1\n",
        "        k = k+1 # now I increment the value of k by 1\n",
        "    if left + i < middle: # check if left + i is less than middle\n",
        "        ourlist[k] = leftlist[i] # I place all elements of my leftlist in ourlist\n",
        "        i = i + 1\n",
        "        k = k + 1\n",
        "    else: # otherwise if my leftlist is empty\n",
        "        while k < right: # untill k is less then rightang \n",
        "            ourlist[k] = rightlist[j] # I place all elements of rightlist in ourlist \n",
        "            j = j + 1\n",
        "            k = k + 1\n",
        "            \n",
        "ourlist = input('input - masukkan nilai yang belum di sorting, kasih spasi pada setiap nilai, misalnya 1 23 6 5: ').split() # insert the input and split\n",
        "ourlist = [int(x) for x in ourlist]\n",
        "merge_sort(ourlist, 0, len(ourlist))\n",
        "print('output - nilai2 yang sudah di sorting: ')\n",
        "print(ourlist)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input - masukkan nilai yang belum di sorting, kasih spasi pada setiap nilai, misalnya 1 23 6 5: 1\n",
            "output - nilai2 yang sudah di sorting: \n",
            "[1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J9et1X_xLHaw"
      },
      "source": [
        "### Contoh dari Buuble Sort"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BQWVr9RLMyi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "58065bfe-7dd5-40aa-d855-ec51374d753b"
      },
      "source": [
        "# Python program for implementation of Bubble Sort\n",
        "  \n",
        "def bubbleSort(arr):\n",
        "    n = len(arr)\n",
        "  \n",
        "    # Traverse through all array elements\n",
        "    for i in range(n-1):\n",
        "    # range(n) also work but outer loop will repeat one time more than needed.\n",
        "  \n",
        "        # Last i elements are already in place\n",
        "        for j in range(0, n-i-1):\n",
        "  \n",
        "            # traverse the array from 0 to n-i-1\n",
        "            # Swap if the element found is greater\n",
        "            # than the next element\n",
        "            if arr[j] > arr[j + 1] :\n",
        "                arr[j], arr[j + 1] = arr[j + 1], arr[j]\n",
        "  \n",
        "# Driver code to test above\n",
        "arr = [64, 34, 25, 12, 22, 11, 90] # Nilai dalam array bisa di ubah sesuai keinginan\n",
        "  \n",
        "bubbleSort(arr)\n",
        "  \n",
        "print (\"Sorted array is:\")\n",
        "for i in range(len(arr)):\n",
        "    print (\"% d\" % arr[i]), "
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted array is:\n",
            " 11\n",
            " 12\n",
            " 22\n",
            " 25\n",
            " 34\n",
            " 64\n",
            " 90\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3bQunJFzQflz"
      },
      "source": [
        "## 3. Searching Algorithm\n",
        "### a. Linier Seacrh\n",
        "### b. Binary Search"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-15UoaD2Fs_H"
      },
      "source": [
        "### Contoh Linier Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "coRFZ9wc8OaP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "e0e5c68b-0172-49c6-e33a-87829c2eed76"
      },
      "source": [
        "# NIlai yang dicari didalam list, bisa dirumah sesuai kebutuhan untuk testing hasil lainnya\n",
        "nilai = 4 \n",
        "\n",
        "def lin_search(ourlist, key):\n",
        "    \n",
        "    for index in range(0, len(ourlist)):\n",
        "        if (ourlist[index] == key):\n",
        "            print(\"Nilai ditemukan\")\n",
        "            return  index\n",
        "    else:\n",
        "        return \"Nilai tidak ditemukan\"\n",
        "    \n",
        "ourlist = [15, 1, 9, 3]\n",
        "\n",
        "lin_search(ourlist, nilai)\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Nilai tidak ditemukan'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfd5JnsrGGeo"
      },
      "source": [
        "### Contoh Binary Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gjcHv_K4_eca",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cca3f376-a834-4b20-c30a-006b7439ab03"
      },
      "source": [
        "# NIlai dari variabel nilai_a dan nilai_b yang dicari didalam list, bisa dirubah sesuai kebutuhan untuk testing hasil lainnya\n",
        "\n",
        "nilai_a = 17\n",
        "nilai_b = 3\n",
        "\n",
        "def bin_search(ourlist, key):\n",
        "    left = 0 # I assign left position to zero\n",
        "    right = len(ourlist)-1 # I assign right position by defining the length of ourlist minus one \n",
        "    matched = False\n",
        "    while(left<=right and not matched): # the loop will continue untill the left element is less \n",
        "                                        # or equal to the right element and the matched is True\n",
        "        mid = (left+right)//2 # I find the position of the middle element\n",
        "        if ourlist[mid] == key: # if the middle element correponds to the key element\n",
        "             matched = True\n",
        "        else: #otherwise \n",
        "            if key < ourlist[mid]: # if key element is less than the middle element\n",
        "                right = mid - 1 #I assign the position of the right element as mid - 1\n",
        "            else: #otherwise\n",
        "                left = mid + 1 #left position will become the middle position plus 1\n",
        "    return matched\n",
        "\n",
        "print(bin_search([1, 3, 9, 15], nilai_a))\n",
        "print(bin_search([1, 3, 9, 15], nilai_b))"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8olyhlWUi-XM",
        "outputId": "e73bf46d-12e8-4b9e-d6b2-adcff31379fb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "list1 = (\"pynative\")\n",
        "print(list1[1:3])"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "yn\n"
          ]
        }
      ]
    }
  ]
}