{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b7b8a2ae-e14d-48be-817b-a8e112000593",
   "metadata": {},
   "source": [
    "# Kombinasi Tipe Data dan Logika Pemrograman dalam Konsep Pemecahan Masalah\n",
    "Selamat datang pada modul pembelajaran \"Kombinasi Tipe Data dan Logika Pemrograman dalam Konsep Pemecahan Masalah\". Pemrograman adalah seni mengatasi tantangan dengan menggabungkan tipe data dan logika untuk menciptakan solusi yang efektif dan efisien. Dalam modul ini, kita akan menjelajahi bagaimana penggunaan tipe data yang tepat dan logika pemrograman dapat membantu Anda mengatasi berbagai permasalahan."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1b3f291-b676-41bf-9190-d652d7ae51cb",
   "metadata": {},
   "source": [
    "## A. Pengenalan Konsep Kombinasi Tipe Data dan Logika Pemrograman\n",
    "Pada bagian ini, kita akan memahami mengapa kombinasi tipe data dan logika pemrograman memiliki peran yang penting dalam pemecahan masalah. Kita akan menjelaskan bagaimana interaksi antara tipe data yang berbeda dan logika pemrograman memungkinkan kita mengembangkan solusi yang efektif dan efisien."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7bb57e8-6fed-47a9-b9d4-a4fe2f1ef192",
   "metadata": {},
   "source": [
    "### 1. Kombinasi tipe data dan logika pemrograman dalam pemecahan masalah.\n",
    "Ketika kita berhadapan dengan masalah yang kompleks, menggabungkan tipe data yang sesuai dengan logika pemrograman yang tepat adalah kunci untuk menghasilkan solusi yang baik. Tipe data memungkinkan kita untuk menyimpan informasi dengan cara yang terstruktur, sementara logika pemrograman membantu kita membuat alur kerja yang cerdas dan adaptif."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3f28ea8-8c90-42b0-abb8-10e737d0cbd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "mahasiswa = {\n",
    "    \"nama\": \"John Doe\",\n",
    "    \"usia\": 21,\n",
    "    \"mata_kuliah\": [\"Pemrograman\", \"Matematika\", \"Bisnis\"]\n",
    "}\n",
    "if mahasiswa[\"usia\"] >= 20:\n",
    "    print(f\"{mahasiswa['nama']} adalah mahasiswa yang dewasa.\")\n",
    "else:\n",
    "    print(f\"{mahasiswa['nama']} adalah mahasiswa muda.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c94604b5-8b97-4a07-a422-e6eab96a23d8",
   "metadata": {},
   "source": [
    "### 2. Tipe data dan logika berinteraksi dalam mengembangkan solusi permasalahan.\n",
    "Tipe data yang beragam, seperti angka, teks, dan struktur data kompleks seperti daftar dan kamus, bekerja bersama logika pemrograman untuk memproses dan memanipulasi informasi. Contohnya, penggunaan pernyataan kondisi memungkinkan program untuk mengambil keputusan berdasarkan nilai variabel atau input pengguna. Begitu pula, pernyataan pengulangan memungkinkan program melakukan tugas berulang secara otomatis, seperti mencari data dalam kumpulan besar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f510110c-919e-43bd-a907-9c8d7853db44",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_nilai = [85, 90, 78, 92, 70]\n",
    "total_nilai = 0\n",
    "for nilai in data_nilai:\n",
    "    total_nilai += nilai\n",
    "rata_rata = total_nilai / len(data_nilai)\n",
    "print(\"Rata-rata nilai:\", rata_rata)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb5d1028-0d70-4916-9cb2-1e71d0e8449d",
   "metadata": {},
   "source": [
    "## B. Kondisi dan Pengulangan dalam Pemecahan Masalah"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f4d6e17-1040-4a00-a173-190fb829fe66",
   "metadata": {},
   "source": [
    "### 1. Penggunaan if, else, elif untuk mengambil keputusan berdasarkan kondisi\n",
    "Pernyataan kondisi, seperti if, else, dan elif, memungkinkan program untuk membuat keputusan berdasarkan kondisi tertentu. Ini memungkinkan program untuk menjalankan blok kode yang berbeda tergantung pada nilai variabel atau input yang diberikan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0df3951b-c9fd-45de-8bd1-d140e8e184ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prestasi baik.\n"
     ]
    }
   ],
   "source": [
    "nilai = 75\n",
    "if nilai >= 85:\n",
    "    print(\"Prestasi sangat baik.\")\n",
    "elif nilai >= 70:\n",
    "    print(\"Prestasi baik.\")\n",
    "elif nilai >= 60:\n",
    "    print(\"Prestasi cukup.\")\n",
    "else:\n",
    "    print(\"Perlu perbaikan.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "628fe96e-e1aa-43db-9c98-b87b19229b3a",
   "metadata": {},
   "source": [
    "### 2. Penerapan pengulangan (for, while) untuk tugas berulang\n",
    "Pernyataan looping, seperti for dan while, memungkinkan program untuk menjalankan serangkaian tugas berulang. Ini sangat berguna saat kita perlu memproses data dalam kumpulan atau menyelesaikan tugas berulang berdasarkan kondisi tertentu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6706a911-cf3c-4bb2-b0b0-27fe1f7e600b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total: 24\n",
      "Nilai counter: 0\n",
      "Nilai counter: 1\n",
      "Nilai counter: 2\n",
      "Nilai counter: 3\n",
      "Nilai counter: 4\n"
     ]
    }
   ],
   "source": [
    "daftar_angka = [3, 7, 1, 9, 4]\n",
    "total = 0\n",
    "for angka in daftar_angka:\n",
    "    total += angka\n",
    "print(\"Total:\", total)\n",
    "\n",
    "counter = 0\n",
    "while counter < 5:\n",
    "    print(\"Nilai counter:\", counter)\n",
    "    counter += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1d2bf6-839f-49cf-9cad-949d8efc33a4",
   "metadata": {},
   "source": [
    "## C. Conditional Programming dalam Pengambilan Keputusan Berdasarkan Data\n",
    "Pada bagian ini, kita akan menjelajahi penggunaan kondisi (conditional) untuk membuat alur program yang dinamis dan responsif terhadap situasi yang lebih kompleks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a4bc1cc-e5be-429c-bf67-015cfa5297b2",
   "metadata": {},
   "source": [
    "### 1. Pernyataan kondisi untuk membuat alur program yang dinamis\n",
    "Kita akan mengembangkan program yang membantu mengelola penugasan pegawai berdasarkan jabatan dan proyek yang diberikan. Program ini akan memberikan petunjuk berdasarkan beberapa faktor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56350a52-01c8-426e-8c5b-d1a6e20c0799",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Selamat datang di Sistem Manajemen Penugasan Pegawai!\")\n",
    "jabatan = input(\"Masukkan jabatan pegawai (manajer/pegawai): \")\n",
    "proyek = input(\"Masukkan proyek yang akan dikerjakan: \")\n",
    "\n",
    "if jabatan == \"manajer\":\n",
    "    print(\"Anda adalah seorang manajer.\")\n",
    "    if proyek == \"pengembangan\":\n",
    "        print(\"Anda bertanggung jawab untuk mengarahkan tim pengembangan.\")\n",
    "    elif proyek == \"pemasaran\":\n",
    "        print(\"Anda akan mengawasi strategi pemasaran proyek ini.\")\n",
    "    else:\n",
    "        print(\"Anda memiliki peran penting dalam penugasan ini.\")\n",
    "\n",
    "elif jabatan == \"pegawai\":\n",
    "    print(\"Anda adalah seorang pegawai.\")\n",
    "    if proyek == \"pengembangan\":\n",
    "        print(\"Anda akan bekerja dalam tim pengembangan.\")\n",
    "    elif proyek == \"pemasaran\":\n",
    "        print(\"Anda akan mendukung upaya pemasaran proyek ini.\")\n",
    "    else:\n",
    "        print(\"Anda akan berkontribusi pada penugasan ini sesuai keahlian Anda.\")\n",
    "\n",
    "else:\n",
    "    print(\"Maaf, jabatan tidak dikenali. Silakan coba lagi.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b84b4b-b684-4089-b16c-f05cc43547db",
   "metadata": {},
   "source": [
    "### 2. Studi kasus: tindakan berdasarkan input pengguna\n",
    "Kita akan membuat program yang mengevaluasi kinerja siswa berdasarkan nilai yang diperoleh dalam berbagai mata pelajaran. Program ini akan memberikan rekomendasi berdasarkan prestasi akademis siswa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "725f466b-49e1-4ba1-b3c9-ee315e005421",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Selamat datang di Sistem Evaluasi Kinerja Siswa!\")\n",
    "nama_siswa = input(\"Masukkan nama siswa: \")\n",
    "nilai_mtk = float(input(\"Masukkan nilai Matematika: \"))\n",
    "nilai_ipa = float(input(\"Masukkan nilai IPA: \"))\n",
    "nilai_bahasa = float(input(\"Masukkan nilai Bahasa Inggris: \"))\n",
    "\n",
    "rata_rata = (nilai_mtk + nilai_ipa + nilai_bahasa) / 3\n",
    "\n",
    "print(f\"Rata-rata nilai {nama_siswa}: {rata_rata:.2f}\")\n",
    "\n",
    "if rata_rata >= 80:\n",
    "    print(\"Prestasi akademis sangat baik.\")\n",
    "    if nilai_mtk >= 85 and nilai_ipa >= 85 and nilai_bahasa >= 85:\n",
    "        print(\"Anda memiliki potensi di semua mata pelajaran.\")\n",
    "    elif nilai_mtk < 70 or nilai_ipa < 70 or nilai_bahasa < 70:\n",
    "        print(\"Tingkatkan prestasi Anda dalam mata pelajaran tertentu.\")\n",
    "\n",
    "elif rata_rata >= 60:\n",
    "    print(\"Prestasi akademis cukup baik.\")\n",
    "    if nilai_mtk < 60 or nilai_ipa < 60 or nilai_bahasa < 60:\n",
    "        print(\"Perhatikan mata pelajaran dengan nilai rendah.\")\n",
    "\n",
    "else:\n",
    "    print(\"Prestasi akademis perlu ditingkatkan secara signifikan.\")\n",
    "    print(\"Pertimbangkan untuk mengambil tindakan lebih lanjut.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98bae49f-6d3e-40c6-b194-2744d0858d4f",
   "metadata": {},
   "source": [
    "## D. Looping untuk Pengulangan Tugas Berulang Sesuai Kondisi\n",
    "Pada bagian ini, kita akan menjelajahi penggunaan pernyataan looping untuk menjalankan tugas berulang berdasarkan kondisi tertentu. Dalam contoh ini, kita akan membuat program yang melakukan penghitungan pendapatan pajak individu berdasarkan berbagai tingkat penghasilan. Program ini akan menggunakan pernyataan while untuk mengulang proses penghitungan untuk setiap kategori penghasilan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cbcd3c2-7fd0-4a99-a632-6021cfc24290",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Penerapan Pernyataan Looping untuk Tugas Berulang\n",
    "print(\"Selamat datang di Kalkulator Pajak Penghasilan!\")\n",
    "\n",
    "# Pengaturan tingkat penghasilan dan pajak\n",
    "tingkat_penghasilan = [20000, 40000, 60000, 80000, 100000]\n",
    "pajak = [0.05, 0.1, 0.15, 0.2, 0.25]\n",
    "\n",
    "total_penghasilan = float(input(\"Masukkan total penghasilan tahunan: \"))\n",
    "pajak_dibayarkan = 0\n",
    "indeks = 0\n",
    "\n",
    "while indeks < len(tingkat_penghasilan):\n",
    "    if total_penghasilan > tingkat_penghasilan[indeks]:\n",
    "        if indeks == len(tingkat_penghasilan) - 1:\n",
    "            pajak_dibayarkan += (total_penghasilan - tingkat_penghasilan[indeks]) * pajak[indeks]\n",
    "        else:\n",
    "            pajak_dibayarkan += (tingkat_penghasilan[indeks + 1] - tingkat_penghasilan[indeks]) * pajak[indeks]\n",
    "    else:\n",
    "        break\n",
    "    indeks += 1\n",
    "\n",
    "print(f\"Total pajak yang harus dibayarkan: {pajak_dibayarkan:.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2929a78-1795-4027-8bf9-bc76b79b70e2",
   "metadata": {},
   "source": [
    "Dalam contoh ini, kita  mencari nilai dalam sebuah dataset menggunakan for loop. Program ini mencari dan menghitung berapa kali nilai muncul dalam dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d50ef7d0-f9eb-4056-9cc7-0a76c9aa96b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Selamat datang di Program Pencarian Nilai!\")\n",
    "\n",
    "data = [5, 7, 12, 5, 9, 5, 7, 3, 5]\n",
    "nilai_yang_dicari = 5\n",
    "jumlah_kejadian = 0\n",
    "\n",
    "for nilai in data:\n",
    "    if nilai == nilai_yang_dicari:\n",
    "        jumlah_kejadian += 1\n",
    "\n",
    "print(f\"Nilai {nilai_yang_dicari} muncul sebanyak {jumlah_kejadian} kali dalam dataset.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a73e657-4122-42fb-b5b8-b586195fcf28",
   "metadata": {},
   "source": [
    "## E. Manipulasi Tipe Data Lebih Kompleks: Nested Lists, Tuples, dan Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff0dadc-a81b-4901-a1a0-eb36fa7b3e23",
   "metadata": {},
   "source": [
    "### 1. Tipe data kompleks seperti nested lists, tuples, dan dictionaries\n",
    "Nested lists memungkinkan kita menggabungkan struktur data yang lebih dalam. Misalnya, kita bisa menggunakan nested lists untuk merepresentasikan matriks tiga dimensi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f7fe7df3-4c94-442c-b192-6b194ce76f3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]\n"
     ]
    }
   ],
   "source": [
    "cube = [[[0 for _ in range(3)] for _ in range(3)] for _ in range(3)]\n",
    "print(cube)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8c057d3c-fac5-4b49-a729-023ae049b433",
   "metadata": {},
   "outputs": [],
   "source": [
    "kota_dalam_negara = [\n",
    "    {\"negara\": \"Indonesia\", \"kota\": [\"Jakarta\", \"Surabaya\", \"Bandung\"]},\n",
    "    {\"negara\": \"Amerika Serikat\", \"kota\": [\"New York\", \"Los Angeles\", \"Chicago\"]},\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1464e813-5c10-4763-b99f-161ca6dbdda2",
   "metadata": {},
   "source": [
    "Tuple sangat berguna untuk menyimpan informasi terkait dalam bentuk yang tidak dapat diubah. Contoh di bawah ini menggambarkan koordinat dalam ruang tiga dimensi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7d38d892-b034-406a-ad05-3699aecd66c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "point_3d = (10, 20, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e3f8cd04-2c23-4ba8-bfea-030bb495da6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "kota_geografis = {\n",
    "    \"Jakarta\": (6.2088, 106.8456),\n",
    "    \"New York\": (40.7128, -74.0060),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e5dd1d-3a83-46be-a221-db3e612a0277",
   "metadata": {},
   "source": [
    "Dictionaries membantu dalam menyimpan data yang memiliki hubungan kunci-nilai, seperti informasi kontak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "db7c3ef1-e432-4b44-9d04-122b319573c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "kontak = {\n",
    "    \"Alice\": {\"telepon\": \"1234567890\", \"email\": \"alice@example.com\"},\n",
    "    \"Bob\": {\"telepon\": \"9876543210\", \"email\": \"bob@example.com\"}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "643da308-ff8e-4808-8553-aff009625d7a",
   "metadata": {},
   "source": [
    "### 2. Menyimpan dan mengorganisir informasi yang lebih kompleks\n",
    "Tipe data kompleks memainkan peran krusial dalam mengelola data yang lebih kompleks dan terstruktur. Misalnya, dalam sistem manajemen toko, kita bisa menggunakan tipe data kompleks untuk menyimpan informasi produk, stok, dan detail pesanan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aedf05fc-9141-425b-983a-dc23696be4dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "produk = {\n",
    "    \"001\": {\"nama\": \"Baju\", \"harga\": 200000, \"stok\": 50},\n",
    "    \"002\": {\"nama\": \"Celana\", \"harga\": 250000, \"stok\": 30},\n",
    "}\n",
    "\n",
    "pesanan = [\n",
    "    {\"id_pesanan\": \"P001\", \"produk\": \"001\", \"jumlah\": 3},\n",
    "    {\"id_pesanan\": \"P002\", \"produk\": \"002\", \"jumlah\": 2},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b2b8781a-1d00-482a-9c69-a6801781eaad",
   "metadata": {},
   "outputs": [],
   "source": [
    "produk = {\n",
    "    \"001\": {\"nama\": \"Baju\", \"harga\": 200000, \"stok\": 50, \"kategori\": \"Pakaian\"},\n",
    "    \"002\": {\"nama\": \"Celana\", \"harga\": 250000, \"stok\": 30, \"kategori\": \"Pakaian\"},\n",
    "}\n",
    "\n",
    "pesanan = [\n",
    "    {\"id_pesanan\": \"P001\", \"produk\": \"001\", \"jumlah\": 3, \"status\": \"Proses\"},\n",
    "    {\"id_pesanan\": \"P002\", \"produk\": \"002\", \"jumlah\": 2, \"status\": \"Selesai\"},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "02540586-7342-4ac3-ab3e-0a210bb51da8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Produk:\n",
      "Kode: 001\n",
      "Nama: Baju\n",
      "Harga: 200000\n",
      "Stok: 50\n",
      "Kategori: Pakaian\n",
      "------------------------------\n",
      "Kode: 002\n",
      "Nama: Celana\n",
      "Harga: 250000\n",
      "Stok: 30\n",
      "Kategori: Pakaian\n",
      "------------------------------\n",
      "\n",
      "Data Pesanan:\n",
      "ID Pesanan: P001\n",
      "Kode Produk: 001\n",
      "Jumlah: 3\n",
      "Status: Proses\n",
      "------------------------------\n",
      "ID Pesanan: P002\n",
      "Kode Produk: 002\n",
      "Jumlah: 2\n",
      "Status: Selesai\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"Data Produk:\")\n",
    "for kode_produk, info_produk in produk.items():\n",
    "    print(f\"Kode: {kode_produk}\")\n",
    "    print(f\"Nama: {info_produk['nama']}\")\n",
    "    print(f\"Harga: {info_produk['harga']}\")\n",
    "    print(f\"Stok: {info_produk['stok']}\")\n",
    "    print(f\"Kategori: {info_produk['kategori']}\")\n",
    "    print(\"-\" * 30)\n",
    "\n",
    "print(\"\\nData Pesanan:\")\n",
    "for pesanan_info in pesanan:\n",
    "    print(f\"ID Pesanan: {pesanan_info['id_pesanan']}\")\n",
    "    print(f\"Kode Produk: {pesanan_info['produk']}\")\n",
    "    print(f\"Jumlah: {pesanan_info['jumlah']}\")\n",
    "    print(f\"Status: {pesanan_info['status']}\")\n",
    "    print(\"-\" * 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a97b931-2abf-4876-ab51-2e226f5e03b0",
   "metadata": {},
   "source": [
    "## F. Teknik Indexing dan Slicing pada Tipe Data yang Kompleks\n",
    "Indexing digunakan untuk mengakses elemen atau karakter individual dalam tipe data. Index dimulai dari 0 untuk elemen pertama, 1 untuk elemen kedua, dan seterusnya. Slicing digunakan untuk mengambil sejumlah elemen atau karakter dari tipe data dengan rentang tertentu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fdd17e6c-5c91-4594-9b41-1257a1f980ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "45\n",
      "W\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "print(my_list[2])  # Output: 30\n",
    "\n",
    "my_tuple = (5, 15, 25, 35, 45)\n",
    "print(my_tuple[4])  # Output: 45\n",
    "\n",
    "my_string = \"Hello, World!\"\n",
    "print(my_string[7])  # Output: W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "42c4d719-d057-433d-8e76-8ba3d603a3fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 30, 40]\n",
      "(25, 35, 45)\n",
      "World\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "print(my_list[1:4])  # Output: [20, 30, 40]\n",
    "\n",
    "my_tuple = (5, 15, 25, 35, 45)\n",
    "print(my_tuple[2:])  # Output: (25, 35, 45)\n",
    "\n",
    "my_string = \"Hello, World!\"\n",
    "print(my_string[7:12])  # Output: World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0bf5190-43ae-4423-aeab-a21f9abbf0c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [10, 20, 30, 40, 50, 60, 70]\n",
    "print(my_list[2:5])  # Output: [30, 40, 50]\n",
    "\n",
    "my_tuple = (5, 15, 25, 35, 45, 55)\n",
    "print(my_tuple[:3])  # Output: (5, 15, 25)\n",
    "\n",
    "my_string = \"Programming is fun!\"\n",
    "print(my_string[12:])  # Output: fun!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1430bf51-ad58-441c-bd67-4355d607f036",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "(35, 45)\n",
      "rammin\n"
     ]
    }
   ],
   "source": [
    "# Indeks Negatif\n",
    "my_list = [10, 20, 30, 40, 50]\n",
    "print(my_list[-3])  # Output: 30\n",
    "\n",
    "my_tuple = (5, 15, 25, 35, 45)\n",
    "print(my_tuple[-2:])  # Output: (35, 45)\n",
    "\n",
    "my_string = \"Python Programming\"\n",
    "print(my_string[-7:-1])  # Output: Program"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "782176b2-befe-4cc6-8a68-5c59df385c01",
   "metadata": {},
   "source": [
    "## G. Latihan dan Tantangan\n",
    "Pada bagian ini, kita akan mengajukan beberapa latihan dan tantangan yang akan membantu Anda mempraktikkan konsep-konsep yang telah dipelajari terkait kombinasi tipe data, kondisi, pengulangan, manipulasi tipe data kompleks, dan teknik indexing/slicing. Silakan mencoba untuk menyelesaikan latihan dan tantangan berikut:\n",
    "\n",
    "### Latihan\n",
    "1. Buatlah program yang menerima input dari pengguna dalam bentuk angka, dan kemudian menampilkan angka tersebut dalam bentuk kata. Contoh: Input: 123, Output: \"Seratus Dua Puluh Tiga\".\n",
    "2. Buatlah program yang meminta pengguna untuk memasukkan daftar angka, dan kemudian menghitung jumlah, rata-rata, nilai maksimal, dan nilai minimal dari angka-angka tersebut.\n",
    "\n",
    "### Tantangan\n",
    "1. Buatlah program untuk menghitung frekuensi kemunculan setiap kata dalam sebuah teks. Program ini harus mampu mengabaikan tanda baca dan menghitung kata-kata dalam huruf kecil maupun besar sebagai kata yang sama.\n",
    "2. Buatlah program yang menggabungkan dua dictionary yang memiliki key dan value berbeda menjadi satu dictionary yang memiliki key dan value gabungan dari kedua dictionary tersebut. Jika terdapat key yang sama, value dari key tersebut dijumlahkan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c220fd81-7bc9-406c-abf9-17db245798fd",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}