diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index 0d926f23..00000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-version: 2.1
-
-orbs:
- # The python orb contains a set of prepackaged CircleCI configuration you can use repeatedly in your configuration files
- # Orb commands and jobs help you with common scripting around a language/tool
- # so you dont have to copy and paste it everywhere.
- # See the orb documentation here: https://circleci.com/developer/orbs/orb/circleci/python
- python: circleci/python@1.2
-
-workflows:
- circle_python_test: # This is the name of the workflow, feel free to change it to better match your workflow.
- # Inside the workflow, you define the jobs you want to run.
- # For more details on extending your workflow, see the configuration docs: https://circleci.com/docs/2.0/configuration-reference/#workflows
- jobs:
- - build-and-test
-
-
-jobs:
- build-and-test: # This is the name of the job, feel free to change it to better match what you're trying to do!
- # These next lines defines a Docker executors: https://circleci.com/docs/2.0/executor-types/
- # You can specify an image from Dockerhub or use one of the convenience images from CircleCI's Developer Hub
- # A list of available CircleCI Docker convenience images are available here: https://circleci.com/developer/images/image/cimg/python
- # The executor is the environment in which the steps below will be executed - below will use a python 3.9 container
- # Change the version below to your required version of python
- docker:
- - image: cimg/python:3.8
- # Checkout the code as the first step. This is a dedicated CircleCI step.
- # The python orb's install-packages step will install the dependencies from a Pipfile via Pipenv by default.
- # Here we're making sure we use just use the system-wide pip. By default it uses the project root's requirements.txt.
- # Then run your tests!
- # CircleCI will report the results back to your VCS provider.
- steps:
- - checkout
- - python/install-packages:
- pkg-manager: pip
- # app-dir: ~/project/package-directory/ # If you're requirements.txt isn't in the root directory.
- # pip-dependency-file: test-requirements.txt # if you have a different name for your requirements file, maybe one that combines your runtime and test requirements.
- - run:
- name: install requirements
- command: pip install -r requirements.txt
- - run:
- name: install flake8
- command: pip install flake8
- - run:
- name: install pytest
- command: pip install pytest
- - run:
- name: lint flake8 testing
- command: flake8 . --ignore=E203,W503,W504 --max-complexity=25 --max-line-length=88
- - run:
- name: Run tests with pytesting
- command: pytest . --doctest-modules --ignore=Basic/
\ No newline at end of file
diff --git a/.coverage b/.coverage
index 9a6c7cc3..c2958da9 100644
Binary files a/.coverage and b/.coverage differ
diff --git a/.flake8 b/.flake8
index 465c9320..d7b93fae 100644
--- a/.flake8
+++ b/.flake8
@@ -1,5 +1,6 @@
[flake8]
-ignore = E203,W503,W504
+ignore = E203,W503,W504,E741
max-complexity = 25
show-source = true
-max-line-length = 88
\ No newline at end of file
+max-line-length = 88
+exclude = Basic
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..176a458f
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+* text=auto
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 00000000..77ad5c1d
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,15 @@
+
+# This is a comment.
+# Each line is a file pattern followed by one or more owners.
+
+# These owners will be the default owners for everything in
+# the repo. Unless a later match takes precedence,
+# @global-owner1 and @global-owner2 will be requested for
+# review when someone opens a pull request.
+
+# Commenting instead of deleting these users in the legacy file
+# to fix the current errors.
+# @KelvinMulyawan - since this user could not be found on GitHub
+# @hendri-27 - since this user didn't appear to have write access
+# according to the bellshade/Python contributions graphs
+* @athallahmaajid @slowy07
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..4aa078ab
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+github: [slowy07, athallahmaajid]
+custom: ["https://saweria.co/bellshade"]
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 45ef134e..69aa9b51 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -7,17 +7,18 @@ assignees: slowy07
---
-**Masalah**
-Jelaskan masalah kamu disini
+## Masalah
+
-**Screenshots atau contoh error**a
-kamu bisa copy dan paste contoh errornya disini atau mngirim screenshot
+## Screenshots atau contoh error
+
```
pesan error
```
-**Desktop (please complete the following information):**
- - OS: ``linux/windows/macOS```
+## Desktop (please complete the following information):
+
+ - OS: ``linux/windows/macOS``
- Python: ``version``
diff --git a/.github/ISSUE_TEMPLATE/lain-lain.md b/.github/ISSUE_TEMPLATE/lain-lain.md
index 8d8e1ce0..3015ae43 100644
--- a/.github/ISSUE_TEMPLATE/lain-lain.md
+++ b/.github/ISSUE_TEMPLATE/lain-lain.md
@@ -7,11 +7,12 @@ assignees: ''
---
-## description
+## Description
-## saya menggunakan
-OS : ``Linux / Windows / MacOS``
+## Saya Menggunakan
+
+OS : ``Linux / Windows / MacOS``
Python: ``version``
## tambahan lainnya
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 766258c6..fb7d97e3 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,26 +1,29 @@
-# Deskripsi (Description)
+## Deskripsi (Description)
-
-# Checklist:
-##### Umum:
+## Checklist:
+### Umum:
+
- [ ] Saya menambah algoritma terbaru.
- [ ] Saya memperbaiki algoritma yang sudah ada.
- [ ] Saya memperbaiki dokumentasi.
- [ ] Saya menambah dokumentasi.
-##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain:
+### Contributor Requirements (Syarat Kontributor) dan Lain-Lain:
+
- [ ] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/PythonAlgorithm/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat.
- [ ] Saya telah menambahkan docstring yang memberikan penjelasan maksud dari kode yang saya buat.
- [ ] Saya menggunakan bahasa Indonesia untuk memberikan penjelasan dari kode yang saya buat.
-##### Unit Testing dan Linting:
+### Unit Testing dan Linting:
+
- [ ] pytest
- [ ] flake8
-# Environment
-Saya menggunakan (I'm using):
+## Environment
+Saya menggunakan (I'm using):
+
- ``os`` = ``linux / windows / macOS``
- ``python`` = ``python3 -V (unix) / py -3 -V (Windows-Python launcher)``
diff --git a/.github/workflows/automerge.yml b/.github/workflows/automerge.yml
deleted file mode 100644
index 4359d062..00000000
--- a/.github/workflows/automerge.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-name: automerge
-on:
- pull_request:
- types:
- - labeled
- - unlabeled
- - synchronize
- - opened
- - edited
- - ready_for_review
- - reopened
- - unlocked
- pull_request_review:
- types:
- - submitted
- check_suite:
- types:
- - completed
- status: {}
-jobs:
- automerge:
- runs-on: ubuntu-latest
- steps:
- - name: automerge
- uses: "pascalgn/automerge-action@v0.14.2"
- env:
- GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 00000000..ebcada9a
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+ push:
+ branches: [ "main" ]
+ pull_request:
+ branches: [ "main" ]
+ schedule:
+ - cron: "7 14 * * 3"
+
+jobs:
+ analyze:
+ name: Analyze
+ runs-on: ubuntu-latest
+ permissions:
+ actions: read
+ contents: read
+ security-events: write
+
+ strategy:
+ fail-fast: false
+ matrix:
+ language: [ python ]
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v3
+
+ - name: Initialize CodeQL
+ uses: github/codeql-action/init@v2
+ with:
+ languages: ${{ matrix.language }}
+ queries: +security-and-quality
+
+ - name: Autobuild
+ uses: github/codeql-action/autobuild@v2
+
+ - name: Perform CodeQL Analysis
+ uses: github/codeql-action/analyze@v2
+ with:
+ category: "/language:${{ matrix.language }}"
diff --git a/.github/workflows/directory.yml b/.github/workflows/directory.yml
new file mode 100644
index 00000000..f1991591
--- /dev/null
+++ b/.github/workflows/directory.yml
@@ -0,0 +1,20 @@
+name: directory_writer
+on: [push]
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-python@v5
+ - name: Write DIRECTORY.md
+ run: |
+ chmod +x scripts/build_directory_md.py
+ scripts/build_directory_md.py 2>&1 | tee DIRECTORY.md
+ git config --global user.name github-actions
+ git config --global user.email 'bellshdae07@gmail.com'
+ git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+ - name: Update DIRECTORY.md
+ run: |
+ git add DIRECTORY.md
+ git commit -am "docs: update DIRECTORY.md" || true
+ git push --force origin HEAD:$GITHUB_REF || true
diff --git a/.github/workflows/pythonapp.yml b/.github/workflows/pythonapp.yml
deleted file mode 100644
index c78c67c0..00000000
--- a/.github/workflows/pythonapp.yml
+++ /dev/null
@@ -1,67 +0,0 @@
-# doctesting untuk testing python
-# jika pull request fail dengan python testing
-# akan di review oleh contributor
-# jika tidak ada perubahan maka pull request akan ditutup
-
-name: python testing
-on:
- push:
- branches: [ main ]
- pull_request:
- branches: [ main ]
-
-jobs:
- build:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - name: Set up Python 3.9
- uses: actions/setup-python@v2
- with:
- python-version: 3.9
- - name: salam
- run: |
- echo "Halo!"
- echo "Mulai testing..."
- echo "harap tunggu sebentar... :)"
- - name: Install dependencies
- run: |
- echo "Mulai jalankan install requirement"
- python -m pip install --upgrade pip
- pip install -r requirements.txt -r dev-requirements.txt
- - name: Format otomatis
- run: |
- echo "Mulai format otomatis"
- isort . --profile=black
- black .
- - name: Test Python
- run: |
- echo "Mulai Jalankan testing docstring"
- pytest . --doctest-modules --ignore=Basic/
- - name: Test Lint Python
- run: |
- echo "Mulai Jalankan testing flake8"
- flake8 .
- - name: Test mypy
- run: |
- echo "Mulai Jalankan testing mypy"
- mypy .
- - name: Cek modifikasi file
- id: git-check
- run: echo ::set-output name=modified::$(if git diff-index --quiet HEAD --; then echo "tidak"; else echo "ya"; fi)
- - name: Push perubahan
- if: steps.git-check.outputs.modified == 'ya' && github.event_name == 'push'
- run: |
- git config --global user.name 'github-actions[bot]'
- git config --global user.email '41898282+github-actions[bot]@users.noreply.github.com'
- git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}
- git commit -am "style: format otomatis dengan black dan isort"
- git push
- - name: Test coverage
- run: |
- echo "Mulai testing coverage"
- coverage run --source . -m pytest --doctest-modules --ignore=Basic/
- - name: Hasil coverage
- run: |
- echo "Laporan coverage"
- coverage report -m
diff --git a/.github/workflows/uv_test.yml b/.github/workflows/uv_test.yml
new file mode 100644
index 00000000..036b8843
--- /dev/null
+++ b/.github/workflows/uv_test.yml
@@ -0,0 +1,36 @@
+name: uv python test
+
+on:
+ pull_request:
+ branches: [main]
+
+jobs:
+ build:
+ # menjalankan testing dengan 3 os yaitu
+ # linux (ubuntu), windows, dan macOS
+ runs-on: ${{ matrix.os }}
+
+ strategy:
+ matrix:
+ os: [macos-latest, windows-latest, ubuntu-latest]
+
+ steps:
+ - name: Checkout Code
+ uses: actions/checkout@v4
+
+ - name: Install uv
+ uses: astral-sh/setup-uv@v5
+
+ - name: Setting python
+ uses: actions/setup-python@v5
+ with:
+ python-version-file: ".python-version"
+
+ - name: install depedencies
+ run: uv add -r dev-requirements.txt
+
+ - name: run testing
+ run: |
+ uv add pre-commit
+ uv run pre-commit install
+ uv run pre-commit run --all-files
diff --git a/.gitignore b/.gitignore
index ccfe9b59..3d9b757c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
# direktori hasil cache testing
# akan di ignore oleh git
# agar tidak ikut dalam proses git push
+.vscode
env/*
__pycache__/
.vscode/
diff --git a/.gitpod.yml b/.gitpod.yml
new file mode 100644
index 00000000..aa75427e
--- /dev/null
+++ b/.gitpod.yml
@@ -0,0 +1,2 @@
+tasks:
+ - init: pip3 install -r requirements.txt
\ No newline at end of file
diff --git a/.mergify.yml b/.mergify.yml
new file mode 100644
index 00000000..b5417ece
--- /dev/null
+++ b/.mergify.yml
@@ -0,0 +1,63 @@
+pull_request_rules:
+ # membuat requirement dari automerge dengan sistem
+ # ketika workflow build passed maka akan dicentang
+ # ketika target pull request ke main maka akan dicentang
+ # ketika dikasih label 'ready-to-merge' akan dicentang
+
+ # ketika requirement telah terpenuhi maka bot akan bekerja
+ # dan pull request secara otomatis akan merge
+ - name: ci testing kalo sukses ke squash dengan label
+ conditions:
+ - base=main
+ - label=ready-to-merge
+ actions:
+ # menambahkan komentar jika sudah di merge
+ comment:
+ message: terima kasih atas kontribusinya @{{author}} !
+ # menambahkan label jika sudah di merge
+ label:
+ add:
+ - sudah dirieview!
+ # metode sistem dari automerge
+ merge:
+ method: squash
+
+ # membuat label dengan kondisi jika di dalam pull request
+ # terdapat file python
+ - name: python label
+ conditions:
+ - or:
+ - body~=(?m)^\[X\] Saya menambah algoritma terbaru.
+ - body~=(?m)^\[X\] Saya membperbaiki algoritma yang sudah ada.
+ - files~=\.py$
+ actions:
+ # menambahkan label 'python files'
+ # dan label 'request tim python untuk review'
+ label:
+ add:
+ - python files
+ - request tim python untuk review
+
+ # membuat label dengan kondisi jika di dalam pull request
+ # terdapat file markdown
+ - name: markdown label
+ conditions:
+ - or:
+ - body~=(?m)^\[X\] Saya menambah algoritma terbaru.
+ - body~=(?m)^\[X\] Saya membperbaiki algoritma yang sudah ada.
+ - files~=\.md$
+ actions:
+ # menambahkan label 'markdown files'
+ label:
+ add:
+ - markdown files
+
+ # membuat sistem bot me mention python team untuk meriview
+ # dari pull request dengan kondisi jika terdapat file python
+ - name: review docs team untuk file markdown
+ conditions:
+ - label=python files
+ actions:
+ request_reviews:
+ teams:
+ - "@bellshade/python-team"
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..2b977db8
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,30 @@
+repos:
+ - repo: https://github.com/pre-commit/pre-commit-hooks
+ rev: v4.6.0
+ hooks:
+ - id: check-executables-have-shebangs
+ - id: check-yaml
+ - id: end-of-file-fixer
+ types: [python]
+ - id: requirements-txt-fixer
+
+ - repo: https://github.com/MarcoGorelli/auto-walrus
+ rev: 0.3.4
+ hooks:
+ - id: auto-walrus
+
+ - repo: https://github.com/psf/black
+ rev: 24.4.2
+ hooks:
+ - id: black
+
+ - repo: https://github.com/PyCQA/flake8
+ rev: 7.1.0
+ hooks:
+ - id: flake8
+ args:
+ - --exclude=Basic
+ - --ignore=E203,W503,F401,W504,F821,F841,E741,E721
+ - --max-complexity=25
+ - --max-line-length=100
+
diff --git a/.python-version b/.python-version
new file mode 100644
index 00000000..24ee5b1b
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/Basic/01_introduction/README.md b/Basic/01_introduction/README.md
new file mode 100644
index 00000000..d8b932a6
--- /dev/null
+++ b/Basic/01_introduction/README.md
@@ -0,0 +1,44 @@
+# Python
+
+
+
+
+
+Selamat datang di pemrograman Python dasar. Di sini kalian dapat memulai serta mencoba pertama kali pemrograman Python.
+
+Daftar Isi
+
+- Introduction
+ - [Daftar Isi](#1)
+ - [Gambaran Singkat](#2)
+ - [Contoh Hello World](#3)
+
+Gambaran Singkat Tentang Bahasa Pemrograman Python
+
+Python dibuat dan dikembangkan oleh [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), programmer yang berasal dari Belanda. Python dibuat dengan menggunakan bahasa pemrograman C sebagai basisnya. Pemilihan nama Python itu sendiri diambil dari sebuah acara televisi yang lumayan terkenal yang bernama **Monty Python’s Flying Circus** yang merupakan acara sirkus favorit dari Guido.
+
+Python adalah bahasa pemograman multiparadigma, yaitu mendukung pemograman berorientasi objek, pemograman terstruktur, dan pemrograman fungsional.
+
+Kelebihan Python antara lain:
+
+- Mudah untuk dipelajari,
+- Mudah digunakan,
+- Mendukung **iot** (**internet of things**),
+- **Multiplatform**, artinya dapat dijalan di berbagai jenis sistem.
+
+Contoh implementasi dari bahasa pemograman Python adalah:
+
+- Komputasi ilmiah dan numerik contohnya seperti [SciPy](https://scipy.org/),
+- Aplikasi bisnis seperti [Tryton](https://www.tryton.org/),
+- Pembuatan game seperti [Battlefield 2](https://en.wikipedia.org/wiki/Battlefield_2),
+- Pengembangan web seperti [Django](https://www.djangoproject.com) atau [Flask](https://flask.palletsprojects.com),
+- Pengembangan dari situs web dan layanan sperti [Dropbox](https://www.dropbox.com), [BuzzFeed](https://www.buzzfeed.com) dan [Uber](https://www.uber.com).
+
+Contoh `Hello World` pada python
+
+```python
+print("hello bellshade")
+print("apa kabar ?")
+```
+
+[Materi Selanjutnya ▶ [tipe data]](../02_tipe_data)
diff --git a/Basic/02_tipe_data/README.md b/Basic/02_tipe_data/README.md
new file mode 100644
index 00000000..affa8fcf
--- /dev/null
+++ b/Basic/02_tipe_data/README.md
@@ -0,0 +1,171 @@
+[Introduction] ◀ Materi Sebelumnya
+
+
+
+# Tipe Data
+
+
+
+Daftar Isi
+
+- Tipe Data
+ - [Daftar Isi](#1)
+ - [Pendahuluan](#2)
+ - [String | `str`](#3)
+ - [Integer | `int`](#4)
+ - [Float | `float`](#5)
+ - [Complex | `complex`](#6)
+ - [List | `list`](#7)
+ - [Tuple | `tuple`](#8)
+ - [Set | `set`](#9)
+ - [FrozenSet | `frozenset`](#10)
+ - [Dictionary | `dict`](#11)
+ - [Bytes | `bytes`](#12)
+ - [ByteArray | `bytearray`](#13)
+ - [MemoryView | `memoryview`](#14)
+- [Video penjelasan tentang tipe data](#15)
+- [Praktikum](#16)
+
+Pendahuluan
+
+Tipe data adalah klasifikasi data. Tipe data menentukan jenis sebuah variabel.
+**Variabel sendiri adalah sebuah wadah untuk menyimpan data.** Dalam penulisannya, python menganut paham `dynamic typing` yang mana dalam membuat variabel kita tidak harus menuliskan tipe datanya pula. Hal tersebut sejalan dengan tujuan python dikembangkan untuk memudahkan keterbacaan kode dan memprioritaskan pengembangan konsep dalam lebih sedikit baris kode
+
+Beberapa tipe data dalam Python:
+
+- Berupa text
+
+ - `str`
+
+ Merupakan salah satu tipe data yang berupa string, berfungsi untuk menghasilkan tipe data string seperti huruf abjad atau simbol lain.
+
+ ```python
+ nama_saya = "franklin"
+ email_saya = "benjamin@franklin"
+ ```
+
+- Berupa angka
+
+ - `int`
+
+ Merupakan salah satu tipe numerik yang sering dipakai dalam pemograman berupa bilangan bulat.
+
+ ```python
+ angka_saya = 25
+ tahun_lahir = 1945
+ ```
+
+ - `float`
+
+ Merupakan salah satu tipe numerik yang menghasilkan berupa bilangan pecahan, sangat berguna dalam menghasilkan nilai secara detail.
+
+ ```python
+ nilai_saya = 95.281724
+ nilai_teman = 30.25912
+ ```
+
+ - `complex`
+
+ Merupakan salah satu tipe data numerik yang berfungsi menghasil sebuah angka complex, contoh angka complex bisa dilihat [di sini](https://id.wikipedia.org/wiki/Bilangan_kompleks).
+
+ ```python
+ angka_kompleks_saya = complex(1.5)
+ angka_teman_saya = complex(2j)
+ ```
+
+- Berupa urutan (sekuensial)
+
+ - `list`
+
+ Tipe data list adalah tipe data koleksi yang berisi beberapa value yang terdapat dalam satu variabel. List menggunakan kurung kotak `[ ]`.
+
+ ```python
+ nama_siswa = ['woody', 'buzz', 'andy']
+ nilai_siswa = [12, 13, 14]
+ ```
+
+ - `tuple`
+
+ Tipe data tuple adalah tipe data koleksi yang berisi beberap value yang terdapat dalam satu variabel. Perbedaan di antara keduanya adalah:
+
+ - tipe data tuple jika diberi value, maka tipe data tersebut tidak dapat diubah kembali.
+ - tipe data tuple menggunakan tutup kurung biasa `()`.
+
+ ```python
+ nama_siswa = ('buzz', 'andy', 'woody')
+ nilai = (12, 13, 14)
+ ```
+
+ - `set`
+
+ Tipe data set adalah tipe data koleksi yang elemennya dapat dirubah, tidak terurut, dan bersifat unik. Sesuai dengan namanya, tipe data set memiliki operasi matematika himpunan seperti gabungan, irisan, selisih, dan lain-lain. Set menggunakan kurung kurawal `{}`.
+
+ ```python
+ nama_siswa = {'buzz', 'andy', 'woody'}
+ nilai = {12, 13, 14}
+ ```
+
+ - `frozenset`
+
+ Tipe data frozenset adalah tipe data koleksi yang mirip dengan set, yang membedakannya dengan set adalah elemen pada frozenset tidak dapat dirubah setelah frozenset dibuat.
+
+ ```python
+ nama_siswa = frozenset(['woody', 'buzz', 'andy'])
+ nilai = frozenset([12, 13, 14])
+ ```
+
+- Berupa map (kata kunci, dictionary)
+
+ - `dict`
+
+ Tipe data dict atau dictionary adalah tipe data array dimana kunci atau **key** dari array bisa berbentuk string dan angka.
+
+ ```python
+ hari = {
+ "sen": "senin",
+ "sel": "selasa",
+ "rab": "rabu"
+ }
+ ```
+
+- Berupa tipe data binary (bytes, bytearray, memoryview)
+
+ - `bytes`
+
+ Merupakan sebuah object tipe data yang berisikan array tunggal.
+
+ ```python
+ angka_saya = bytes(12)
+ angka_saya1 = bytes(300)
+ ```
+
+ - `bytearray`
+
+ Merupakan seubah object tipe data yang berisikan array byte tunggal yang tidak dapat dirubah.
+
+ ```python
+ angka_saya = bytearray(12)
+ ```
+
+ - `memoryview`
+
+ Memoryview adalah cara aman untuk mengekspos protokol buffer dengan python. Ini memungkinkan untuk mengakses buffer internal suatu objek dengan membuat objek tampilan. Memoryview mengambalikan fungsi tampilan memori daripada objek yang diberikan.
+
+ ```python
+ angka_saya = memoryview(bytes(12))
+ angka_saya1 = memoryview(bytes(1212))
+ ```
+
+Video penjelasan tentang tipe data
+
+
+
+[](https://youtu.be/b3X0CH98Y9g?list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY)
+
+
+
+Praktikum
+
+Klik link ini untuk mencoba kode python dari pembahasan kali ini. [Source code](../02_tipe_data/tipe_data.py)
+
+Materi Selanjutnya ▶ [variable]
diff --git a/Basic/02_tipe_data/tipe_data.py b/Basic/02_tipe_data/tipe_data.py
new file mode 100644
index 00000000..ec79d3ba
--- /dev/null
+++ b/Basic/02_tipe_data/tipe_data.py
@@ -0,0 +1,93 @@
+# Tipe data pada Python adalah:
+# tipe text yaitu str (string)
+# tipe angka yaitu int, float, dan complex
+# tipe data majemuk yaitu list, tuple, set, dan range
+# tipe data map yaitu dict
+
+# type() digunakan untuk memeriksa tipe data pada variabel
+
+# contoh tipe data str
+teks_string = "Halo dunia!"
+print(teks_string)
+print(type(teks_string))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data integer
+bilangan_integer = 2
+print(bilangan_integer)
+print(type(bilangan_integer))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data float
+bilangan_desimal = 3.13
+print(bilangan_desimal)
+print(type(bilangan_desimal))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari complex
+bilangan_complex_1 = complex(1.5)
+bilangan_complex_2 = complex(2j)
+print(bilangan_complex_1)
+print(bilangan_complex_2)
+print(type(bilangan_complex_1))
+print(type(bilangan_complex_2))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari list
+nama_siswa = ["andi", "buzz", "wheezy", "army"]
+print(nama_siswa)
+print(nama_siswa[1])
+print(nama_siswa[2])
+print(type(nama_siswa))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari tuple
+mahasiswa = ("suryadi", "sukoco", "sukijan", "sumarmi")
+print(mahasiswa)
+print(mahasiswa[1])
+print(mahasiswa[2])
+print(type(mahasiswa))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari set
+merk_mobil = {"ferrari", "bmw", "toyota"}
+print(merk_mobil)
+# jika code dibawah dijalankan akan error karena
+# tipe data set unsubcriptable (tidak berurutan)
+# print(merk_mobil[1])
+# jika code dibawah dijalankan akan error karena
+# tipe data set unsubcriptable (tidak berurutan)
+# print(merk_mobil[2])
+print(type(merk_mobil))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari frozzenset
+nama_desa = frozenset({"getasrejo", "karangmalang", "siti"})
+print(nama_desa)
+print(type(nama_desa))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari dict
+detail_mobil = {"merk": "ferrari", "asal": "italia"}
+print(detail_mobil)
+print(detail_mobil["merk"])
+print(detail_mobil["asal"])
+print(type(detail_mobil))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari bytes
+angka_bytes = bytes(12)
+print(angka_bytes)
+print(type(angka_bytes))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari bytearray
+angka_bytearray = bytearray(12)
+print(angka_bytearray)
+print(type(angka_bytearray))
+print() # untuk menambahkan baris baru
+
+# contoh tipe data dari memoryview
+angka_memoryview = memoryview(bytes(12))
+print(angka_memoryview)
+print(type(angka_memoryview))
diff --git a/Basic/03_variable/README.md b/Basic/03_variable/README.md
new file mode 100644
index 00000000..54119dce
--- /dev/null
+++ b/Basic/03_variable/README.md
@@ -0,0 +1,208 @@
+[tipe data] ◀ Materi Sebelumnya
+
+
+
+# Variabel
+
+
+
+Daftar Isi
+
+---
+
+- [Daftar Isi](#1)
+- [Pendahuluan](#2)
+- [Assign Variabel](#3)
+- [Penamaan Variabel](#4)
+- [Penggunaan Built-in Keyword](#5)
+- [Video Penjelasan Tentang Variabel](#6)
+- [Praktikum](#7)
+
+Pendahuluan
+
+---
+
+**Variabel adalah referensi dari sebuah value.** Variabel sering di analogikan seperti **sebuah wadah yang menampung sebuah benda.** Seperti kita ketika ingin menyimpan suatu benda, maka perlu mencari tempat / wadah benda tersebut ingin disimpan terlebih dahulu. Dalam menentukan wadah, kita hanya perlu mencantumkan nama wadah (nama variabel) terlebih dahulu. Setelah itu, python akan secara otomatis mengambilkan wadah sesuai dengan kebutuhan kita. Contoh penggunaan variabel pada Python :
+
+```python
+angka_saya = 100
+print(angka_saya)
+
+# outputnya
+# 100
+```
+
+Pada kode diatas, kita membuat sebuah variabel yang mereferensikan nilai angka `100`. Dengan penggunaan dari variabel kita bisa memanggil lebih dari sekali, misalnya:
+
+```python
+angka_saya = 20
+print(angka_saya)
+print(angka_saya)
+
+# outputnya
+# 20
+# 20
+```
+
+Assign Variabel
+
+---
+
+Kita bisa assign variable dengan variabel lainnya agar mudah untuk mendeklarasikan sebuah nilai yang sama dengan variabel yang berbeda, sebagai contoh:
+
+```python
+angka_saya = 200
+angka_lain = angka_saya
+print(angka_saya)
+print(angka_lain)
+
+# outputnya
+# 200
+# 200
+```
+
+Atau bisa juga dengan cara:
+
+```python
+angka_saya = angka_lain = angka_banyak = 200
+print(angka_saya)
+print(angka_lain)
+print(angka_banyak)
+
+# outputnya
+# 200
+# 200
+# 200
+```
+
+Contoh pada string:
+
+```python
+nama = nama_alias = "adams"
+print(nama)
+print(nama_alias)
+
+# outputnya
+# adams
+# adams
+```
+
+Penamaan Variabel
+
+---
+
+Python memiliki beberapa peraturan dalam penulisan sebuah variabel. Jika kamu ingin melihat detail aturan tersebut bisa kunjungi laman [PEP8](https://peps.python.org/pep-0008/#type-variable-names) ini. Peraturan tersebut adalah:
+
+1. Menggunakan kata tanpa didahuli dengan angka:
+
+ **contoh benar** ✅
+
+ ```python
+ nama = "bob"
+ ```
+
+ **contoh salah** ❌
+
+ ```python
+ 1nama = "bob"
+ ```
+
+2. Menggunakan underscore (garis bawah) jika ingin menggunakan kata yang panjang:
+
+ **contoh yang benar** ✅
+
+ ```python
+ angka_saya = 12
+ ```
+
+ **contoh yang salah** ❌
+
+ ```python
+ 12angka_saya = 12
+ ```
+
+3. Variabel pada python bersifat sensitif, penggunaan huruf besar dan kecil sangat diperhatikan:
+
+ contoh
+
+ ```python
+ Nama_saya = "james"
+ nama_saya = "joko"
+ print(Nama_saya)
+ print(nama_saya)
+
+ # outputnya
+ # james
+ # joko
+ ```
+
+ contoh diatas akan menghasilkan 2 nama karena variabel tersebut secara kalimat sama tapi secara penulisan berbeda, Python memperhatikan hal ini.
+
+Pada Python, penggunaan variabel disarankan menggunakan `snake_case`.
+
+Penggunaan Built-in Keyword
+
+---
+
+**Built-in keyword** pada Python adalah kata-kata yang mana sudah ditetapkan/dibuat sebelumnya oleh Python. Keyword-keyword tersebut dibuat untuk melakukan suatu perintah tertentu. Maka dari itu, dalam membuat variabel kita harus menghindari kata-kata tersebut agar program kita tidak terjadi error. Ada beberapa kata yang dilarang untuk digunakan sebagai nama variabel. Contoh penggunaan kata yang dilarang pada Python:
+
+```python
+class sma_saya = "bahasa"
+print(sma_saya)
+```
+
+Hasil esekusi diatas akan menyebabkan error karena `class` merupakan salah satu nama fungsi dari Python.
+
+Kata/keywords yang dilarang:
+
+- False
+- None
+- True
+- and
+- as
+- assert
+- break
+- class
+- continue
+- def
+- del
+- elif
+- else
+- except
+- finally
+- for
+- from
+- global
+- if
+- import
+- in
+- is
+- lambda
+- nonlocal
+- not
+- or
+- pass
+- raise
+- try
+- return
+- while
+- with
+- yield
+
+Video Penjelasan Tentang Variabel
+
+---
+
+
+
+[](https://youtu.be/gxmTFXfrMzk?list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY)
+
+
+
+Praktikum
+
+---
+
+Klik link ini untuk mencoba kode python dari pembahasan kali ini. [Source code](../03_variable/variable.py)
+
+Materi Selanjutnya ▶ [operator]
diff --git a/Basic/03_variable/string_variable.py b/Basic/03_variable/string_variable.py
new file mode 100644
index 00000000..a9494778
--- /dev/null
+++ b/Basic/03_variable/string_variable.py
@@ -0,0 +1,35 @@
+# String dalam Python diidentifikasi
+# sebagai serangkaian karakter yang berdekatan
+# yang diwakili dalam tanda kutip.
+
+# Dalam membuat variabel string kita dapat
+# menggunakan petik dua ("") / petik satu ('')
+pesan = "saya pergi ke pasar"
+
+# s a y a p e r g i
+# 0 1 2 3 4 5 5 6 7 8 9
+
+# k e p a s a r
+# 10 11 12 13 14 15 16 17
+
+# Dalam tipe data string, value dari
+# variabel tersebut akan dianggap sebagai
+# list. Maka dari kita dapat memanggil
+# setiap karakter dengan urutan index
+
+# print secara keseluruhan
+print(pesan)
+# print karakter pertama pada pesan
+print(pesan[0])
+# print karakter dari karakter ke 3 sampai 5
+print(pesan[2:5])
+# print dimulai dari karakter ke 3
+print(pesan[2:])
+# print kata 2 kali
+print(pesan * 2)
+
+
+# gabung kata dengan kata baru
+# saya pergi kepasar dengan ibu saya
+print(pesan + " dengan ibu saya")
+print(pesan, " dengan ibu saya")
diff --git a/Basic/variable/Variable.py b/Basic/03_variable/variable.py
similarity index 86%
rename from Basic/variable/Variable.py
rename to Basic/03_variable/variable.py
index 89e0255c..4202b571 100644
--- a/Basic/variable/Variable.py
+++ b/Basic/03_variable/variable.py
@@ -1,11 +1,9 @@
-# variable pada python juga
-# dan juga banyak data dan value pada python
-# contoh dasar yaitu int, float, str
-
nama = "Riskiy" # contoh tipe data string
umur = 12 # contoh tipe data integer (int)
nilai = 95.5 # nilai
+# tanda koma ',' pada print digunakan untuk
+# menambahkan nilai variabel ke perintah print
print("Dia bernama ", nama)
print("Dia baru berumur ", umur, " tahun")
print("dan dia mendapatkan nilai ", nilai)
@@ -17,6 +15,7 @@
# contoh penggunaan variable yang baik
# nama_lengkap = "jhon lenon"
# nama_lengkap2 = "jhon lenin"
+# nama_lengkap_2 = "jhon lenan"
# contoh inisiasi beberapa variable
# dalam satu line
diff --git a/Basic/04_operator/README.md b/Basic/04_operator/README.md
new file mode 100644
index 00000000..f7939ac6
--- /dev/null
+++ b/Basic/04_operator/README.md
@@ -0,0 +1,343 @@
+[variable] ◀ Materi Sebelumnya
+
+
+
+# Operator
+
+
+
+Daftar Isi
+
+---
+
+- [Daftar Isi](#1)
+- [Pendahuluan](#2)
+- [Operator Aritmatika](#3)
+- [Operator Penugasan](#4)
+- [Operator Perbandingan](#5)
+- [Operator Logika](#6)
+- [Operator Keanggotaan](#7)
+- [Operator Identitas](#8)
+- [Operator Bitwise](#9)
+- [Video Penjelasan Tentang Variabel](#10)
+- [Praktikum](#11)
+
+Pendahuluan
+
+---
+
+**Operator digunakan untuk melakukan operasi pada variabel atau value.** Dengan operator kita dapat memanipulasi nilai dari operan berdasarkan operator yang kita masukkan seperti `2+3` yang mana angka `2` dan `3` merupakan `operand` dan `+` merupakan `operator` untuk fungsi penjumlahan.
+
+Python memiliki beberapa jenis operator yaitu:
+
+- [Operator Aritmatika](#3)
+- [Operator Penugasan](#4)
+- [Operator Perbandingan](#5)
+- [Operator Logika](#6)
+- [Operator Keanggotaan](#7)
+- [Operator Identitas](#8)
+- [Operator Bitwise](#9)
+
+Operator Aritmatika
+
+---
+
+Operator aritmatika adalah operator yang digunakan untuk melakukan operasi matematika seperti penjumlahan, pengurangan, perkalian, pembagian di antara value atau variabel.
+
+Sebagai contoh operasi pertambahan:
+
+```python
+angka = 2
+angka_kedua = 3
+
+print(angka + angka_kedua)
+
+# outputnya
+# 5
+```
+
+Operasi tersebut menambahkan kedua variabel yang memiliki value yaitu 2 dan 3.
+
+Berikut table dari operator aritmatika:
+
+| operator | nama operator | contoh penggunaan |
+| -------- | ------------- | ----------------- |
+| + | penambahan | a + b |
+| - | pengurangan | a - b |
+| \* | perkalian | a \* b |
+| / | pembagian | a / b |
+| \* \* | perpangkatan | a \*\* b |
+| % | modulus | a % b |
+| // | floor | a // b |
+
+```py
+print(6+2) # 8
+print(6-2) # 4
+print(6*2) # 12
+print(6/2) # 3.0
+print(6**2) # 36
+print(5%2) # 1
+print(10//3) # 3
+```
+
+Operator Penugasan
+
+---
+
+Operator penugasan adalah operator yang digunakan untuk menetapkan suatu bilangan ke dalam variabel.
+
+Sebagai contoh operasi penugasan:
+
+```python
+nilai = 5
+nilai += 3
+# operator tersebut sama dengan
+# nilai = nilai + 3
+
+print("nilai adalah", nilai) #8
+```
+
+Operasi tersebut menambahkan sekaligus menetapkan ke dalam variabel nilai.
+
+Berikut tabel dari operasi penugasan:
+
+| Operator | Example | Sama Dengan | Hasil (jika x=5) |
+| -------- | ----------- | -------------- | :--------------: |
+| = | x = 5 | x = 5 | 44 |
+| += | x += 3 | x = x + 3 | 8 |
+| -= | x -= 3 | x = x - 3 | 2 |
+| \*= | x \*= 3 | x = x \* 3 | 15 |
+| /= | x /= 3 | x = x / 3 | 1.67 |
+| %= | x %= 3 | x = x % 3 | 2 |
+| //= | x //= 3 | x = x // 3 | 1 |
+| \*\*= | x \*\*= 3 | x = x \*\* 3 | 125 |
+| &= | x &= 3 | x = x & 3 | 1 |
+| |= | x |= 3 | x = x | 3 | 7 |
+| ^= | x ^= 3 | x = x ^ 3 | 6 |
+| <<= | x <<= 3 | x = x << 3 | 40 |
+| >>= | x >>= 3 | x = x >> 3 | 0 |
+
+Operator Perbandingan
+
+---
+
+Operator perbandingan adalah operator yang digunakan untuk membandingkan suatu nilai dengan nilai yang lain.
+
+Sebagai contoh operasi perbandingan:
+
+```python
+print(2 < 3) # True
+```
+
+Operasi tersebut membandingkan apakah nilai pertama lebih kecil daripada nilai kedua.
+
+Berikut tabel dari operasi perbandingan:
+
+| Operator | Artinya |
+| -------- | --------------------------------- |
+| == | Sama Dengan |
+| != | Tidak Sama Dengan |
+| > | Lebih besar dari |
+| < | Lebih Kecil dari |
+| >= | Lebih Besar dari atau sama dengan |
+| <= | Lebih Kecil dari atau sama dengan |
+
+```py
+print(2 < 3) # True
+print(2 > 3) # False
+print(2 <= 3) # True
+print(2 >= 3) # False
+print(2 == 3) # False
+print(2 != 3) # True
+```
+
+Operator Logika
+
+---
+
+Operator logika adalah operator yang digunakan untuk mengecek apakah sebuah penyataan bernilai True atau False.
+
+Sebagai contoh operasi logika:
+
+```python
+print(3 < 5 and 5 > 3) # True
+```
+
+Operasi tersebut mengecek apakah kedua nilai yang dicek memiliki nilai True.
+
+Berikut tabel dari operasi logika:
+
+| Operator | Penjelasan |
+| -------- | ------------------------------------------------------------------ |
+| and | Mengembalikan nilai True jika kedua nilai memiliki nilai True |
+| or | Mengembalikan nilai True jika salah satu nilai memiliki nilai True |
+| not | Membalikkan hasil, mengembalikan False jika hasilnya True |
+
+```py
+print(True and True) # True
+print(True and False) # False
+print(False and False) # False
+print(True or True) # True
+print(True or False) # True
+print(False or False) # False
+print((True and not True)) # False
+print(True or not False) # True
+print(False and not False) # False
+```
+
+Operator Keanggotaan
+
+---
+
+Operator keanggotaan adalah operator yang digunakan untuk memvalidasi anggota di dalam sebuah kumpulan data.
+
+Contoh operasi keanggotaan:
+
+```python
+list_bahasa_pemrograman = ["javascript", "java", "Python", "Dart"]
+print("Python" in list_bahasa_pemrograman) # True
+print("Indonesia" in list_bahasa_pemrograman) # False
+```
+
+Operasi tersebut memvalidasi apakah `"Python"` ada di dalam list `list_bahasa_pemrograman`.
+
+Berikut tabel dari operasi keanggotaan:
+
+| Operator | Penjelasan |
+| -------- | ---------------------------------------------------------------------------- |
+| in | Mengembalikan nilai True jika nilai yang disebutkan ada di dalam objek |
+| not in | Mengembalikan nilai True jika nilai yang disebutkan tidak ada di dalam objek |
+
+Operator Identitas
+
+---
+
+Operator identitas adalah operator yang digunakan untuk membandingkan suatu data. Jika data bernilai sama dan memiliki memori yang sama, maka akan mengembalikan nilai True.
+
+Contoh dari operasi identitas:
+
+`contoh 1`
+
+```python
+x = 3
+y = 7
+
+print(x is y) # False
+print(x is not y) # True
+```
+
+Hasil:
+
+```
+>> Tidak sama
+```
+
+Karena nilai dari variabel `x` dan `y` tidak memilki nilai dan memori yang sama.
+
+`contoh 2`
+
+```python
+if (type(y) != int):
+ print("Ini bukan integer")
+else:
+ print("Ini adalah integer")
+```
+
+Hasil:
+
+```
+>> Ini adalah integer
+```
+
+Karena tipe data yang digunakan pada variabel `y` adalah `integer`, bukan string ataupun tipe data lainnya.
+
+Berikut tabel dari operasi identitas:
+
+| Operator | Penjelasan |
+| -------- | --------------------------------------------------------------------------------------------- |
+| is | Mengembalikan nilai True jika nilai yang disebutkan memiliki objek dan memori yang sama |
+| is not | Mengembalikan nilai True jika nilai yang disebutkan tidak memiliki objek dan memori yang sama |
+
+Operator Bitwise
+
+---
+
+Operator bitwise digunakan untuk melakukan operasi bilangan biner. Bilangan bulat pertama diubah menjadi biner dan kemudian operasi dilakukan pada bit demi bit, maka nama operator bitwise. Kemudian hasilnya dikembalikan dalam format desimal.
+
+Contoh dari **bitwise not operator**:
+
+```python
+angka_saya = 10
+print(~a)
+```
+
+Hasilnya:
+
+```bash
+-11
+```
+
+Penjelasannya sebagai berikut:
+
+```
+angka_saya = 10 = 1010
+~a = ~1010
+ = -(1010 + 1)
+ = -(1011)
+ = -11
+```
+
+Contoh dari **bitwise right**:
+
+```python
+angkat_saya = 10
+print(angka_saya >> 1)
+```
+
+Hasilnya:
+
+```bash
+5
+```
+
+```
+angka_saya = 10 = 0000 1010
+a >> 1 = 0000 0101 = 5
+```
+
+Berikut tabel dari operasi identitas:
+
+| operator | deskripsi | sintaks |
+| :------- | ------------------- | ------: |
+| & | Bitwise AND | x & y |
+| \| | Bitwise OR | x \| y |
+| ~ | Bitwise NOT | ~x |
+| ^ | Bitwise XOR | x ^ y |
+| >> | Bitwise right shift | x>> |
+| << | Bitwise left shift | x<< |
+
+Video Penjelasan Tentang Variabel
+
+---
+
+[](https://youtu.be/RoDGGTWbKK4?list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY)
+[](https://www.youtube.com/watch?v=49KDyhzgCmA&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=15)
+[](https://www.youtube.com/watch?v=Kv_lDWq8kCc&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=11)
+[](https://www.youtube.com/watch?v=Sl7zqPpC2VI&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=12)
+[](https://www.youtube.com/watch?v=-VrqfCGwr88&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=14)
+
+Praktikum
+
+---
+
+Klik link dibawah untuk mencoba kode python dari pembahasan kali ini.
+
+- [Operator Aritmatika](operator_aritmatika.py)
+- [Operator Penugasan](operator_penugasan.py)
+- [Operator Komparasi](operator_perbandingan.py)
+- [Operator Logika](operator_logika.py)
+- [Operator Identitas](operator_identitas.py)
+- [Operator Bitwise](operator_bitwise.py)
+- [Operator Keanggotaan](operator_keanggotaan.py)
+
+Materi Selanjutnya ▶ [String]
diff --git a/Basic/operator/operator_aritmatika.py b/Basic/04_operator/operator_aritmatika.py
similarity index 98%
rename from Basic/operator/operator_aritmatika.py
rename to Basic/04_operator/operator_aritmatika.py
index e8784b96..8b5cc953 100644
--- a/Basic/operator/operator_aritmatika.py
+++ b/Basic/04_operator/operator_aritmatika.py
@@ -35,7 +35,7 @@
print(100 % 5)
# operator perpangkatan
-print(4 ** 2)
+print(4**2)
# operator floor division
# mengambil nilai utama dari suatu pembagian
diff --git a/Basic/04_operator/operator_bitwise.py b/Basic/04_operator/operator_bitwise.py
new file mode 100644
index 00000000..73e2819d
--- /dev/null
+++ b/Basic/04_operator/operator_bitwise.py
@@ -0,0 +1,18 @@
+angka_saya = 30
+angka_saya1 = 6
+
+print("operator bitwise")
+print("angka_saya & angka =", angka_saya & angka_saya1)
+print("angka_saya | angka =", angka_saya | angka_saya1)
+print("angka_saya ^ angka =", angka_saya ^ angka_saya1)
+print("~angka_saya =", ~angka_saya)
+
+
+print("\noperator bitwise left and right")
+angka_lain = 30
+angka_lain1 = -30
+print("angka_lain = 30 >> 1 =", angka_lain >> 1)
+print("angka_lain1 = -30 >> 1 =", angka_lain1 >> 1)
+
+print("angka lain = 30 << 1 =", angka_lain << 1)
+print("angka_lain1 = -30 << 1 =", angka_lain1 << 1)
diff --git a/Basic/04_operator/operator_identitas.py b/Basic/04_operator/operator_identitas.py
new file mode 100644
index 00000000..a5a38ccb
--- /dev/null
+++ b/Basic/04_operator/operator_identitas.py
@@ -0,0 +1,28 @@
+# Operator Identitas adalah operator yang digunakan
+# untuk membandingkan suatu object. Jika object bernilai sama
+# dan memiliki memori yang sama, maka akan mengembalikan nilai True.
+# contoh:
+
+
+# variabel
+x = 3
+y = 7
+
+# cek apakah nilai dari variabel x dan y ada pada memori yang sama
+# jika x is y, maka cetak "Sama"
+# lain jika x is not y, maka cetak "Tidak sama"
+
+if x is y:
+ print("Sama")
+elif x is not y:
+ print("Tidak sama")
+print("\n")
+
+
+# jika tipe data y bukan integer, maka cetak "Ini bukan integer"
+# jika tidak, maka cetak "Ini adalah integer"
+
+if type(y) != int:
+ print("Ini bukan integer")
+else:
+ print("Ini adalah integer")
diff --git a/Basic/04_operator/operator_keanggotaan.py b/Basic/04_operator/operator_keanggotaan.py
new file mode 100644
index 00000000..2eef5ffa
--- /dev/null
+++ b/Basic/04_operator/operator_keanggotaan.py
@@ -0,0 +1,12 @@
+# Operator Keanggotaan (Membership Operator) adalah operator
+# yang memvalidasi anggota dari sebuah objek iterable
+# contoh:
+
+
+X = [1, 2, "3", 4, "lima"]
+
+# memvalidasi "3" didalam variable "X"
+print("3" in X) # True
+
+# memvalidasi 1 tidak didalam variable "X"
+print(1 not in X) # False
diff --git a/Basic/04_operator/operator_logika.py b/Basic/04_operator/operator_logika.py
new file mode 100644
index 00000000..f489bf18
--- /dev/null
+++ b/Basic/04_operator/operator_logika.py
@@ -0,0 +1,29 @@
+# operator logika (Logical Operator) digunakan untuk
+# menggabungkan pernyataan kondisional
+# bingung?
+# mari kita buat contohnya
+
+
+# variabel
+X = 5
+
+# operator "and" digunakan untuk mengecek
+# apakah kedua pernyataan yang diberikan bernilai True
+
+print("X < 6 and X > 1:", X < 6 and X > 1) # True
+print("X > 6 and X > 1:", X > 6 and X > 1) # False
+
+# operator "or" digunakan untuk mengecek
+# apakah salah satu dari dua pernyataan bernilai True
+
+print("X > 6 or X > 1:", X > 6 or X > 1) # True
+print("X > 6 or X < 1:", X > 6 or X < 1) # False
+
+# operator "not" digunakan untuk mengecek
+# apakah nilai tersebut bernilai False
+
+X_UNDER_6 = X < 6
+X_ABOVE_10 = X > 10
+
+print(not X_UNDER_6) # False
+print(not X_ABOVE_10) # True
diff --git a/Basic/operator/operator_penugasan.py b/Basic/04_operator/operator_penugasan.py
similarity index 100%
rename from Basic/operator/operator_penugasan.py
rename to Basic/04_operator/operator_penugasan.py
diff --git a/Basic/04_operator/operator_penugasan_ekspresi.py b/Basic/04_operator/operator_penugasan_ekspresi.py
new file mode 100644
index 00000000..d98d6c0f
--- /dev/null
+++ b/Basic/04_operator/operator_penugasan_ekspresi.py
@@ -0,0 +1,57 @@
+"""
+Operator Walrus
+=== versi Python yang didukung: 3.8+ ===
+
+Operator Walrus adalah operator jenis Assignment Expression
+yang merupakan operator baru yang ditambahkan pada Python versi ke 3.8
+
+Fungsi dari operator Walrus ini adalah melakukan pengisian
+sekaligus mengembalikan nilai dan mempersingkat sintaks program
+
++------------+--------------+-----------------+
+| Simbol | Contoh | Sama Dengan |
+|------------|--------------|-----------------|
+| := | walrus := 5 | walrus = 5 |
+| | | return walrus |
++------------+--------------+-----------------+
+"""
+
+# Contoh dibawah ini dapat dilihat perbedaannya jika melalui CLI Python
+# Tidak akan mengembalikan nilai, hanya melakukan pengisian
+# walrus = False
+
+
+# Akan mengembalikan nilai,
+# operator walrus melakukan pengisian nilai sekaligus mengembalikan nilai
+# Walrus digunakan pada if statement,
+# Maka dari itu jika digunakan sebagai assignment harus diberi tanda kurung ()
+# Agar tidak memunculkan SyntaxError
+# (walrus2 := True)
+
+
+# Misal dibuat fungsi sederhana func()
+def func(num):
+ return num + 1
+
+
+# Jika tanpa walrus, agar tidak duplikat maka fungsi func() dimasukkan ke variabel
+# x = func(4)
+# if x >= 5:
+# print(x)
+
+
+# Jika memakai operator Walrus maka bisa langsung dipakai pada if statement
+# Di bawah ini adalah contoh yang salah
+# Mengembalikan nilai True
+# Karena terbaca x di assign 5 >= 5
+# if x := func(4) >= 5:
+# print(x)
+
+
+# Di bawah ini adalah contoh yang benar
+# Mengembalikan nilai 5
+# x akan diisi nilai dari func(4)
+# Lalu dicek apakah lebih dari sama dengan 5
+# Terakhir akan print nilai dari x
+if (x := func(4)) >= 5:
+ print(x)
diff --git a/Basic/operator/operator_perbandingan.py b/Basic/04_operator/operator_perbandingan.py
similarity index 99%
rename from Basic/operator/operator_perbandingan.py
rename to Basic/04_operator/operator_perbandingan.py
index b70dbf45..63bd8887 100644
--- a/Basic/operator/operator_perbandingan.py
+++ b/Basic/04_operator/operator_perbandingan.py
@@ -1,6 +1,5 @@
# Operator Perbandingan (Comparison Operator) digunakan untuk
# Membadingkan antara dua nilai
-
# contoh
# Variable
diff --git a/Basic/05_string/README.md b/Basic/05_string/README.md
new file mode 100644
index 00000000..614732c3
--- /dev/null
+++ b/Basic/05_string/README.md
@@ -0,0 +1,158 @@
+[Operator] ◀ Materi Sebelumnya
+
+
+
+# String
+
+
+
+Daftar Isi
+
+---
+
+- [Daftar Isi](#1)
+- [Pendahuluan](#2)
+- [Deklarasi Variabel String](#3)
+- [Deklarasi Variabel Multistring](#4)
+- [Mencetak String](#5)
+- [Method String Bawaan](#6)
+ - [`upper()`](#7)
+ - [`lower()`](#8)
+ - [Substring String](#9)
+ - [`len()`](#10)
+ - [`in` Keyword](#11)
+- [Video Penjelasan Tentang String](#12)
+- [Praktikum](#13)
+
+Pendahuluan
+
+---
+
+Seperti yang dijelaskan pada materi sebelumnya [(tipe data)](../02_tipe_data/), string adalah salah satu tipe data pada Python yang berfungsi untuk menyimpan huruf abjad atau simbol lain. Penggunaan string sangat diperlukan ketika kita ingin menyimpan data seperti alamat, nama dll. Seperti pada materi sebelumnya di [tipe data](../02_tipe_data/), pendeklarasian variabel dengan tipe data string dapat dilakukan dengan cara seperti berikut :
+
+Deklarasi Variabel String
+
+---
+
+```python
+kata_pertama = "warung"
+# String juga dapat ditulis menggunakan petik satu
+# Namun hal tersebut TIDAK DISARANKAN
+```
+
+Deklarasi Variabel Multistring
+
+---
+
+String juga dapat dideklarasikan dengan cara berikut:
+
+```python
+kata_saya = """Indonesia adalah negara yang indah
+berada di bawah garis khatulistiwa
+aku cinta Indonesia
+"""
+```
+
+Mencetak String
+
+---
+
+```python
+print(kata_saya)
+
+# outputnya
+# Indonesia adalah negara yang indah
+# berada di bawah garis khatulistiwa
+# aku cinta Indonesia
+```
+
+Method String Bawaan
+
+---
+
+**Dalam membuat program, manipulasi string sangat diperlukan karena tidak semua nilai string yang kita dapatkan sesuai dengan yang kita inginkan.** Maka dari itu dibutuhkan sebuah tindakan untuk mengubah atau memanipulasi string tersebut. Dalam Python, terdapat beberapa method bawaan (built-in method) yang bisa kita gunakan untuk memanipulasi string antara lain seperti berikut :
+
+`upper()`
+
+---
+
+Method ini digunakan untuk mengkapitalisasi setiap karakter pada string.
+
+```python
+print(kata_pertama.upper())
+
+# outputnya
+# WARUNG
+```
+
+`lower()`
+
+---
+
+Method ini digunakan untuk membuat setiap karakter pada string menjadi huruf kecil
+
+```python
+print(kata_pertama.upper().lower())
+
+# outputnya
+# WARUNG -> warung
+```
+
+Substring String
+
+---
+
+Dalam Python, string bisa dianggap seperti kumpulan (list) dari beberapa karakter. Maka dari itu, kita dapat mengambil salah satu karakter dari string berdasarkan urutan index paling kiri.
+
+```python
+print(kata_pertama[0])
+
+# outputnya
+# w
+```
+
+`len()`
+
+---
+
+Method ini digunakan untuk menghitung jumlah karatker dari string
+
+```python
+print(len(kata_pertama))
+
+# outputnya
+# 6
+```
+
+`in` Keyword
+
+---
+
+`in` merupakan salah satu keyword dalam Python yang digunakan utnuk mengecek kata khusus dalam sebuah string
+
+```python
+print("Indonesia" in kata_saya)
+print("Indonesia" in "one")
+
+# outputnya
+# False
+# True
+# Perlu diperhatikan penggunaan keyword `in` harus
+# memperhatikan besar kecil huruf (case sensitive)
+```
+
+Jika kamu ingin mempelajari mengenai method-method string apa saja yang dapat kita gunakan. Anda dapat langsung melihat pada materi [manipulasi string](../11_manipulasi_string/)
+
+Video Penjelasan Tentang String
+
+---
+
+[](https://www.youtube.com/watch?v=fhAEh1Z9YuY&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=16)
+
+Praktikum
+
+---
+
+Klik link dibawah untuk mencoba kode python dari pembahasan kali ini. [Source code](../05_string/string_python.py)
+
+Materi Selanjutnya ▶ [Input Output]
diff --git a/Basic/string_python.py b/Basic/05_string/string_python.py
similarity index 68%
rename from Basic/string_python.py
rename to Basic/05_string/string_python.py
index ad810092..c58b49d2 100644
--- a/Basic/string_python.py
+++ b/Basic/05_string/string_python.py
@@ -3,14 +3,17 @@
# contoh
# "Hello World" sama dengan 'hello world'
# 'hello world' sama dengan "hello world"
+# Namun disarankan menggunakan petik dua
+# dalam deklarasi python
+
kata_pertama = "warung"
# bisa juga menggunakan multi string
# bisa menggunakan 3 tanda petik dua atau satu
-kata_saya = """indonesia adalah negara yang indah
+kata_saya = """Indonesia adalah negara yang indah
berada di bawah garis khatulistiwa
-aku cinta indonesia
+aku cinta Indonesia
"""
# print(kata_pertama)
@@ -30,6 +33,7 @@
# contoh
print(len(kata_pertama))
-# kita juga mengecek kata khusus dalam sebuah string
+# kita juga dapat mengecek kata khusus dalam sebuah string
# contoh
-print("indonesia" in kata_saya)
+print("Indonesia" in kata_saya)
+print("Indonesia" in "one") # lgtm [py/comparison-of-constants]
diff --git a/Basic/06_input_output/README.md b/Basic/06_input_output/README.md
new file mode 100644
index 00000000..fe71910e
--- /dev/null
+++ b/Basic/06_input_output/README.md
@@ -0,0 +1,60 @@
+# Input/Output Python
+
+Pada Python terdapat fungsi dimana kita bisa membuat sebuah inputan. Contohnya sebagai berikut:
+
+```python
+nama = input("masukkan nama kamu ")
+print(nama)
+```
+
+pada kode diatas jika dijalankan akan menampilkan:
+
+```bash
+masukkan nama kamu
+```
+
+Jika kita memasukkan nama maka program akan menampilkan nama yang sebelumnya kita ketik:
+
+```bash
+masukkan nama kamu
+arfy
+arfy
+```
+
+Contoh lain:
+
+```python
+nama = input("masukkan nama ")
+print("selamat pagi ", nama)
+```
+
+Maka akan menampilkan berupa ``selamat pagi nama_yang_diinputkan``. Contoh output:
+
+```bash
+masukkan nama
+arfy
+selamat pagi arfy
+```
+
+Kita juga bisa merubah value dari variabel yang sudah ada dengan menggunakan input.
+
+```python
+nama = "arfy"
+# menampikan isi value dari nama terlebih dahulu
+print(nama)
+nama = input("masukkan nama ")
+print("di variabel nama sekarang adalah ", nama)
+```
+
+Maka output yang keluar adalah:
+
+```bash
+arfy
+masukkan nama
+jole
+di variabel nama sekarang adalah jole
+```
+
+Video penjelasan tentang operator input output = [Belajar python dasar - mengambil input data dari user](https://www.youtube.com/watch?v=Ar1xxIsyuvI&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=8)
+
+[Materi Selanjutnya](../07_logika_percabangan)
\ No newline at end of file
diff --git a/Basic/input_output.py b/Basic/06_input_output/input_output.py
similarity index 89%
rename from Basic/input_output.py
rename to Basic/06_input_output/input_output.py
index 7f4244bc..c923d092 100644
--- a/Basic/input_output.py
+++ b/Basic/06_input_output/input_output.py
@@ -2,11 +2,13 @@
# memasukkan variabel secara dinamis
# output digunakan untuk
# contoh
+
+
nama = "joes"
print(nama)
# mengganti nama 'joes' menjadi sesuai user
-nama = input("masukkan nama :").strip()
+nama = input("masukkan nama :")
print(nama)
# menggunakan inputan sesuai tipe data
diff --git a/Basic/07_logika_percabangan/README.md b/Basic/07_logika_percabangan/README.md
new file mode 100644
index 00000000..75158b8d
--- /dev/null
+++ b/Basic/07_logika_percabangan/README.md
@@ -0,0 +1,49 @@
+# Logika Percabangan
+
+Logika percabangan akan mengambil dan memutuskan sesuatu dari sebuah pernyataan dan kemudian menghasilkan sebuah pernyataan jika suatu solusi dapat dipenuhi. Sebagai contoh, ``jika kamu kehujanan maka kamu menggunakan payung``, dalam contoh kodenya adalah:
+
+```python
+cuaca = "hujan"
+if cuaca == "hujan":
+ print("gunakan payung")
+```
+
+Contoh di atas merupakan contoh sederhana dari logika percabangan dimana jika cuaca hujan maka akan menggunakan payung, dan bagaimana jika value dari ``"hujan"`` kita ganti dengan cerah?.
+
+Jika kita mengganti variabelnya dari ``cuaca = "hujan"``, maka program tidak menghasilkan apapun karena tidak membuat sebuah fungsi atau operator apapun jika ``cerah``, maka untuk membuat fungsi atau operator logika agar dapat mengambil data value berupa ``jika cerah maka tidak menggunakan payung``.
+
+```python
+cuaca = "cerah"
+if cuaca == "hujan":
+ print("gunakan payung")
+# menggunakan fungsi elif
+elif cuaca == "cerah":
+ print("tidak menggunakan payung")
+```
+
+Contoh di atas merupakan contoh sederhana dari logika percabangan dimana jika cuaca cerah maka tidak menggunakan payung, dan bagaimana jika value dari ``"cerah"``, ``"hujan"`` kita ganti dengan bebas?
+
+```python
+# membuat variabel dari cuaca
+# dan membuat value "cerah"
+cuaca = "cerah"
+# logika jika cuaca hujan
+if cuaca == "hujan":
+ print("gunakan payung")
+# menggunakan fungsi elif
+# jika cuaca cerah
+elif cuaca == "cerah":
+ print("tidak menggunakan payung")
+# menggunakan else jika kedua fungsi tidak terpenhi
+# if dan elif
+else:
+ print("gunakan pakaian renang")
+```
+
+Contoh diatas merupakan contoh sederhana dari logika percabangan dimana jika selain dari cuaca hujan dan cerah maka menampilkan ``gunakan pakaian renang``.
+
+video penjelasan tentang logika percabangan (elif) = [Belajar python dasar - elif statement](https://www.youtube.com/watch?v=ICowoqcLp4E&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=23)
+
+video penjelasan tentang logika percabangan (elif else) = [Belajar python dasar - if dan else statement](https://www.youtube.com/watch?v=rF8rh40z_X0&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=22)
+
+[Materi Selanjutnya](../08_perulangan)
\ No newline at end of file
diff --git a/Basic/07_logika_percabangan/logika_percabangan.py b/Basic/07_logika_percabangan/logika_percabangan.py
new file mode 100644
index 00000000..c23f1dd6
--- /dev/null
+++ b/Basic/07_logika_percabangan/logika_percabangan.py
@@ -0,0 +1,16 @@
+# membuat variabel dari cuaca
+# dan membuat value "cerah"
+
+
+cuaca = "cerah"
+# logika jika cuaca hujan
+if cuaca == "hujan":
+ print("gunakan payung")
+# menggunakan fungsi elif
+# jika cuaca cerah
+elif cuaca == "cerah":
+ print("tidak menggunakan payung")
+# menggunakan else jika kedua fungsi tidak terpenhi
+# if dan elif
+else:
+ print("gunakan pakaian renang")
diff --git a/Basic/08_perulangan/README.md b/Basic/08_perulangan/README.md
new file mode 100644
index 00000000..2fee0fe3
--- /dev/null
+++ b/Basic/08_perulangan/README.md
@@ -0,0 +1,144 @@
+# Perulangan
+
+Perulangan adalah urutan instruksi yang akan dijalankan, apabila suatu kondisi terpenuhi.
+
+Perulangan pada Python terbagi 2, yaitu:
+- while
+- for
+
+mari kita ulas terlebih dahulu while loop.
+
+## While
+
+Contoh:
+
+```python
+a = 1
+
+while a <= 5:
+ print(a)
+ a += 1
+```
+
+Apabila variable `a` yang awalnya 1, tidak melebihi ataupun sama dengan 5 maka loop bisa berjalan, apabila kondisinya sudah tidak terpenuhi lagi, maka statement loop akan otomatis selesai.
+
+Contoh lainnya:
+
+```python
+b = 5
+
+while b >= 1:
+ print(b)
+ b -= 1
+```
+
+Apabila variable b yang awalnya 5, masih lebih besar atau sama dengan 1, apabila variable b sudah menyentuh angka 0, maka loop statement otomatis tidak akan bekerja.
+
+Bisakah kita menghentikan proses looping di tengah statement yang masih memenuhi persyaratan?
+Tentu bisa dong!
+
+Yaitu denga menggunakan keyword ```break```. Contohnya:
+
+```python
+c = 1
+
+while c <= 5:
+ print(c)
+ if c == 3:
+ break
+ c += 1
+```
+
+Apabila nilai variable `c` masih ada di bawah atau sama dengan `5` maka proses loop bisa dilakukan, tetapi, jika nilai `c` sudah di angka `3`, kita melakukan proses ```break```, atau berhenti. Jadi kita menghentikan loop nya meskipun hasil statement loop nya masih benar.
+
+Terus, bisa diskip ga sih suatu bilangan? Bisa dong, kita memakai statement ```continue```, contohnya:
+
+```python
+d = 0
+
+while d < 5:
+ d += 1
+ if d == 3:
+ continue
+ print(d)
+```
+
+Dari program di atas, kita melakukan statement yang sama dengan `3` statement di atas, tapi ni, bedanya adalah, apabila variable `d` sudah ada di angka `3`, kita ```continue``` aja, atau kita skip.
+
+Last but not least, gimana sih cara ngasih tau kita kalau misalnya loop nya udah selesai gitu? tentu ada caranya, kita akan pakai statement ```else```. Contohnya:
+
+```python
+e = 0
+
+while e <= 5:
+ print(e)
+ e += 1
+else:
+ print("Selamat, looping anda telah selesai !!")
+```
+
+Nah, jadi kalau misalnya loop kita udah selesai, Python akan memberikan statement, `"Selamat, looping anda telah selesai !!`
+
+
+## For
+
+Contohnya:
+
+```python
+angka = [1,2,3,4,5]
+
+for item in angka:
+ print(item)
+```
+
+Jadi maksud dari koding di atas adalah untuk setiap item di dalam list angka, silahkan tampilkan item tersebut.
+
+Kita juga bisa menggunakan `break` di perulangan `for`:
+
+```python
+for item in angka:
+ print(item)
+ if item == 3:
+ break
+```
+
+Meskipun statement dari `break` for loop ini beda dengan while loop, maknanya sama saja, kalau itemnya udah di angka 3, break aja, atau selesaikan aja.
+
+apa di for loop ada ```continue```? pastinyaa:
+
+```python
+for item in angka:
+ if item == 3:
+ continue
+ print(item)
+```
+
+Penjelasannya adalah, apabila item dari list angka tersebut udah ada di angka `3`, angka `3` nya diskip, dan berlanjut ke angka 4.
+
+Last but not least,
+
+```else``` statement
+
+```python
+for item in angka:
+ print(item)
+else:
+ print("Selesai !")
+```
+
+
+Apa sih perbedaan antara while loop dan for loop?
+
+- while loop itu bergerak/melakukan sesuatu berdasarkan "kondisi" seperti misalnya tadi, "jika nilai a masih dibawah 5, maka tampilkan a", tapi kalau tidak? tentu outputnya tidak ada lagi dan while loop selesai, hal ini bisa di dukung dengan arti dari ```while``` yang artinya ```ketika```.
+
+- for loop adalah looping yang melakukan sesuatu berdasarkan "keanggotaan", seperti misalnya, "untuk setiap anggota dari list angka, tampilkan (print)", hal ini tentu di dukung dengan arti dari statement for loop yaitu ```for item in iterable``` yang artinya ```untuk setiap item yang ada di dalam iterable``` dan arti kata ```for``` itu sendiri yang artinya ```untuk```.
+
+
+while loop
+for loop
+
+Video penjelasan tentang looping (for) = [Belajar dasar python - for loop (perulangan)](https://www.youtube.com/watch?v=Z4qfMhx4XzQ&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=25)
+
+Video penjelasan tentang looping (while) = [Belajar dasar python - while loop (perulangan)](https://www.youtube.com/watch?v=ZupffvoCChQ&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=26)
+
+[Materi Selanjutnya](../09_fungsi)
\ No newline at end of file
diff --git a/Basic/08_perulangan/for_loop.py b/Basic/08_perulangan/for_loop.py
new file mode 100644
index 00000000..32c249da
--- /dev/null
+++ b/Basic/08_perulangan/for_loop.py
@@ -0,0 +1,31 @@
+# penggunaan for loop pada string
+nama = "zoelfekre"
+for tampil_nama in nama:
+ print(tampil_nama)
+
+# penggnaan for loop pada list
+print("\ntampil nama siswa dalam list")
+nama_siswa = ["zoelfekre", "dwi", "dian"]
+for tampil_siswa in nama_siswa:
+ print(tampil_siswa)
+
+# penggunaan for loop pada tuple
+print("\ntampil nama siswa dalam tuple")
+nama_siswa_tuple = ("zoelfekre", "dwi", "dian")
+for tampil_siswa_tuple in nama_siswa:
+ print(tampil_siswa_tuple)
+
+
+# penggunaan break pada looping
+angka_saya = 0
+for angka_saya in range(0, 10):
+ print(angka_saya)
+ if angka_saya == 5:
+ break
+
+# penggunaan continue pada looping
+angka_saya1 = 0
+for angka_saya1 in range(0, 10):
+ if angka_saya1 == 5:
+ continue
+ print(angka_saya1)
diff --git a/Basic/08_perulangan/while_loop.py b/Basic/08_perulangan/while_loop.py
new file mode 100644
index 00000000..3d592751
--- /dev/null
+++ b/Basic/08_perulangan/while_loop.py
@@ -0,0 +1,36 @@
+a = 1
+
+while a <= 5:
+ print(a)
+ a += 1
+
+b = 5
+
+while b >= 1:
+ print(b)
+ b -= 1
+
+c = 1
+
+while c <= 5:
+ print(c)
+ if c == 3:
+ break
+ c += 1
+
+d = 0
+
+while d < 5:
+ d += 1
+ if d == 3:
+ continue
+ print(d)
+
+e = 0
+
+while e <= 5:
+ print(e)
+ e += 1
+ break
+else:
+ print("Selamat, looping anda telah selesai !!")
diff --git a/Basic/09_fungsi/README.md b/Basic/09_fungsi/README.md
new file mode 100644
index 00000000..f574c1a9
--- /dev/null
+++ b/Basic/09_fungsi/README.md
@@ -0,0 +1,240 @@
+# Fungsi
+
+Fungsi adalah sebuah blok kode yang berjalan ketika dipanggil.
+
+Contoh:
+
+```python
+def hello():
+ print('Hello!')
+```
+
+Apabila kita ingin menggunakan fungsi tersebut kita bisa memanggilnya dengan:
+
+```python
+hello()
+```
+
+Lantas, apakah kita bisa memasukkan input ke dalam fungsi?
+Tentu bisa input yang kita kirimkan ke dalam fungsi disebut sebagai argument, seperti apa contohnya?
+
+> Argument adalah nilai atau variabel yang dikirim kepada fungsi ketika fungsi tersebut dipanggil.
+
+```python
+def hello(nama):
+ print('Hello '+str(nama)+'!')
+```
+
+Apabila kita ingin memakai fungsi tersebut dan memasukkan argument kita cukup mengetikkan:
+
+```python
+hello('Bellshade')
+```
+
+`Bellshade` adalah argument yang dikirim kepada fungsi `hello(py)`.
+
+Kita bisa mengirimkan lebih dari satu argument. Contohnya:
+
+```python
+def triangle(alas, tinggi):
+ hasil = (alas * tinggi)/2
+ print(hasil)
+```
+
+Dan kita pun akan memakai fungsi segitiga kita dengan mengirimkan dua argument, yaitu `2` dan `3`:
+
+```python
+triangle(2,3)
+```
+
+
+## Return
+Return adalah sebuah keyword yang mengembalikan nilai dan juga sekaligus "mengakhiri" function itu sendiri.
+
+Contohnya:
+
+```python
+def triangle(alas,tinggi):
+ hasil = (alas * tinggi)/2
+ return hasil
+
+
+print(triangle(2,3))
+```
+
+Return pada koding di atas, mengakhiri function dari `triangle`, jadi kita tidak bisa lagi melakukan perintah apapun setelah baris `return hasil`.
+
+
+## Default argument
+Default argument terjadi apabila kita membuat argument menjadi bernilai tetap, misalnya:
+
+```python
+def salam(waktu="Pagi"):
+ greet = "Selamat " + str(waktu)
+ return greet
+
+
+print(salam("Siang")) # Selamat Siang
+print(salam("Malam")) # Selamat Malam
+print(salam("Sore")) # Selamat Sore
+print(salam()) # Selamat Pagi
+```
+
+Di sini kita melakukan default value terhadap argument dari waktu menjadi `Pagi`, jadi apabila kita memanggil `salam()`,
+maka itu tidak akan menimbulkan error, karena sudah ada default valuenya, dan default value juga bersifat `flexibel` dimana masih bisa diubah menjadi, 'Siang', 'Malam', dan lainnya tergantung pada nilai yang diberikan pada argument fungsi.
+
+
+## Unlimited atau Infinite
+`Unlimited` atau `Infinite` artinya adalah tak terbatas, apa yang tak terbatas?
+Yang tak terbatas di fungsi Python adalah jumlah argument yang dapat kita inputkan.
+
+Contohnya:
+
+```python
+def unlimited(*args):
+ for item in args:
+ print(item)
+
+
+unlimited(1,2,3,4)
+unlimited([1,2],[3,4])
+```
+
+Contoh dari unlimited nya adalah, pada command pertama, kita memasukkan 4 parameter, command kedua, kita memasukkan 2 parameter.
+
+Last, but not least, unlimited keyword argument, dimana kita memberi tahu bahwa argument kita ini memiliki key, atau kunci. Hal ini sama dengan dictionary di mana pada unlimited keyword argument, Python memakai prinsip dictionary, sementara pada unlimited argument, Python mengadopsi konsep tuple.
+
+Contohnya:
+
+```python
+def unlimitedkeyword(**infinite):
+ for key, value in infinite.items():
+ print("index {} memiliki nilai {}".format(key,value))
+
+
+unlimitedkeyword(a=2,b=1,c=3)
+unlimitedkeyword(fname="Harry",lname="Potter")
+```
+
+Di mana pada command pertama, kita memasukkan 3 parameter dengan masing-masing key a,b,c dan value 1,2,3.
+Dan pada command kedua, kita memasukkan 2 parameter dengan masing-masing key yaitu fname dan lname dengan value Harry, Potter.
+
+
+## Fungsi Rekursi
+
+### Definisi Fungsi Rekursi
+Fungsi rekursi adalah fungsi yang dapat memanggil dirinya sendiri. Beberapa permasalahan dalam algoritma dan struktur data menggunakan rekursi sebagai solusi penyelesaian, misalnya, dalam struktur data *linked list* atau *tree*. Perhatikan fungsi `recursion` di bawah:
+
+```python
+def recursion(param):
+ return recursion(param)
+```
+
+Kita harus memperhatikan dua hal ketika berurusan dengan rekursi:
+1. __*Base Case*__ : *Base Case* berfungsi untuk mengentikan proses rekursi. Kita harus jeli ketika mendefinisikan *base case*, sebab tiap
+permasalahan memiliki *base case* yang berbeda. Salah mendefinisikan *base case* dapat berakhir dengan *infinite recursion*. *Base Case* biasanya
+didefinisikan ketika ```n = 0``` atau ```n = 1```.
+2. __Proses Rekursi__ : Proses rekursi merupakan solusi penyederhanaan dari masalah yang besar menjadi subpermasalahan yang lebih kecil. Sama seperti
+*base case*, proses rekursi setiap permasalahan berbeda-beda.
+
+Contoh fungsi rekursi adalah faktorial. Faktorial merupakan perkalian mundur suatu bilangan positif yang kurang lebih atau sama dengan *n*. Faktorial dilambangkan dengan `n!`. Faktorial 0 atau `0!` bernilai 1. Nilai faktorial suatu bilangan positif dapat dihitung menggunakan proses rekursi yang ditunjukkan pada fungsi `faktorial(n)` di bawah:
+
+```python
+def faktorial(n):
+ """
+ menghitung nilai faktorial suatu bilangan positif n
+ dan mengembalikan integer
+ >>> faktorial(5)
+ 120
+ >>> faktorial(6)
+ 720
+ """
+
+ #base case
+ if n == 0 or n == 1:
+ return 1
+ #proses rekursi
+ else :
+ return n*faktorial(n-1)
+```
+
+Visualisasi dari proses rekursi di atas adalah sebagai berikut
+
+
+
+### Rekursi Versus Loop
+Sebenarnya, beberapa permasalahan dalam pemrograman bisa diselesaikan menggunakan *loop* biasa daripada menggunakan rekursi, seperti pada kasus faktorial di atas. Kode untuk menghitung nilai faktorial menggunakan *loop* ditunjukkan pada kode di bawah ini:
+
+```python
+n = int(input())
+hasil = 1
+
+if n == 0 or n == 1:
+ print(1)
+else :
+ for i in range(n, 0, -1):
+ hasil = hasil * n
+ n = n - 1
+
+print(hasil)
+```
+
+Jika kita meng-`input` variabel *n* dengan nilai 5, kita akan mendapatkan `hasil` 120. Dari hasil tersebut, kita sama-sama tahu, bahwa perhitungan faktorial menggunakan fungsi rekursi dan *loop* biasa menghasilkan solusi yang sama.
+
+**Jadi, daripada memikirkan base case dan proses rekursi, lebih baik kita menggunakan loop biasa ketika menghadapi permasalahan yang melibatkan proses iterasi?**
+Jawabannya : **tidak**. Sebab, beberapa permasalahan dalam algoritma dan struktur data menggunakan pendekatan rekursi sebagai penyelesaian masalah. Hal ini disebabkan penyelesaian permasalahan menggunakan *loop* atau iterasi biasa tidak intuitif untuk permasalahan tersebut. Contoh solusi yang kurang intuitif dari permasalahan pada algoritma dan struktur data adalah ketika kita ingin meng-*insert* *node* pada *linked list* atau menambahkan *node* pada *tree*. Setidaknya sampai tulisan ini dibuat, penulis belum mendapatkan penyelesaian untuk menambahkan *node* pada kedua struktur data di atas menggunakan pendekatan iterasi biasa.
+
+Contoh lain dari penyelesaian masalah menggunakan rekursi dapat dilihat pada file ```recursion_example.py``` yang ada di repositori.
+
+
+## Closure
+
+### Definisi Closure
+Kita bisa mendefinisikan fungsi di dalam fungsi. Di Python, teknik ini disebut sebagai *closure* atau *nested function*. *Closure* dapat mengakses variabel yang tidak berada di dalam *scope* fungsi tersebut. Variabel ini biasa disebut *nonlocal variable*. *Closure* juga dapat mengembalikan fungsi layaknya fungsi rekursi. Fungsi ```outerFunc()``` di bawah ini mendemonstrasikan bagaimana *closure* bekerja:
+
+```python
+def outerFunc(pesan):
+
+ def innerFunc():
+ # parameter "pesan" dapat diakses oleh innerFunc
+ print("{} juga dari innerFunc".format(pesan))
+
+ # ketika outerFunc(pesan) dipanggil, innerFunc() juga ikut terpanggil
+ innerFunc()
+
+
+pesan = "Halo"
+hasil = outerFunc(pesan)
+# memunculkan "Halo juga dari innerFunc" di console
+print(hasil)
+```
+
+Seperti yang sudah disebutkan pada bagian definisi, *closure* juga dapat mengembalikan fungsi. *Closure* yang memiliki kegunaan seperti ini biasa disebut sebgai *factory function*. Fungsi `pangkat()` di bawah mendemonstrasikan bagaimana cara kerja *factory function*:
+
+```python
+def pangkat(n):
+
+ def basis(x):
+ return x ** n
+ return basis
+
+
+# membuat perpangkatan 2
+pangkat2 = pangkat(2)
+
+# membuat perpangkatan 3
+pangkat3 = pangkat(3)
+
+# menampilkan 4
+print(pangkat2(2))
+
+# menampilkan 27
+print(pangkat3(3))
+```
+
+
+Bellshade Python Function
+Bellshade Python Recursion
+
+
+[Materi Selanjutnya](../10_list_tuple)
diff --git a/Basic/fungsi/fungsi.py b/Basic/09_fungsi/fungsi.py
similarity index 93%
rename from Basic/fungsi/fungsi.py
rename to Basic/09_fungsi/fungsi.py
index bf5d39e5..36f087e7 100644
--- a/Basic/fungsi/fungsi.py
+++ b/Basic/09_fungsi/fungsi.py
@@ -65,7 +65,7 @@ def unlimited(*args):
def unlimitedkeyword(**infinite):
for key, value in infinite.items():
- print("index {} memiliki nilai {}".format(key, value))
+ print(f"index {key} memiliki nilai {value}")
unlimitedkeyword(a=2, b=1, c=3)
diff --git a/Basic/09_fungsi/recursion_example.py b/Basic/09_fungsi/recursion_example.py
new file mode 100644
index 00000000..9c65ae93
--- /dev/null
+++ b/Basic/09_fungsi/recursion_example.py
@@ -0,0 +1,22 @@
+def fibo(n):
+ """
+ Deret fibonacci merupakan salah satu permasalahan yang diselesaikan
+ menggunakan pendekatan rekursi. Pada beberapa literatur,
+ deret fibonacci dimulai dengan 0,1,1,2,... namun ada
+ literatur yang menjelaskan bahwa deret ini dimulai dengan 1,1,2,... .
+ Fungsi fibo(n) memiliki parameter n yang akan mengembalikan nilai
+ fibonacci pada urutan ke-n. Fungsi ini menggunakan deret 1,1,2,...
+ """
+
+ # base case
+ if n == 1 or n == 2:
+ return 1
+ # proses rekursi
+ else:
+ return fibo(n - 1) + fibo(n - 2)
+
+
+n = 3
+result = fibo(n)
+# result menghasilkan 2
+print(result)
diff --git a/Basic/10_list_tuple/README.md b/Basic/10_list_tuple/README.md
new file mode 100644
index 00000000..3944223e
--- /dev/null
+++ b/Basic/10_list_tuple/README.md
@@ -0,0 +1,162 @@
+# List
+List digunakan untuk menyimpan data yang banyak dengan hanya satu variable, list menggunakan square bracket atau kurung petak (`[]`). Contoh:
+
+```python
+nama_hewan = ["sapi", "gajah", "ayam", "bebek"]
+print(nama_hewan)
+```
+
+List memiliki index, index dimulai dari 0, dan index kedua dimulai dari angka 1.
+
+Kelebihan dari list adalah:
+
+- Bisa dirubah
+ list bisa dirubah dengan dengan cara:
+ ```python
+ nama_hewan = ["sapi", "gajah", "ayam", "bebek"]
+ nama_hewan[1] = "kucing"
+ print(nama_hewan)
+ ```
+- Menerima duplikasi
+ list juga duplikasi item, sebagai contoh:
+ ```python
+ nama_hewan = ["ikan", "singa", "ikan", "sapi"]
+ print(nama_hewan)
+ ```
+
+# Tuple
+Tuple mirip dengan list, kecuali datanya tidak bisa diubah lagi. Tuple menggunakan round bracket atau kurung bulat (`()`). Contoh:
+
+```python
+nama_hewan = ("ikan", "gajah", "sapi", "paus")
+print(nama_hewan)
+```
+
+Untuk tuple dengan hanya satu item di dalamnya menggunakan koma (`,`) karena jika tidak menggunakan koma akan dianggap sebagai string. Contoh:
+
+```python
+nama_hewan = ("sapi",)
+print(nama_hewan)
+```
+
+# Comprehension
+Kita juga dapat membuat/membangun list atau dictionary menggunakan *comprehension*. *Comprehension* memanfaatkan *loop* untuk membangun list atau dictionary. Dengan *comprehension*, kita dapat membuat list dengan kode yang lebih ringkas.
+
+Dalam menggunakan *comprehension*, ada 3 hal yang harus kita perhatikan, yakni:
+
+1. Output
+2. Loop
+3. Condition
+
+Ketiga hal di atas ditulis dengan notasi *comprehension* sebagai berikut :
+
+ Penjelasan diolah dari [freecodecamp](https://www.freecodecamp.org/news/list-comprehension-in-python/)
+
+## List Comprehension
+Kita dapat membangun list menggunakan *comprehension*. Kita memiliki *template* untuk list comprehension, seperti kode yang ditunjukkan di bawah:
+
+```python
+list_comprehension = [x for x in interable]
+```
+
+Iterable di atas bisa saja elemen dari list lain, atau fungsi bawaan seperti ```range()```.
+
+Sebagai contoh, kita ingin membuat list yang berisikan bilangan genap dari 1 sampai 10. Dengan menggunakan list comprehension, kita dapat menuliskan kode tersebut sebagai berikut :
+
+```python
+genap = [x for x in range(11) if x % 2 == 0]
+# menghasilkan [0, 2, 4, 6, 8, 10]
+print(genap)
+
+```
+
+Kode di atas dapat kita tulis ulang menggunakan loop biasa, namun kode yang ditulis akan lebih panjang dengan kode sebagai berikut :
+
+```python
+genap = []
+for x in range (11):
+ if x % 2 == 0:
+ genap.append(x)
+
+# menghasilkan [0, 2, 4, 6, 8, 10]
+print(genap)
+
+```
+
+Tidak hanya conditional menggunakan ```if```, tetapi kita juga bisa menggunakan ```if ... else``` dalam list comprehension. Kode di bawah ini menggunakan ```if ... else``` untuk menampilkan apakah nilai dalam list bernilai ganjil atau genap.
+
+```python
+ganjilGenap = ['genap' if num % 2 == 0 else 'ganjil' for num in range(5)]
+# menghasilkan ['genap', 'ganjil', 'genap', 'ganjil', 'genap']
+print(ganjilGenap)
+
+```
+
+Kita juga bisa menggunakan nested loop dalam list comprehension. Kode di bawah ini membuat matriks menggunakan list comprehension.
+
+```python
+matriks = [[i for i in range (3)] for i in range (5)]
+# menghasilkan [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
+print(matriks)
+
+```
+
+Pada kode di atas, terdapat dua buah list comprehension. List comprehension pertama ditunjukkan oleh ```[i for i in range (3)]```, sedangkan list comprehension kedua ditunjukkan oleh ```[ ... for i in range (5)]```. List comprehension pertama akan menghasilkan baris dengan elemen tiap baris adalah ```[0, 1, 2]```, dan list comprehension kedua akan menghasilkan 5 buah kolom.
+
+## Dictionary Comprehension
+Sama seperti list comprehension, kita juga dapat membangun sebuah dictionary menggunakan dictionary comprehension. Hanya saja, kita harus ingat, bahwa dictionary merupakan *key - value pair*, artinya kita mengakses elemen dictionary menggunakan *key* pada dictionary tersebut.
+
+Kita memiliki *template* untuk dictionary comprehension, seperti kode yang ditunjukkan di bawah :
+
+```python
+dict_comprehension = {k:v for (k,v) in dict.items()}
+```
+
+```dict.items()``` di atas dapat kita ganti dengan iterable lain, misalnya objek yang dihasilkan dari fungsi ```range()```
+
+Contoh di bawah ini adalah membangun dictionary pemangkatan 2 pada tiap *value* dictionary menggunakan dictionary comprehension.
+
+```python
+awal = {'1': 1, '2': 2, '3': 3, '4': 4, '5': 5}
+akhir = {k: v**2 for (k, v) in awal.items()}
+# menghasilkan {'1': 1, '2': 4, '3': 9, '4': 16, '5': 25}
+print(akhir)
+
+```
+
+Sama seperti list comprehension, kita juga bisa menggunakan condition dalam dictionary comprehension. Contoh di bawah ini akan menghasilkan ```ganjil``` jika *key* bernilai ganjil dan sebaliknya.
+
+```python
+awal = {'1': 1, '2': 2, '3': 3, '4': 4, '5': 5}
+akhir = {k: ('ganjil' if v % 2 != 0 else 'genap') for (k, v) in awal.items()}
+# menghasilkan {'1': 'ganjil', '2': 'genap', '3': 'ganjil', '4': 'genap', '5': 'ganjil'}
+print(akhir)
+
+```
+
+Kemudian, sama dengan list comprehension, kita juga bisa menggunakan dictionary comprehension di dalam dictionary comprehension, atau biasa kita sebut nested dictionary comprehension. Kode di bawah ini akan memangkatkan ```key_luar``` sebanyak ```key_dalam``` kali.
+
+```python
+kuadrat = {
+ key_luar:
+ {key_dalam: key_luar ** key_dalam for key_dalam in range(1, 5)}
+ for key_luar in range(2, 5)
+ }
+# menghasilkan {2: {1: 2, 2: 4, 3: 8, 4: 16}, 3: {1: 3, 2: 9, 3: 27, 4: 81}, 4: {1: 4, 2: 16, 3: 64, 4: 256}}
+print(kuadrat)
+
+```
+
+Kode di atas ekuivalen dengan kode di bawah.
+
+```python
+kuadrat = dict()
+for key_luar in range(2, 5):
+ kuadrat[key_luar] = {key_dalam: key_luar ** key_dalam for key_dalam in range(1,5)}
+
+# menghasilkan {2: {1: 2, 2: 4, 3: 8, 4: 16}, 3: {1: 3, 2: 9, 3: 27, 4: 81}, 4: {1: 4, 2: 16, 3: 64, 4: 256}}
+print(kuadrat)
+
+```
+
+[Materi Selanjutnya](../11_manipulasi_string)
\ No newline at end of file
diff --git a/Basic/10_list_tuple/list_python.py b/Basic/10_list_tuple/list_python.py
new file mode 100644
index 00000000..7d9bb1de
--- /dev/null
+++ b/Basic/10_list_tuple/list_python.py
@@ -0,0 +1,27 @@
+nama_hewan = ["gajah", "sapi", "kuda", "buaya"]
+
+# menampilkan isi list
+print(nama_hewan)
+
+# menampilkan isi list dengan index
+print(nama_hewan[0])
+print(nama_hewan[1])
+
+# mengganti satu index list
+nama_hewan[0] = "kucing"
+print(nama_hewan)
+
+# menghitung jumlah list
+print(len(nama_hewan))
+
+# campur beberapa tipe data dalam satu list
+list_saya = ["gajah", 12, True, "makan"]
+print(list_saya)
+
+# menggunakan konstruktor pada pembuatan list
+list_hewan1 = list(("kijang", "sapi", "kucing", "ayam"))
+print(list_hewan1)
+
+# menggunakan looping untuk menampilkan list
+for jenis_hewan in list_hewan1:
+ print(jenis_hewan)
diff --git a/Basic/10_list_tuple/tuple_python.py b/Basic/10_list_tuple/tuple_python.py
new file mode 100644
index 00000000..8bcb282f
--- /dev/null
+++ b/Basic/10_list_tuple/tuple_python.py
@@ -0,0 +1,26 @@
+jenis_mobil = ("ferrari", "bmw", "jaguar", "lamborghini")
+
+# menampilkan isi dari tuple
+print(jenis_mobil)
+
+# menampilkan isi dari tuple dengan index
+print(jenis_mobil[0])
+
+# menduplikasi item pada list
+jenis_mobil_terbaru = ("ferrari", "bmw", "jaguar", "bmw")
+print(jenis_mobil_terbaru)
+
+# menghitung panjang tuple
+print(len(jenis_mobil))
+
+# membuat satu item dengan tuple
+jenis_makanan = ("seblak",)
+print(jenis_makanan)
+
+# membuat tipe data tuple
+tuple_campur = ("makan", 12, True, 12.0)
+print(tuple_campur)
+
+# menampilkan tuple dengan perulangan for
+for mobil in jenis_mobil:
+ print(mobil)
diff --git a/Basic/11_manipulasi_string/README.md b/Basic/11_manipulasi_string/README.md
new file mode 100644
index 00000000..8818eeb5
--- /dev/null
+++ b/Basic/11_manipulasi_string/README.md
@@ -0,0 +1,185 @@
+# Manipulasi string
+
+Pada Python kita bisa merubah dan memanipulasi string yang sudah ada agar sesuai dengan kebutuhan yang diinginkan.
+
+
+- Mengakses salah satu karakter dari string
+
+ ```python
+ nama_saya = "zoelfikrie"
+ print(nama_saya[0])
+ ```
+
+- Menghitung semua karakter string
+
+ ```python
+ nama_saya = "athallamajed"
+ print(len(nama_saya))
+ ```
+
+- Menghitung jumlah suatu huruf dari karakter
+
+ ```python
+ nama_saya = "carl loghmatten"
+ print(nama_saya.count("l"))
+ ```
+
+- Menghitung jumlah spasi pada string
+
+ ```python
+ kalimat = "program belajar indonesia"
+ print(kalimat.count(' '))
+ ```
+
+- Memotong karakter
+
+ ```
+ kata = "indonesia programming"
+ ```
+
+ - mengambil karakter pertama dari string
+ ```python
+ print(kata[0])
+ ```
+
+ - mengambil 3 karakter dari string
+ ```python
+ priint(kata[0:3])
+ ```
+ ```python
+ print(kata{:3})
+ ```
+
+ - mengambil 3 karakter terakhir dari string
+ ```python
+ print(kata[-3:])
+ ```
+
+- Mengulang sebanyak dari string
+ ```python
+ # mengulang sebanyak 100 kali
+ print("indonesia" * 100)
+ ```
+
+- Mengubah kata dari string
+
+ ```python
+ kata = "belajar memasak"
+ ubah = kata.replace("belajar", "pintar")
+ print(ubah)
+ ```
+
+|sintaks | penjelasan | contoh kode |
+|:-- | :--: | :-- |
+| ``uper()``| mengubah semua huruf menjadi kapital | ``kata.upper()`` |
+| ``lower()``| mengubah semua huruf menjadi kecil | ``kata.lower()`` |
+| ``title()``| mengubah setiap awalan kata kalimat menjadi kapital | ``kata.title()``|
+| ``capitalize()`` | mengubah awalan huruf utama menjadi kapital | ``kata.capitalize()`` |
+| ``swapcase()``| mengubah setiap awalan kata kalimat menjadi huruf kecil | ``kata.swapcase()``|
+
+- Membalikkan string
+
+ ```python
+ kata = "bellshade python"
+ # cara pertama
+ print(kata[::-1])
+ # cara kedua
+ print(' '.join(reversed(kata)))
+ ```
+
+- Penggabungan string
+
+ ```python
+ kata = "memasak"
+ print("saya belajar " + kata)
+ ```
+
+ - join
+ menambahkan karakter di setiap karakter
+ ```python
+ kata = "indonesia"
+ print("x".join(kata))
+ ```
+
+- Pengecekan
+
+ - ``kata.isalnum()``
+ cek kata tersebut mengandung alphanumerik atau tidak
+
+ - ``kata.isalpha()``
+ cek kata tersebut mengandung alphabet
+
+ - ``kata.isdigit()``
+ cek apakah kata mengandung digit atau angka
+
+ - ``kata.istitle()``
+ cek apakah kata mengandung title atau tidak
+
+ - ``kata.isupper()``
+ cek apakah kata mengandung huruf kapital
+
+ - ``kata.islower()``
+ cek apakah kata mengandung kata huruf kecil
+
+ - ``kata.isspace()``
+ cek apakah kata mengandung spasi atau tidak
+
+ - ``kata.endswith('karakter')``
+ cek apakah kata mengandung karakter tersebut atau tidak pada akhir
+
+ - ``kata.startswith('karakter')``
+ cek apakah kata mengandung karakter terseub atau tidak pada awal
+
+berikut tabel method pada string
+
+| Method | Penjelasan |
+|----------------|-----------------------------------------------------------------------------------------------|
+| capitalize() | Mengubah karakter pertama menjadi Kapital |
+| casefold() | Mengubah string menjadi huruf kecil |
+| center() | Mengembalikan String yang ditengahkan |
+| count() | Menghitung jumlah karakter tertentu di dalam string |
+| encode() | Mengembalikan string yang sudai disandi |
+| endswith() | Mengembalikan True jika string berakhir dengan karakter tertentu |
+| expandtabs() | Mengatur besar Tab pada String |
+| find() | Mencari karakter tertentu dan mengembalikan letak dimana karakter itu berada |
+| format() | mem-format karakter tertentu di dalam string |
+| format_map() | mem-format karakter tertentu di dalam string |
+| index() | Mencari karakter tertentu dan mengembalikan letak dimana karakter itu berada |
+| isalnum() | Mengembalikan True jika semua karakter adalah alfanumerik |
+| isalpha() | Mengembalikan True jika semua karakter adalah alfabet |
+| isascii() | Mengembalikan True jika semua karakter adalah karakter ascii |
+| isdecimal() | Mengembalikan True jika semua karakter adalah desimal |
+| isdigit() | Mengembalikan True jika semua karakter adalah angka |
+| isidentifier() | Mengembalikan True jika String adalah pengidentifikasi |
+| islower() | Mengembalikan True jika semua karakter adalah huruf kecil |
+| isnumeric() | Mengembalikan True jika semua karakter adalah numerik |
+| isprintable() | Mengembalikan True jika semua karakter dapat dicetak |
+| isspace() | Mengembalikan True jika semua karakter adalah spasi |
+| istitle() | Mengembalikan True jika string mengikuti aturan judul |
+| isupper() | Mengembalikan True jika semua karakter adalah upper case |
+| join() | masuk kedalam elemen dari suatu iterable dia akhir string |
+| ljust() | Mengembalikan String yang dikirikan |
+| lower() | Mengkonversi string ke huruf kecil |
+| lstrip() | Menghapus spasi di kiri pada string |
+| maketrans() | Mengembalikan tabel translasi untuk di translasikan |
+| partition() | Mengembalikan Tuple dimana string dibagi menjadi tiga bagian |
+| replace() | Mengemlikan String dimana karakter tertentu di ganti dengan karakter yang lain |
+| rfind() | Mencari karakter tertentu dan mengembalikan posisi dimana karakter itu berada terakhir |
+| rindex() | Mencari karakter tertentu dan mengembalikan posisi dimana karakter itu berada terakhir |
+| rjust() | Mengembalikan string yang dikanankan |
+| rpartition() | Mengembalikan Tuple dimana string dibagi menjadi tiga bagian |
+| rsplit() | Membagi string pada pembagi yang ditentukan, dan mengembalikan list |
+| rstrip() | Menghapus spasi di kanan pada string |
+| split() | Membagi string pada pembagi yang ditentukan, dan mengembalikan list |
+| splitlines() | Membagi string pada baris baru, dan mengembalikan list |
+| startswith() | Mengembalikan True jika string dimulai dengan karakter tertentu |
+| strip() | Mengembalikan String yang spasinya sudah dihapus |
+| swapcase() | Mengubah kapital menjadi huruf kecil dan sebaliknya |
+| title() | Mengubah huruf awal di setiap kata menjadi kapital |
+| translate() | Mengembalikan string yang sudah ditranslasi |
+| upper() | Mengubah string menjadi huruf Kapital |
+| zfill() | Mengisi string dengan angka 0 sebanyak jumlah yang ditentukan di awal string |
+
+video penjelasan tentang manipulasi string = [Belajar python dasar - manipulasi string](https://www.youtube.com/watch?v=ORda-LwrEwE&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=18)
+
+[Materi Selanjutnya](../12_exception)
\ No newline at end of file
diff --git a/Basic/12_exception/README.md b/Basic/12_exception/README.md
new file mode 100644
index 00000000..20b71b4a
--- /dev/null
+++ b/Basic/12_exception/README.md
@@ -0,0 +1,144 @@
+# Exceptions (Eksepsi)
+Saat melakukan pemrograman di bahasa _Python_, pasti sebagian besar _developer_ pernah mengalami kesalahan ketika mengeksekusi sebuah program yang dikenal dengan sebutan _error_. Hal ini terjadi karena ada kesalahan dalam menuliskan sintaks yang membuat program tersebut berhenti dan memunculkan pesan kesalahan (_error_) tersebut. Beberapa contoh kesalahan yang biasa kita lakukan ketika memprogram bahasa _Python_ diantaranya:
+
+- Pernyataan `if` atau `for` yang tidak diikuti dengan tanda titik dua.
+ ```python
+ >>> if True
+ File "", line 1
+ if True
+ ^
+ SyntaxError: invalid syntax
+ ```
+
+- Penggunaan tanda kurung yang salah.
+ ```python
+ >>> print('contoh penulisan yang salah'))
+ File "", line 1
+ print('contoh penulisan yang salah'))
+ ^
+ SyntaxError: invalid syntax
+ ```
+
+_Error_ juga dapat terjadi saat program berjalan (_runtime_) yang disebut dengan eksepsi (_exception_). Beberapa contoh eksepsi yang biasa ditemukan adalah sebagai berikut:
+- `ZeroDivisionError` : suatu bilangan numerik tidak dapat dibagi dengan nol.
+ ```python
+ >>> 2 / 0
+ Traceback (most recent call last):
+ File "", line 1, in
+ ZeroDivisionError: division by zero
+ ```
+
+- `TypeError` : operasi aritmatika pada tipe data yang tidak sesuai, misalkan tidak dapat melakukan operasi penjumlahan antara _integer_ dengan _string_.
+ ```python
+ >>> 5 + "5"
+ Traceback (most recent call last):
+ File "", line 1, in
+ TypeError: unsupported operand type(s) for +: 'int' and 'str'
+ ```
+## Exeption Handling (Penanganan Eksepsi)
+Seperti yang sudah diketahui di awal bahwa terjadinya _error_ atau _exception_ menyebabkan program terhenti. Untuk mengantisipasi hal ini, _Python_ menyediakan penanganan kesalahan tersebut menggunakan pernyataan `try` dan `except`. Letakkan baris program yang memiliki kemungkinan _error_ di dalam blok `try`. Bila terjadi error di dalam blok `try`, tangani di dalam blok `except`. Struktur penulisan kodenya adalah sebagai berikut.
+```python
+try:
+ # eksekusi baris ini jika tidak ada kesalahan (error)
+except:
+ # tangani jika terdapat kesalahan di dalam blok try
+```
+Pada contoh eksepsi `ZeroDivisionError` di atas, jika ingin menangani eksepsi tersebut, maka di dalam blok `try` berisi baris kode untuk melakukan operasi pembagian dua buah bilangan. Sedangkan di dalam blok `except` berisi pesan kesalahan menggunakan sintaks `print()` bahwa suatu bilangan tidak dapat dibagi dengan nol, sehingga penulisannya sebagai berikut.
+```python
+try:
+ # karena pembaginya adalah nol, maka tangani error di except
+ hasil = 5 / 0
+ print('Hasil pembagian adalah =', hasil)
+except:
+ # tangani error di sini
+ print('Bilangan tidak dapat dibagi dengan nol')
+```
+Pada contoh di atas, sebelum masuk ke dalam blok `except`, alangkah baiknya diikuti dengan jenis eksepsi yang ingin ditangani. Karena bisa saja terdapat lebih dari satu jenis eksepsi yang berbeda untuk ditangani. Pada contoh di atas, untuk menangani untuk eksepsi `ZeroDivisionError`, maka penulisan kodenya sebagai berikut:
+```python
+try:
+ # karena pembaginya adalah nol, maka tangani error di except
+ hasil = 5 / 0
+ print('Hasil pembagian adalah =', hasil)
+except ZeroDivisionError:
+ # tangani error di sini
+ print('Bilangan tidak dapat dibagi dengan nol')
+```
+
+Jika kita ingin menangani lebih dari satu eksepsi, maka jenis eksepsi yang ingin disebutkan menggunakan tuple. Contoh, jika ingin menangani `ZeroDivisionError` dan `TypeError`, maka struktur penulisannya menjadi sebagai berikut:
+```python
+try:
+ # lakukan sesuatu
+except (ZeroDivisionError, TypeError):
+ # tangani error di sini
+```
+
+Eksepsi dapat ditangani menggunakan lebih dari satu blok `except`. Dari contoh kasus di atas, dapat dikembangkan sebagai berikut:
+```python
+try:
+ hasil = 5 / "2"
+ print("Hasil pembagian adalah =", hasil)
+except ZeroDivisionError:
+ # tangani error jiia ada bilangan yang dibagi dengan nol di blok try
+ print("Bilangan tidak dapat dibagi dengan nol")
+except TypeError:
+ # tangani error jika kedua bilangan berbeda tipe data di blok try
+ print("Kedua bilangan berbeda tipe")
+```
+
+Selain itu, kita dapat menampilkan pesan kesalahan atau eksepsi bawaan _Python_ dengan menambahkan _alias_ menggunakan kata kunci `as` setelah jenis eksepsinya. Kemudian cetak pesan kesalahan dengan _alias_ tersebut menggunakan `print()`. Contoh penulisannya sebagai berikut.
+```python
+# Bentuk 1
+try:
+ hasil = 5 / "2"
+ print("Hasil pembagian adalah =", hasil)
+except ZeroDivisionError as err:
+ print(err) # division by zero
+except TypeError as err:
+ print(err) # unsupported operand type(s) for /: 'int' and 'str'
+
+# Bentuk 2
+try:
+ hasil = 3 / "1"
+ print('Hasil pembagian adalah =', hasil)
+except (ZeroDivisionError, TypeError) as err:
+ # cetak pesan error tergantung jenis error yang ditangkap
+ print(err)
+```
+
+## Pernyataan `finally`
+`finally` merupakan pernyataan yang selalu dieksekusi apapun hasil eksekusinya baik yang menghasilkan kesalahan (eksepsi) maupun tidak. Biasanya pernyataan `finally` dapat dipasangkan dengan `try` dan `except` sehingga menjadi pola `try-finally` maupun `try-except-finally`.
+
+Contoh kode yang menggunakan pernyataan `try-finally`:
+```python
+try:
+ print(2 / 0)
+finally:
+ print("Baris ini selalu dieksekusi")
+```
+Output:
+```python
+Baris ini selalu dieksekusi
+Traceback (most recent call last):
+ File "finally.py", line 3, in
+ hasil = 2 / 0
+ZeroDivisionError: division by zero
+```
+Karena baris kode yang ada di dalam `try` terdapat kesalahan, maka baris kode yang ada di dalam `finally` dieksekusi, kemudian munculkan kesalahannya. Sebaliknya, jika baris kode yang ada di dalam `try` tidak ada masalah, maka dieksekusi dan baris kode yang ada di dalam `finally` juga dieksekusi.
+
+Agar kesalahan dapat ditangani terlebih dahulu, gunakan pernyataan `except`.
+```python
+try:
+ print(3 / "2")
+except TypeError as err:
+ print("Kesalahan :",err)
+finally:
+ print("Baris ini selalu dieksekusi")
+```
+Output:
+```
+Kesalahan : unsupported operand type(s) for /: 'int' and 'str'
+Baris ini selalu dieksekusi
+```
+Karena terdapat kesalahan di dalam `try`, maka ditangani di dalam `except`. Kemudian, baris kode yang ada di dalam `finally` juga dieksekusi.
+
+[Materi Selanjutnya](../13_module)
\ No newline at end of file
diff --git a/Basic/12_exception/exception.py b/Basic/12_exception/exception.py
new file mode 100644
index 00000000..f0a20436
--- /dev/null
+++ b/Basic/12_exception/exception.py
@@ -0,0 +1,46 @@
+# menangani eksepsi sederhana
+try:
+ # jalankan kode berikut jika berhasil
+ # bilangan yang dibagi dengan nol merupakan kesalahan
+ # maka tangani di dalam 'except'
+ hasil = 5 / 0 # type: ignore
+ print("Hasil pembagian adalah =", hasil)
+except ZeroDivisionError:
+ # tangani kesalahan di sini
+ print("Bilangan tidak dapat dibagi dengan nol")
+
+
+# menangani lebih dari satu eksepsi
+# Cara 1. menggunakan lebih dari satu blok 'except'
+try:
+ hasil = 3 / "1" # type: ignore
+ print("Hasil pembagian adalah =", hasil)
+except ZeroDivisionError:
+ print("Bilangan tidak dapat dibagi dengan nol")
+except TypeError:
+ print("Bilangan harus bertipe numerik")
+
+# Cara 2. menuliskannya di dalam tuple
+try:
+ hasil = 3 / "1" # type: ignore
+ print("Hasil pembagian adalah =", hasil)
+except (ZeroDivisionError, TypeError):
+ print("Terdapat kesalahan ketika melakukan pembagian")
+
+
+# mencetak pesan kesalahan/eksepsi bawaan python
+# gunakan keyword 'as' untuk memberi nama alias eksepsi
+try:
+ hasil = 5 / 0 # type: ignore
+ print("Hasil pembagian adalah =", hasil)
+except ZeroDivisionError as err:
+ print(err) # division by zero
+except TypeError as err:
+ print(err) # unsupported operand type(s) for /: 'int' and 'str'
+
+try:
+ hasil = 3 / "1" # type: ignore
+ print("Hasil pembagian adalah =", hasil)
+except (ZeroDivisionError, TypeError) as err:
+ # cetak pesan error tergantung jenis error yang ditangkap
+ print(err)
diff --git a/Basic/13_module/README.md b/Basic/13_module/README.md
new file mode 100644
index 00000000..4af4d88b
--- /dev/null
+++ b/Basic/13_module/README.md
@@ -0,0 +1,70 @@
+# Module (Modul)
+_Module_ adalah sebuah _file_ yang berekstensi `.py` yang berisi kumpulan fungsi, _class_ maupun variabel. Kegunaan dari _module_ adalah untuk memecah kode bagian besar menjadi bagian-bagian kecil ke dalam _file_ yang terpisah berekstensi `.py` agar mudah dikelola. _Module_ bersifat _reusable_ yang artinya dapat digunakan secara berulang dimanapun sesuai dengan kebutuhan.
+
+## Mendefinisikan modul
+Misalkan, terdapat kumpulan fungsi untuk melakukan perhitungan operasi aritmatika sederhana di dalam sebuah _file_ baru, misalkan `kalkulator.py`
+
+```python
+def tambah(angka1, angka2):
+ return angka1 + angka2
+
+
+def kurang(angka1, angka2):
+ return angka1 - angka2
+
+
+def kali(angka1, angka2):
+ return angka1 * angka2
+
+
+def bagi(angka1, angka2):
+ return angka1 / angka2
+
+```
+
+## Melakukan _import_ modul
+_File_ `kalkulator.py` yang sudah dibuat sebelumnya dapat digunakan pada _file_ yang lain. Buat _file_ baru yang namanya `perhitungan1.py`, dimana akan dilakukan _import file_ `kalkulator.py` menggunakan kata kunci `import` di awal baris kode yang diikuti dengan nama module, yaitu _file python_ tanpa eksetensi `.py` yang ingin dipanggil. Bentuk penulisannya adalah sebagai berikut
+
+```python
+import kalkulator
+```
+
+Saat modul `kalkulator` telah di-_import_, maka fungsi-fungsi di dalam modul tersebut dapat diakses menggunakan notasi titik. Sebagai contoh, jika ingin mengakses fungsi `tambah`, maka penulisannya menjadi `kalkulator.tambah(2, 3)`. Begitu pula jika ingin mengakses fungsi-fungsi yang lainnya, maka pemanggilan fungsinya sebagai berikut.
+
+```python
+print(kalkulator.tambah(2, 3))
+print(kalkulator.kurang(2, 3))
+print(kalkulator.kali(2, 3))
+print(kalkulator.bagi(10, 2))
+```
+
+Output:
+```
+5
+2
+18
+5.0
+```
+
+Selain menggunakan kata kunci `import`, pemanggilan modul dapat dilakukan dengan menggunakan pola `from ... import ...`, dimana kata kunci `from` diikuti dengan nama modul (_file python_) yang ingin dipanggil dan dilanjutkan dengan kata kunci `import` yang diikuti dengan nama _class_, fungsi dan variabel yang ingin digunakan secara spesifik pada modul tersebut. Sebagai contoh, buat _file_ baru yang namanya `perhitungan2.py`. Di dalam _file_ tersebut, dilakukan pemanggilan _file_ `kalkulator.py` beserta fungsi di dalamnya yang akan digunakan. Penulisan di awal baris kode adalah sebagai berikut:
+
+```python
+from kalkulator import tambah, kurang, kali, bagi
+```
+
+Penggunaan fungsi yang telah di-_import_ tanpa menggunakan notasi titik, sehingga menjadi sebagai berikut:
+```python
+print(tambah(2, 3))
+print(kurang(2, 3))
+print(kali(2, 3))
+print(bagi(10, 2))
+```
+
+Output:
+```
+5
+2
+18
+5.0
+```
+[Materi Selanjutnya](../14_python_datetime)
\ No newline at end of file
diff --git a/Basic/13_module/kalkulator.py b/Basic/13_module/kalkulator.py
new file mode 100644
index 00000000..242b4e48
--- /dev/null
+++ b/Basic/13_module/kalkulator.py
@@ -0,0 +1,14 @@
+def tambah(angka1, angka2):
+ return angka1 + angka2
+
+
+def kurang(angka1, angka2):
+ return angka1 - angka2
+
+
+def kali(angka1, angka2):
+ return angka1 * angka2
+
+
+def bagi(angka1, angka2):
+ return angka1 / angka2
diff --git a/Basic/13_module/perhitungan1.py b/Basic/13_module/perhitungan1.py
new file mode 100644
index 00000000..78716c63
--- /dev/null
+++ b/Basic/13_module/perhitungan1.py
@@ -0,0 +1,6 @@
+import kalkulator
+
+print(kalkulator.tambah(3, 2))
+print(kalkulator.kurang(4, 2))
+print(kalkulator.kali(3, 6))
+print(kalkulator.bagi(10, 2))
diff --git a/Basic/13_module/perhitungan2.py b/Basic/13_module/perhitungan2.py
new file mode 100644
index 00000000..532aca35
--- /dev/null
+++ b/Basic/13_module/perhitungan2.py
@@ -0,0 +1,6 @@
+from kalkulator import bagi, kali, kurang, tambah
+
+print(tambah(2, 3))
+print(kurang(2, 3))
+print(kali(2, 3))
+print(bagi(10, 2))
diff --git a/Basic/14_python_datetime/README.md b/Basic/14_python_datetime/README.md
new file mode 100644
index 00000000..a17f3f73
--- /dev/null
+++ b/Basic/14_python_datetime/README.md
@@ -0,0 +1,97 @@
+# Tanggal dan Waktu (_datetime_)
+
+_Datetime_ adalah suatu standar pustaka (standard library) bawaan _P ython_ untuk manipulasi tanggal dan waktu. Untuk menggunakannya, cukup `import` dari module `datetime`.
+
+```python
+import datetime
+```
+
+Setelah dilakukan _import_, fungsi-fungsi atau class di dalamnya dapat digunakan. Misalkan, jika ingin mengetahui waktu saat ini, gunakan fungsi `now()`.
+
+```python
+sekarang = datetime.datetime.now()
+print(sekarang)
+```
+
+Output:
+```
+2021-10-24 22:12:29.476245
+```
+
+Pada hasil output di atas, berisi informasi yang terdiri tahun, bulan, hari, jam, menit, detik, dan milidetik. Karena merupakan tipe objek dari `datetime`, ada beberapa fungsi maupun atribut untuk mengembalikan informasi mengenai objek `datetime` tersebut. Misalkan, jika ingin mengetahui tahun, bulan dan hari, maka gunakan atribut `year`, `month`, dan `day`
+
+```python
+print(sekarang.year)
+print(sekarang.month)
+print(sekarang.day)
+```
+
+## Format penulisan tanggal
+
+Modul `datetime` memungkinkan kita unuk menulis format tanggal sesuai yang diinginkan. Beberapa contoh penulisan tanggal adalah sebagai berikut:
+- 24-10-2021
+- 24/10/2021
+- 24 October 2021
+- dan lain sebagainya
+
+Untuk melakukannya, gunakan fungsi `strftime()`, yang menerima argument string format penulisan tanggal yang biasanya diawali dengan tanda `%` yang dapat disebut juga dengan _directive_. Misalkan, jika ingin mengubah format tanggal hari ini menjadi `DD-MM-YYYY`, maka contoh penggunaan fungsi adalah sebagai berikut:
+
+```python
+print(sekarang.strftime('%d-%m-%Y'))
+```
+
+Contoh kode program di atas, terdapat 3 directive yang dapat dijelaskan sebagai berikut:
+- `%d` : menampilkan tanggal dalam bentuk angka (01-31)
+- `%m` : menampilkan bulan dalam bentuk angka (01-12)
+- `%Y` : menampilkan tahun dalam versi lengkap (4 digit)
+
+Sehingga, jika kode di atas dieksekusi, maka hasilnya adalah sebagai berikut (hasil dapat berbeda tergantung tanggal saat ini)
+```
+24-10-2021
+```
+Format penulisan tanggal dan waktu lainnya dapat dilihat pada referensi berikut: [https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)
+
+## Membuat tanggal dan waktu sendiri
+Pada bagian sebelumnya, telah dijelaskan bagaimana mengetahui tanggal saat ini dan bentuk penulisannya. Untuk bagian ini, akan dibahas bagaimana mendefinisikan tanggal dan waktu yang akan kita buat. Masih menggunakan `datetime.datetime()`, misalkan kita mendefinisikan tanggal untuk hari kemerdekaan 17 Agustus 1945.
+
+```python
+import datetime
+
+hari_kemerdekaan = datetime.datetime(1945, 8, 17)
+```
+
+Sehingga, jika dicetak variabel `hari_kemerdekaan`, maka hasilnya adalah `1945-08-17`. Hasil tersebut dapat diubah format penanggalannya sesuai dengan cara yang dijelaskan pada bagian sebelumnya.
+
+## Operasi `datetime`
+Tanggal dan waktu dapat dioperasikan seperti operator aritmatika pada umumnya. Salah satu contoh penerapannya adalah operasi pengurangan untuk menghitung umur kita saat ini dengan mengurangkan dari tanggal hari ini terhadap tanggal lahir. Contoh, jika tanggal lahirnya 29 Desember 1997, maka program perhitungan umur adalah sebagai berikut:
+
+```python
+import datetime
+
+tanggal_lahir = datetime.datetime(1997, 12, 29)
+tanggal_sekarang = datetime.datetime.now()
+umur_sekarang = tanggal_sekarang - tanggal_lahir
+print(umur_sekarang)
+```
+
+Maka outputnya adalah `"8704 days, 12:49:29.801983"` (hasil dapat berbeda tergantung tanggal dieksekusi pada saat itu), yang berarti hasil pengurangannya adalah 8704 hari 12 jam 49 menit 29,801983 detik. Jika ingin menampilkan umur dalam tahun dan hari, maka langkah-langkahnya adalah sebagai berikut:
+- Ambil jumlah harinya menggunakan properti `days`.
+- Bagi jumlah hari tersebut dengan 365 menggunakan operator _floor division_ agar diperoleh hasil dalam tahun tipe integer.
+- Bagi jumlah hari tersebut dengan 365 menggunakan operator _modulus_ agar diperoleh sisa harinya.
+Sehingga, jika kode di atas dilanjutkan, maka akan menjadi sebagai berikut:
+
+```python
+jumlah_hari = umur_sekarang.days
+umur_tahun = jumlah_hari // 365
+sisa_hari = jumlah_hari % 365
+print("Umur saya adalah %d tahun %d hari" % (umur_tahun, sisa_hari))
+```
+
+Jika dieksekusi kode di atas, maka hasilnya adalah `"Umur saya adalah 23 tahun 309 hari"`.
+
+## Referensi
+Hal-hal lebih lanjut tentang modul tanggal dan waktu (_datetime_) ini dapat mengunjungi [dokumentasi](https://docs.python.org/3.9/library/datetime.html) berikut
+
+video penjelasan tentang modul datetime = [Belajar python dasar - mengenal modul datetime](https://www.youtube.com/watch?v=n9vTAmq3GHE&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=21)
+
+[Materi Selanjutnya](../15_python_math)
\ No newline at end of file
diff --git a/Basic/14_python_datetime/module_datetime.py b/Basic/14_python_datetime/module_datetime.py
new file mode 100644
index 00000000..304a9459
--- /dev/null
+++ b/Basic/14_python_datetime/module_datetime.py
@@ -0,0 +1,21 @@
+import datetime
+
+# mengetahui waktu sekarang
+sekarang = datetime.datetime.now()
+print(sekarang)
+
+# mengetahui tahun
+print(sekarang.year)
+
+# mengetahui bulan
+print(sekarang.month)
+
+# mengetahui hari
+print(sekarang.day)
+
+# format tanggal DD-MM-YYYY
+print(sekarang.strftime("%d-%m-%Y"))
+
+# mendefinisikan tanggal dan waktu
+hari_kemerdekaan = datetime.date(1945, 8, 17)
+print(hari_kemerdekaan)
diff --git a/Basic/14_python_datetime/perhitungan_umur.py b/Basic/14_python_datetime/perhitungan_umur.py
new file mode 100644
index 00000000..2609c628
--- /dev/null
+++ b/Basic/14_python_datetime/perhitungan_umur.py
@@ -0,0 +1,21 @@
+import datetime
+
+# tentukan tanggal lahir, misalkan 29 Des 1997
+tanggal_lahir = datetime.datetime(1997, 12, 29)
+
+# ambil waktu sekarang
+tanggal_sekarang = datetime.datetime.now()
+
+# hitung umurnya
+umur_sekarang = tanggal_sekarang - tanggal_lahir
+print(umur_sekarang)
+
+# ambil jumlah hari
+jumlah_hari = umur_sekarang.days
+
+# hitung umur dalam tahun
+umur_tahun = jumlah_hari // 365
+
+# hitung sisa hari
+sisa_hari = jumlah_hari % 365
+print("Umur saya adalah %d tahun %d hari" % (umur_tahun, sisa_hari))
diff --git a/Basic/15_python_math/README.md b/Basic/15_python_math/README.md
new file mode 100644
index 00000000..687d38cd
--- /dev/null
+++ b/Basic/15_python_math/README.md
@@ -0,0 +1,125 @@
+# Fungsi Matematika (_math_)
+
+Ada kalanya ketika kita akan melakukan perhitungan numerik yang teknis atau saintifik. Perhitungan tersebut seperti trigonometri, eksponen, logaritma, pembulatan bilangan, dan lain sebagainya. Bahasa pemrograman Python menyediakan sebuah standar pustaka (_standard library_) yang memungkinkan kita untuk melakukan operasi perhitungan tersebut. Modul tersebut adalah `math`, dimana terdapat fungsi-fungsi matematis yang dapat digunakan. Gunakan keyword `import` untuk menggunakan modul tersebut.
+```python
+import math
+```
+
+Kali ini, kita akan menggunakan beberapa fungsi yang sering digunakan untuk melakukan operasi fungsi matematis yang dasar.
+
+## Nilai Konstanta
+Konstanta merupakan nilai tetap yang ditemukan ilmuan setelah melalui serangkaian proses penelitian. Terdapat nilai konstanta yang disediakan oleh modul Python, yaitu:
+- `math.pi` : Nilai konstanta dari $\pi$ = 3.141592... dengan nilai yang lebih presisi. Nilai ini biasanya digunakan untuk konversi satuan radian ke derajat, menghitung keliling dan luas lingkaran, volume bola, volume tabung, dan lain sebagainya.
+- `math.e` : Nilai konstanta dari _e_ = 2.71828... dengan nilai yang lebih presisi. Dapat disebut juga sebagai konstanta Euler. Nilai ini biasanya digunakan untuk perhitungan bunga bank, menghitung jumlah penduduk suatu negara, mengukur peluruhan unsur radioaktif, dan lain sebagainya.
+- `math.tau` : Nilai konstanta yang setara dengan 2 kali dari nilai $\pi$, yaitu $\tau$ = 6.283185..., untuk mengetahui lebih lanjut tentang bilangan ini, tonton video dari Vi Hart berikut [Pi is (still) Wrong](https://www.youtube.com/watch?v=jG7vhMMXagQ).
+- `math.inf` : Merupakan nilai positif tak terhingga (_infinity_). Untuk nilai negatif tak terhingga, gunakan `-math.inf`.
+- `math.nan` : Merupakan nilai yang bukan merupakan angka (_not a number/NaN_). Ini ekuivalen dengan `float('nan')`.
+
+```python
+import math
+
+print(math.pi)
+print(math.e)
+print(math.tau)
+print(math.inf)
+print(-math.inf)
+print(math.nan)
+```
+
+Output:
+```
+3.141592653589793
+2.718281828459045
+6.283185307179586
+inf
+-inf
+nan
+```
+
+## Pembulatan
+Nilai bilangan desimal (_float_) dapat dibulatkan baik ke atas maupun ke bawah. Modul `math` menyediakan fungsi untuk melakukan itu, yaitu:
+- `math.floor(x)` : Sesuai dengan namanya (_floor_ = lantai), fungsi ini untuk membulatkan bilangan ke bawah, dimana `x` adalah tipe data _float_. Contoh nilai 14.8 akan dibulatkan ke bawah menjadi 14.
+- `math.ceil(x)` : Sesuai dengan namanya (_ceil_ = langit atau genteng), fungsi ini untuk membulatkan bilangan ke atas, dimana `x` adalah tipe data _float_. Contoh nilai 14.3 akan dibulatkan ke atas menjadi 15.
+
+```python
+import math
+
+print(math.floor(14.8))
+print(math.floor(14.3))
+```
+
+Output:
+```
+14
+15
+```
+
+## Konversi Satuan Sudut
+Sudut dapat dikonversikan dari satuan derajat ke radian, maupun sebaliknya. Fungsi yang digunakan adalah `degrees()` dan `radians()`.
+- `math.degrees(x)` : Mengkonversikan sudut dari `x` radian ke derajat.
+- `math.radians(x)` : Mengkonversikan sudut dari `x` derajat ke radian.
+
+Nilai konstanta dari `pi` (pada penjelasan sebelumnya tentang "Nilai Konstanta") diperlukan untuk melakukan konversi satuan sudut dari radian ke derajat. Seperti diketahui, besar sudut dari 2 $\pi$ radian = 360 derajat, maka jika ingin melakukan konversi dari nilai 2 $\pi$ radian dan outputnya 360 derajat, gunakan konstanta dari `pi` tersebut. Berikut contoh penggunaan dari fungsi `degrees()` dan `radians()`.
+
+```python
+import math
+
+print(math.degrees(2 * math.pi))
+print(math.radians(90))
+```
+
+Output:
+```
+360.0
+1.5707963267948966
+```
+
+## Trigonometri
+Modul `math` memiliki fungsi trigonometri seperti _sinus_, _cosinus_ dan _tangen_. Fungsi yang digunakan adalah `sin(x)`, `cos(x)` dan `tan(x)`. Dimana nilai `x` adalah sudut tipe _float_ dengan satuan radian. Misalkan, jika ingin mengetahui nilai kosinus dari sudut 30 derajat, maka nilai 30 derajat tersebut harus dikonversikan terlebih dahulu menjadi radian seperti yang dijelaskan pada bagian sebelumnya tentang "Konversi Satuan Sudut".
+
+```python
+import math
+
+sudut_30 = math.radians(30)
+print(math.sin(sudut_30))
+print(math.cos(sudut_30))
+print(math.tan(sudut_30))
+```
+
+Output:
+```
+0.49999999999999994
+0.8660254037844387
+0.5773502691896257
+```
+
+## Eksponen dan Logaritma
+Eksponen merupakan perpangkatan x terhadap y yang dinotasikan sebagai $x^y$. Sedangkan logaritma merupakan kebalikan dari perpangkatan, dengan bilangan pokok b dan basis a yang dinotasikan sebagai $^a\log_b$. Contoh, jika $5^3$ maka hasilnya 125. Jika diubah dalam bentuk logaritma, maka $^5\log_{125}$ hasilnya adalah 3.
+
+Contoh diatas, dapat dilakukan menggunakan modul bantuan `math`. Beberapa fungsi dasar eksponen dan logaritma yang disediakan adalah sebagai berikut.
+- `math.sqrt(x)` : Memperoleh hasil akar kuadrat dari bilangan `x` ($\sqrt x$)
+- `math.pow(x, y)`: Memperoleh hasil pangkat antara x dan y ($x^y$)
+- `math.log10(x)` : Memperoleh hasil logaritma dari `x` yang bilangan basisnya 10 ($\log_x$)
+- `math.log(x, y)` : Memperoleh hasil logaritma dari `x` yang bilangan basisnya `y` ($^y\log_x$)
+
+```python3
+import math
+
+print(math.sqrt(25))
+print(math.pow(5, 3))
+print(math.log10(1000))
+print(math.log(125, 5))
+```
+
+Output:
+```
+5.0
+125.0
+3.0
+3.0000000000000004
+```
+
+## Referensi
+Informasi lebih lanjut tentang penggunaan modul `math` ini, silahkan mengunjungi dokumentasi resmi dari Python [di sini](https://docs.python.org/3.9/library/math.html)
+
+[Materi Selanjutnya](../16_class)
\ No newline at end of file
diff --git a/Basic/15_python_math/math_eksponen_logaritma.py b/Basic/15_python_math/math_eksponen_logaritma.py
new file mode 100644
index 00000000..ce986c48
--- /dev/null
+++ b/Basic/15_python_math/math_eksponen_logaritma.py
@@ -0,0 +1,6 @@
+import math
+
+print(math.sqrt(25))
+print(math.pow(5, 3))
+print(math.log10(1000))
+print(math.log(125, 5))
diff --git a/Basic/15_python_math/math_konstanta.py b/Basic/15_python_math/math_konstanta.py
new file mode 100644
index 00000000..e6c2f12e
--- /dev/null
+++ b/Basic/15_python_math/math_konstanta.py
@@ -0,0 +1,8 @@
+import math
+
+print(math.pi)
+print(math.e)
+print(math.tau)
+print(math.inf)
+print(-math.inf)
+print(math.nan)
diff --git a/Basic/15_python_math/math_konversi_sudut.py b/Basic/15_python_math/math_konversi_sudut.py
new file mode 100644
index 00000000..0df5ffa1
--- /dev/null
+++ b/Basic/15_python_math/math_konversi_sudut.py
@@ -0,0 +1,4 @@
+import math
+
+print(math.degrees(2 * math.pi))
+print(math.radians(90))
diff --git a/Basic/15_python_math/math_pembulatan.py b/Basic/15_python_math/math_pembulatan.py
new file mode 100644
index 00000000..2f819785
--- /dev/null
+++ b/Basic/15_python_math/math_pembulatan.py
@@ -0,0 +1,4 @@
+import math
+
+print(math.floor(14.8))
+print(math.ceil(14.3))
diff --git a/Basic/15_python_math/math_trigonometri.py b/Basic/15_python_math/math_trigonometri.py
new file mode 100644
index 00000000..45958647
--- /dev/null
+++ b/Basic/15_python_math/math_trigonometri.py
@@ -0,0 +1,6 @@
+import math
+
+sudut_30 = math.radians(30)
+print(math.sin(sudut_30))
+print(math.cos(sudut_30))
+print(math.tan(sudut_30))
diff --git a/Basic/16_class/README.md b/Basic/16_class/README.md
new file mode 100644
index 00000000..24eab77a
--- /dev/null
+++ b/Basic/16_class/README.md
@@ -0,0 +1,66 @@
+## Class (Kelas)
+
+Kelas dapat diartikan sebagai kerangka untuk membuat suatu objek, membuat suatu kelas sama dengan membuat tipe baru, dan meng-inisialisasi tipe tersebut sama dengan menghasilkan objek baru.
+
+Kelas memiliki atribut untuk mempertahankan nilainya, dan memilki metode untuk mengubah nilainya. Untuk membuat class di python dapat menggunakan keyword class.
+
+# Atribut
+
+Atribut adalah variable dan fungsi yang ada didalam kelas, seluruh atribut bersifat publik dan dapat diakses menggunakan tanda titik (.) dibelakang objek. Note: atribut yang diawali dengan `_` umumnya dianggap *private*; tidak dimaksudkan untuk digunakan di luar kelas.
+
+# Metode
+
+Metode adalah fungsi yang dibuat didalam kelas, karena metode adalah fungsi maka untuk membuatnya menggunakan keyword def.
+
+Ada 3 jenis metode class, yaitu:
+
+- instance method
+
+Metode ini harus memiliki parameter self, yang berguna untuk mengakses atribut objek, untuk menggunakannya harus melalui objek.
+
+- classmethod
+
+Metode ini menggunakan deokrator @classmethod dan harus memiliki parameter cls, yang berguna untuk mengakses atributnya, untuk menggunakannya dapat langsung dari kelasnya tanpa menggunakan objek.
+
+- staticmethod
+
+Metode ini menggunakan dekorator @staticmethod, metode ini sama seperti classmethod namun tidak perlu menggunakan parameter wajib.
+
+## Konstruktor dan Destruktor
+
+- konstruktor
+
+Konstruktor adalah metode yang dipanggil saat membuat suatu objek, konstruktor dapat berguna untuk meminta atribut apa saja yang diperlukan saat membuat objek. Membuat konstruktor dapat menggunakan dunder-method init dan harus memiliki parameter self, juga dapat memiliki parameter tambahan.
+
+- destruktor
+
+Destruktor adalah metode yang dipanggil saat suatu objek dihapus, untuk membuat destruktor dapat menggunakan dunder-method del dan memiliki parameter self.
+
+
+## menggunakan metode dunder atau magic method
+Metode dunder atau magic method dalam Python adalah metode yang memiliki dua garis bawah awalan dan akhiran dalam nama metode. Dunder disini berarti “Double Under (Underscores)”.
+
+contoh:
+```
+__add__, __repr__, __len__
+```
+
+contoh penggunaan dari dunder method:
+```python
+class Hewan:
+ def __init__(self, nama_hewan, suara):
+ self.nama_hewan = nama_hewan
+ self.suara = suara
+
+ def __repr__(self):
+ return "kucing {} bersuara {}".format(self.nama_hewan, self.suara)
+
+
+if __name__ == "__main__":
+ hewan = Hewan("sapi", "Mooo")
+ print(f" {hewan.nama_hewan} bersuara :{hewan.suara}")
+```
+
+Teman-teman bisa belajar lebih lanjut seputar class [di sini](https://www.youtube.com/watch?v=upngNSC9FU8&list=PLZS-MHyEIRo7ab0-EveSvf4CLdyOECMm0&index=3) dan method [di sini](https://www.youtube.com/watch?v=DE-h_oR8Nmo&list=PLZS-MHyEIRo7ab0-EveSvf4CLdyOECMm0&index=4)
+
+[Materi Selanjutnya](../17_inheritance)
\ No newline at end of file
diff --git a/Basic/16_class/class.py b/Basic/16_class/class.py
new file mode 100644
index 00000000..74b005e1
--- /dev/null
+++ b/Basic/16_class/class.py
@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod, abstractproperty
+
+
+# Kelas abstrak hewan, tidak dapat di-inisialisasi dan hanya berupa instance
+class Hewan(ABC):
+ # Properti abstrak
+ @abstractproperty
+ def suara(self):
+ pass
+
+ # Metode abstrak
+ @abstractmethod
+ def bersuara(self):
+ pass
+
+
+# Menggunakan pewarisan dari kelas Hewan
+class Kucing(Hewan):
+ # Mengimplementasikan properti suara
+ @property
+ def suara(self):
+ return "MIAWW MIAWW"
+
+ # Mengimplementasikan atribut bersuara
+ def bersuara(self):
+ print(self.suara)
+
+
+# contoh membuat objek
+tomcat = Kucing()
+
+# mengakses metode bersuara
+tomcat.bersuara()
+# output: "MIAWW MIAWW"
diff --git a/Basic/16_class/const_desct.py b/Basic/16_class/const_desct.py
new file mode 100644
index 00000000..14b7ca0c
--- /dev/null
+++ b/Basic/16_class/const_desct.py
@@ -0,0 +1,45 @@
+class Warung:
+ def __init__(self, owner, alamat):
+ self.owner = owner
+ self.alamat = alamat
+ self.menu = []
+
+ def __del__(self):
+ print("Warung dihapus, data terakhir warung:", self.data())
+
+ def tambah_menu(self, makanan):
+ """
+ metode ini berfungsi untuk menambahkan data
+ ke atribut menu_makanan
+ makanan = string
+ """
+ self.menu.append(makanan)
+
+ def data(self):
+ """
+ metode ini berfungsi untuk mengembalikan data
+ seluruh atribut warung dalam bentuk dict.
+ """
+ return {"alamat warung": self.alamat, "owner": self.owner, "menu": self.menu}
+
+
+# membuat objek dan meng-inisialisasi-nya
+kedai_atuk = Warung(owner="Atuk Daka", alamat="Jl. Apel No. 23")
+
+# mengakses metode tambah_menu untuk menambahkan menu
+kedai_atuk.tambah_menu("kopi susu")
+kedai_atuk.tambah_menu("roti bakar")
+
+# mengakses metode data untuk melihat data warung
+data_kedai_atuk = kedai_atuk.data()
+print(data_kedai_atuk)
+# output: {'alamat warung': 'Jl. Apel No. 23',
+# 'owner': 'Atuk Daka',
+# 'menu': ['kopi susu', 'roti bakar']}
+
+# menghapus objek warung
+del kedai_atuk
+# output: Warung dihapus, data terakhir warung:
+# {'alamat warung': 'Jl. Apel No. 23',
+# 'owner': 'Atuk Daka',
+# 'menu': ['kopi susu', 'roti bakar']}
diff --git a/Basic/16_class/dunder_method.py b/Basic/16_class/dunder_method.py
new file mode 100644
index 00000000..ffe65d5f
--- /dev/null
+++ b/Basic/16_class/dunder_method.py
@@ -0,0 +1,12 @@
+class Hewan:
+ def __init__(self, nama_hewan, suara):
+ self.nama_hewan = nama_hewan
+ self.suara = suara
+
+ def __repr__(self):
+ return f"kucing {self.nama_hewan} bersuara {self.suara}"
+
+
+if __name__ == "__main__":
+ hewan = Hewan("sapi", "Mooo")
+ print(f" {hewan.nama_hewan} bersuara :{hewan.suara}")
diff --git a/Basic/16_class/methods.py b/Basic/16_class/methods.py
new file mode 100644
index 00000000..d28b273f
--- /dev/null
+++ b/Basic/16_class/methods.py
@@ -0,0 +1,41 @@
+class SegiEmpat:
+ def __init__(self, panjang, lebar):
+ self.panjang = panjang
+ self.lebar = lebar
+
+ def hitung_luas(self):
+ """
+ metode ini akan mengembalikan luas bangun menggunakan
+ hasil perkalian panjang dan lebar
+ """
+ return self.panjang * self.lebar
+
+ @classmethod
+ def kotak(cls, sisi):
+ """
+ metode ini akan mengembalikan suatu objek kotak
+ """
+ return cls(sisi, sisi)
+
+ @staticmethod
+ def jenis_bangun(panjang, lebar):
+ """
+ metode ini akan mengembalikan jenis segiempat, apakah
+ persegi atau persegipanjang
+ """
+ return "persegi" if panjang == lebar else "persegi panjang"
+
+
+print(SegiEmpat.jenis_bangun(10, 5))
+# output: persegi panjang
+
+persegi_panjang = SegiEmpat(10, 5)
+print(persegi_panjang.hitung_luas())
+# output: 50
+
+print(SegiEmpat.jenis_bangun(3, 3))
+# output: persegi
+
+persegi = SegiEmpat.kotak(3)
+print(persegi.hitung_luas())
+# output: 9
diff --git a/Basic/17_inheritance/README.md b/Basic/17_inheritance/README.md
new file mode 100644
index 00000000..5ce0fbee
--- /dev/null
+++ b/Basic/17_inheritance/README.md
@@ -0,0 +1,48 @@
+# Inheritance
+Warisan memungkinkan kita untuk mendefinisikan kelas yang mewarisi semua metode dan properti dari kelas lain.
+
+Kelas induk adalah kelas yang diwarisi, juga disebut kelas dasar.
+
+Kelas anak adalah kelas yang mewarisi dari kelas lain, juga disebut kelas turunan.
+
+contoh:
+
+```python
+class Merk(object):
+ def __init__(self):
+ self.nama = "calvin klein"
+
+class Panggil(Merk):
+ def __init__(self):
+ Merk.__init__(self)
+
+ def tampilkan(self):
+ print(self.nama)
+
+data = Panggil()
+data.tampilkan()
+```
+
+informasi:
+- ``class Merk(object)``
+ Merupakan parent utama dari inheritance dengan mendeklarasikan variabel nama dengan value ``"calvin klein"``
+
+- ``class Panggil(Merk)``
+ Merupakan child parent yang memanggil parent class utama
+
+ - ``Merk.__init__(self)``
+ merupakan konstruktor pemanggil parent class atau kelas induk
+
+ - ``def tampilkan(self)``
+ memanggil dari variabel dari parent class atau kelas induk yang berupa ``self.nama`` yang berisi value string (``calvin klein``)
+
+- ``data = Panggil()``
+ Deklarasi variabel baru dengan memanggil kelas ``Panggil()``
+
+- ``data.tampilkan()``
+
+ Memanggil fungsi dari tampilkan dari kelas ``Panggil()``, kemudian menampilkan berupa variabel dari parent class atau kelas induk dari ``Merk`` yang berisi value berupa ``calvin klein``
+
+Teman-teman bisa belajar lebih lanjut tentang inheritance [di sini](https://www.youtube.com/watch?v=G6fmTwxx8rw&list=PLZS-MHyEIRo7ab0-EveSvf4CLdyOECMm0&index=12), super method [di sini](https://www.youtube.com/watch?v=pjHk9CrB1JE&list=PLZS-MHyEIRo7ab0-EveSvf4CLdyOECMm0&index=13), dan override [di sini](https://www.youtube.com/watch?v=sYKhxqcDu3w&list=PLZS-MHyEIRo7ab0-EveSvf4CLdyOECMm0&index=14)
+
+[Materi Selanjutnya](../18_akses_modifikasi/public)
\ No newline at end of file
diff --git a/Basic/17_inheritance/inheritance_python.py b/Basic/17_inheritance/inheritance_python.py
new file mode 100644
index 00000000..ccd4cb1d
--- /dev/null
+++ b/Basic/17_inheritance/inheritance_python.py
@@ -0,0 +1,28 @@
+# kelas induk
+class Siswa:
+ # __init__ sebagai constructor
+ def __init__(self, nama, kelas, jenis_kelamin):
+ self.nama = nama
+ self.kelas = kelas
+ self.jenis_kelamin = jenis_kelamin
+
+
+# child class atau kelas non induk
+# membuat kategori siswa berdasarkan dari
+# kelas induk
+class KategoriSiswa(Siswa):
+ def __init__(self):
+ # memanggil constructor dari kelas induk
+ Siswa.__init__(self, "arfy", 12, "laki-laki")
+
+ # mmenampilkan hasil dari kelas induk
+ def tampilkan(self):
+ print(self.nama)
+ print(self.kelas)
+ print(self.jenis_kelamin)
+
+
+# deklarasi objek
+data = KategoriSiswa()
+# memanggil objek
+data.tampilkan()
diff --git a/Basic/18_akses_modifikasi/01_public/README.md b/Basic/18_akses_modifikasi/01_public/README.md
new file mode 100644
index 00000000..84f5356a
--- /dev/null
+++ b/Basic/18_akses_modifikasi/01_public/README.md
@@ -0,0 +1,21 @@
+# public modifier
+
+Anggota kelas yang dideklarasikan publik mudah diakses dari bagian mana pun dari program. Semua anggota data dan fungsi anggota kelas bersifat publik secara default.
+
+```python
+class NamaSaya:
+ def __init__(self, nama, umur):
+ self.nama_saya = name
+ self.umur_saya = umur
+
+ def tampil_nama(self):
+ print(f"Apa kabar {self.nama_saya}")
+
+objek_kelas = NamaSaya("yoga", 31)
+objek_kelas.tampil_nama()
+print("Umur saya adalah ", objek_kelas.umur_saya)
+```
+
+Dalam program di atas, ``nama_saya`` dan ``umur_saya`` adalah anggota data publik dan metode ``tampil_nama()`` adalah fungsi anggota publik dari kelas ``NamaSaya``. Data anggota kelas ``NamaSaya`` ini dapat diakses dari mana saja dalam program.
+
+[Materi Selanjutnya](../02_private)
\ No newline at end of file
diff --git a/Basic/18_akses_modifikasi/01_public/public.py b/Basic/18_akses_modifikasi/01_public/public.py
new file mode 100644
index 00000000..978bc762
--- /dev/null
+++ b/Basic/18_akses_modifikasi/01_public/public.py
@@ -0,0 +1,12 @@
+class NamaSaya:
+ def __init__(self, nama, umur):
+ self.nama_saya = nama
+ self.umur_saya = umur
+
+ def tampil_nama(self):
+ print(f"Apa kabar {self.nama_saya}")
+
+
+objek_kelas = NamaSaya("yoga", 31)
+objek_kelas.tampil_nama()
+print("Umur saya adalah ", objek_kelas.umur_saya)
diff --git a/Basic/18_akses_modifikasi/02_private/README.md b/Basic/18_akses_modifikasi/02_private/README.md
new file mode 100644
index 00000000..4ab459c3
--- /dev/null
+++ b/Basic/18_akses_modifikasi/02_private/README.md
@@ -0,0 +1,43 @@
+# private access
+
+Anggota kelas private menggunakan variabel deklarasi objek berupa tanda dua underscore ``__`` pada bagian depan objek dan menyatakan bahwa objek tersebut otomatis hanya akan bisa diakses oleh sebuah kelas dan turunannya saja.
+
+```python
+class PekerjaTambang:
+ # private variabel
+ __nama = None
+ __jabatan = None
+
+ # konstruktor
+ def __init__(self, nama, jabatan):
+ self.__nama = nama
+ self.__jabatan = jabatan
+
+ # membuat fungsi yang bersifat private
+
+ def __menampilkan(self):
+ # memangakses private objek
+ print("Nama: ",self.__nama)
+ print("Jabatan: ",self.__jabatan)
+
+ # fungsi yang bersifat publik
+
+ def menampilkan_data(self):
+ self.__menampilkan()
+
+# membuat objek dan menampilkannya
+pekerja1 = PekerjaTambang("James", "Research")
+
+# menampilkan objek yang dimana terdapat fungsi private
+pekerja1.menampikan_data()
+```
+
+Variabel dari ``__nama``, ``__jabatan`` adalah salah satu variabel yang hanya bisa diakses di dalam kelas (termasuk fungsi dari ``__menampilkan``, ini hanya bisa diakses di dalam kelas ``PekerjaTambang``), sementara fungsi ``menampilkan_data`` bisa diakses di luar atau di dalam kelas dikarenakan bersifat publik sehingga bisa diakses dari luar dengan membuat objek dan menampilkan hasil dari fungsi private yaitu ``__menampilkan``. Jika kita menambahkan kode lagi di bawah dengan memanggil fungsi dari ``__menampilkan`` makan akan terjadi error karena kelas tersebut bersifat private. Contoh error yang dihasilkan adalah:
+```
+Traceback (most recent call last):
+ File "file_saya.py", line x, in
+ pekerja1.__menampilkan()
+AttributeError: 'PekerjaTambang' object has no attribute '__menampilkan'
+```
+
+[Materi Selanjutnya](../03_protected)
\ No newline at end of file
diff --git a/Basic/18_akses_modifikasi/02_private/private.py b/Basic/18_akses_modifikasi/02_private/private.py
new file mode 100644
index 00000000..bd358c2e
--- /dev/null
+++ b/Basic/18_akses_modifikasi/02_private/private.py
@@ -0,0 +1,28 @@
+class PekerjaTambang:
+ # private variabel
+ __nama = None
+ __jabatan = None
+
+ # konstruktor
+ def __init__(self, nama, jabatan):
+ self.__nama = nama
+ self.__jabatan = jabatan
+
+ # membuat fungsi yang bersifat private
+
+ def __menampilkan(self):
+ # memangakses private objek
+ print("Nama: ", self.__nama)
+ print("Jabatan: ", self.__jabatan)
+
+ # fungsi yang bersifat publik
+
+ def menampilkan_data(self):
+ self.__menampilkan()
+
+
+# membuat objek dan menampilkannya
+pekerja1 = PekerjaTambang("James", "Research")
+
+# menampilkan objek yang dimana terdapat fungsi private
+pekerja1.menampilkan_data()
diff --git a/Basic/18_akses_modifikasi/03_protected/README.md b/Basic/18_akses_modifikasi/03_protected/README.md
new file mode 100644
index 00000000..aba1e933
--- /dev/null
+++ b/Basic/18_akses_modifikasi/03_protected/README.md
@@ -0,0 +1,44 @@
+# Protected access
+
+Anggota kelas yang dideklarasikan protected hanya dapat diakses oleh kelas turunannya. Anggota data dari suatu kelas dinyatakan terlindungi dengan menambahkan satu simbol underscore ``_`` sebelum anggota data dari kelas tersebut.
+
+```python
+class PekerjaTambang:
+ # protected variabel
+ _nama = None
+ _jabatan = None
+
+ # membuat konstruktor
+ def __init__(self, nama, jabatan):
+ self._nama = nama
+ self._jabatan = jabatan
+
+ # membuat fungsi protected
+ def _menampilkan(self):
+ print("jabatan: ", self._jabatan)
+
+
+# kelas turunan dari pekerja tambang
+class Pekerja(PekerjaTambang):
+
+ # membuat konstruktor
+ def __init__(self, nama, jabatan):
+ PekerjaTambang.__init__(self, nama, jabatan)
+
+ # membuat fungsi publik
+ def menampilkan(self):
+ print("nama: ", self._nama)
+ # menampilkan fungsi protected dari kelas Pekerja Tambang
+ self._menampilkan()
+
+
+# membuat variabel yang membuat objek dari pekerja
+pekerja1 = Pekerja("james", "driller")
+
+# menampikan
+pekerja1.menampilkan()
+```
+
+Di atas, ``_nama``, ``_jabaran`` adalah anggota data yang protected dan metode ```_menampilkan()``` adalah metode yang dilindungi dari kelas ``Pekerja``. Metode ``menampilkan()`` adalah fungsi anggota publik dari kelas ``Pekerja()`` yang diturunkan dari kelas ``PekerjaTambang``, metode ``menampilkan()`` di kelas ``Pekerja`` mengakses data anggota kelas ``PekerjaTambang`` yang protected.
+
+[Materi Selanjutnya](../../19_iterator)
\ No newline at end of file
diff --git a/Basic/18_akses_modifikasi/03_protected/protected.py b/Basic/18_akses_modifikasi/03_protected/protected.py
new file mode 100644
index 00000000..7d6e5809
--- /dev/null
+++ b/Basic/18_akses_modifikasi/03_protected/protected.py
@@ -0,0 +1,33 @@
+class PekerjaTambang:
+ # protected variabel
+ _nama = None
+ _jabatan = None
+
+ # membuat konstruktor
+ def __init__(self, nama, jabatan):
+ self._nama = nama
+ self._jabatan = jabatan
+
+ # membuat fungsi protected
+ def _menampilkan(self):
+ print("jabatan: ", self._jabatan)
+
+
+# kelas turunan dari pekerja tambang
+class Pekerja(PekerjaTambang):
+ # membuat konstruktor
+ def __init__(self, nama, jabatan):
+ PekerjaTambang.__init__(self, nama, jabatan)
+
+ # membuat fungsi publik
+ def menampilkan(self):
+ print("nama: ", self._nama)
+ # menampilkan fungsi protected dari kelas Pekerja Tambang
+ self._menampilkan()
+
+
+# membuat variabel yang membuat objek dari pekerja
+pekerja1 = Pekerja("james", "driller")
+
+# menampikan
+pekerja1.menampilkan()
diff --git a/Basic/19_iterator/README.md b/Basic/19_iterator/README.md
new file mode 100644
index 00000000..56cbbdb4
--- /dev/null
+++ b/Basic/19_iterator/README.md
@@ -0,0 +1,39 @@
+# Iterator
+
+Iterator adalah objek yang berisi sesuatu yang bisa dihitung atau *iterable*.
+
+Objek *iterable* adalah String, List, Tuple, Set, Dictionary.
+
+contoh dari penggunaan iterator:
+```py
+nama_maintainer = ("majed", "permen", "kelvin", "hen")
+show = iter(nama_maintainer)
+print(next(show))
+print(next(show))
+print(next(show))
+print(next(show))
+```
+
+menggunakan `__iter__()`
+```py
+class AngkaSaya:
+ def __iter__(self):
+ self.angka = 1
+ return self
+
+ def __next__(self):
+ nomor = self.angka
+ self.angka += 1
+ return nomor
+
+kelas_angka = AngkaSaya()
+test_iter = iter(kelas_angka)
+
+print(next(test_iter))
+print(next(test_iter))
+print(next(test_iter))
+```
+
+untuk lebih jelasnya kamu bisa lihat [disini](iterator.py)
+
+[Materi Selanjutnya](../20_lambda)
\ No newline at end of file
diff --git a/Basic/19_iterator/iterator.py b/Basic/19_iterator/iterator.py
new file mode 100644
index 00000000..1c9ab469
--- /dev/null
+++ b/Basic/19_iterator/iterator.py
@@ -0,0 +1,48 @@
+fruits = ("apple", "banana", "cherry")
+
+# fungsi iter() disini digunakan untuk membuat iterator
+fruits_iter = iter(fruits)
+
+# mengecek tipe data fruits_iter
+print("Tipe data dari fruits_iter:", fruits_iter)
+
+# Untuk mengakses isi dari iterator kita menggunakan fungsi next
+print(next(fruits_iter))
+print(next(fruits_iter))
+print(next(fruits_iter))
+
+# Kita juga dapat menggunakan for loop untuk mengulang suatu objek
+
+print("\nMenggunakan For Loop:")
+
+# hasil kode ini sama dengan yang diatas
+for fruit in fruits:
+ print(fruit)
+
+
+# iterator juga bisa kita kustomisasi pada class
+class MyNumbers:
+ # dunder method iter
+ def __iter__(self):
+ self.fruits = ["apple", "banana", "cherry"]
+ self.counter = 0
+ return self
+
+ # dunder method next
+ def __next__(self):
+ if self.counter < len(self.fruits):
+ x = self.fruits[self.counter]
+ self.counter += 1
+ return x
+ else:
+ # StopIteration digunakan untuk menghentikan iterator
+ raise StopIteration
+
+
+myclass = MyNumbers()
+myiter = iter(myclass)
+
+print("\nMengulang menggunakan Class:")
+print(next(myiter))
+print(next(myiter))
+print(next(myiter))
diff --git a/Basic/20_lambda/README.md b/Basic/20_lambda/README.md
new file mode 100644
index 00000000..10421dbb
--- /dev/null
+++ b/Basic/20_lambda/README.md
@@ -0,0 +1,47 @@
+# Lambda function
+
+Lambda function atau dikenal juga dengan anonymous function
+adalah sebuah function yang bisa menerima multiple arguments
+tetapi hanya bisa melakukan satu ekspresi atau satu eksekusi.
+
+Pada contoh berikut, kita melakukan perhitungan luas persegi
+dengan satu argument yaitu sisi (s) dan satu ekspresi sisi*sisi.
+
+```python
+luas_persegi = lambda s: s ** 2
+print(luas_persegi(4))
+```
+
+Contoh dari lambda function yang bisa menerima multiple argument
+yaitu lambda function luas segitiga
+
+```python
+luas_segitiga = lambda a, t: (a * t) / 2
+print(luas_segitiga(2, 3))
+```
+
+Lambda sendiri bisa menerima argumen secara tak terbatas
+seperti pada contoh:
+
+```python
+infinite = lambda *input: sum(input)
+print(infinite(1, 2, 3))
+print(infinite(1, 2, 3, 4))
+```
+
+Bisa juga menerima argumen dengan keyword
+```python
+key_inf = lambda **kwargs: sum(kwargs.values())
+print(key_inf(satu=1, dua=2, tiga=3)) # 6
+print(key_inf(seven=7, eight=8, nine=9, ten=10)) # 34
+```
+
+Contoh penerapannya bisa kita lihat pada fungsi ```filter()```
+yaitu
+```python
+li = [i for i in range(10)]
+beyond_five = list(filter(lambda x: (x > 5), li))
+print(beyond_five)
+```
+
+[Materi Selanjutnya](../21_regex)
\ No newline at end of file
diff --git a/Basic/20_lambda/lambda.py b/Basic/20_lambda/lambda.py
new file mode 100644
index 00000000..fb461d19
--- /dev/null
+++ b/Basic/20_lambda/lambda.py
@@ -0,0 +1,38 @@
+# flake8: noqa
+
+# lambda function atau dikenal juga dengan anonymous function
+# adalah function yang bisa menerima multiple arguments
+# tapi hanya bisa melakukan 1 expression
+
+# seperti contoh pada lambda luas_persegi dibawah
+# hanya input s, dan satu expresi yaitu, s * s
+
+luas_persegi = lambda s: s**2
+print(luas_persegi(4)) # 16
+
+# bukti dari lambda bisa menerima multiple argument adalah
+# pada luas_segitiga, argument nya itu a dan t
+
+luas_segitiga = lambda a, t: (a * t) / 2
+print(luas_segitiga(2, 3)) # 3.0
+
+# disamping itu, lambda function juga bisa menerima
+# unlimited argument seperti contoh dibawah
+
+infinite = lambda *input: sum(input)
+print(infinite(1, 2, 3)) # 6
+print(infinite(1, 2, 3, 4)) # 10
+
+# dan bisa juga unlimited argument dengan keyword
+
+key_inf = lambda **kwargs: sum(kwargs.values())
+print(key_inf(satu=1, dua=2, tiga=3)) # 6
+print(key_inf(seven=7, eight=8, nine=9, ten=10)) # 34
+
+# contoh penerapan dari lambda function yaitu
+# melakukan proses filterisasi dimana yang ditampilkan hanya
+# bilangan yang lebih besar dari 5, memakai filter()
+
+li = [i for i in range(10)]
+beyond_five = list(filter(lambda x: (x > 5), li))
+print(beyond_five) # [6,7,8,9]
diff --git a/Basic/21_regex/README.md b/Basic/21_regex/README.md
new file mode 100644
index 00000000..7c2dd33a
--- /dev/null
+++ b/Basic/21_regex/README.md
@@ -0,0 +1,40 @@
+# A. Regular Expression
+
+Regular Expression adalah sekumpulan karakter yang membentuk suatu pola pencarian
+
+# B. Regular Expression Special Sequences
+| Special Sequences | Arti |
+|---------------------|-------------------------------------------------------|
+| \d | Bilangan Bulat / Digit (0-9) |
+| \s | Spasi / Whitespace |
+| \w | Alphabet (A-Za-z), Digit (0-9), dan '-' (garis bawah) |
+
+# C. Regular Expression Metacharacters
+| Metacharacters | Arti |
+|------------------|---------------------------------------------------------------------------------|
+| + | Apabila special sequences yang diinginkan muncul sekali ataupun lebih dari satu |
+| * | Apabila special sequences yang diinginkan tidak muncul ataupun lebih dari satu |
+| [] | Menspesifikasikan pola / special sequences yang diinginkan |
+| {} | Menspesifikasikan kemunculan dari special sequences tersebut |
+| | | Pernyataan logika OR pada Regex |
+
+# D. Regular Expression Set Example
+| Set | Arti |
+|-------|--------------------------------------------------|
+| [A-Z] | Hanya menerima alphabet berupa huruf besar semua |
+| [a-z] | Menerima alphabet huruf kecil |
+| [abc] | Hanya huruf abc |
+| [0-9] | Bilangan digit dari 0 sampai 9 |
+| [1-5] | Hanya menerima bilangan digit dari 1 sampai 5 |
+
+# E. Reguler Expression Function
+## 1. Findall
+Findall adalah sebuah fungsi dimana fungsi tersebut mengembalikan kecocokan antara sequences atau pola yang kita inginkan dengan text yang akan dicari.
+## 2. Sub
+Sub adalah sebuah fungsi dimana fungsi tersebut mengganti sequences yang kita cari dengan sequences / kata baru.
+## 3. Search
+Search adalah sebuah fungsi dimana fungsi tersebut mencari object yang kita inginkan pada kata yang akan kita eksekusi.
+## 4. Split
+Split adalah sebuah fungsi dimana fungsi itu memecah / membagi kalimat yang akan dieksekusi berdasarkan sebuah pola.
+
+[Materi Selanjutnya](../22_scope)
\ No newline at end of file
diff --git a/Basic/21_regex/regex_code.py b/Basic/21_regex/regex_code.py
new file mode 100644
index 00000000..3aeb88db
--- /dev/null
+++ b/Basic/21_regex/regex_code.py
@@ -0,0 +1,22 @@
+import re
+
+text = "@robot9 "
+
+print(re.findall(r"\d", text))
+print(re.findall(r"\w", text))
+print(re.findall(r"\s", text))
+
+angka = "1234"
+
+text = "Budi suka makan buah apel"
+
+print(re.findall(r"\d+", angka))
+print(re.findall(r"\w+", text))
+
+text = "Poseidon dan Zeus"
+
+print(re.findall(r"[aiueo]", text))
+
+text = "Air, api, tanah, udara"
+
+print(re.findall(r"Air|Water", text))
diff --git a/Basic/22_scope/README.md b/Basic/22_scope/README.md
new file mode 100644
index 00000000..45ee9adc
--- /dev/null
+++ b/Basic/22_scope/README.md
@@ -0,0 +1,81 @@
+# Pengertian
+Scope adalah sebuah variabel hanya dapat diakses didalam wilayah dia dibuat, inilah yang disebut dengan *Scope*.
+
+# Jenis-Jenis Scope
+
+## Local Scope
+Sebuah variabel yang dibuat di dalam sebuah fungsi termasuk *Local Scope* dari fungsi tersebut
+dan hanya dapat digunakan didalam fungsi tersebut.
+
+Contoh:
+```py
+def myfunc():
+ x = 300
+ print(x)
+
+myfunc()
+# variabel x tidak dapat diakses di sini
+```
+
+### Fungsi di dalam Fungsi
+Seperti penjelasan di atas, variabel `x` tidak dapat diakses di luar fungsi tersebut, tapi `x` dapat diakses
+di fungsi manapun di dalam fungsi tersebut
+
+Contoh:
+```py
+def myfunc():
+ x = 300
+ def myinnerfunc():
+ print(x)
+ myinnerfunc()
+
+myfunc()
+```
+
+## Global Scope
+Sebuah variabel yang dibuat di bagian utama kode python adalah *Global Variable* yang termasuk *Global Scope*
+variabel global dapat digunakan di manapun
+
+Contoh:
+```
+x = 300
+
+def myfunc():
+ print(x)
+
+myfunc()
+print(x)
+```
+
+
+### Menamai Variabel
+Jika kamu menamai suatu variabel `x` di global scope dan kamu juga menamai variabel lainnya dengan `x`,
+maka python akan memisahkan variabel tersebut menjadi dua variabel yang berbeda.
+
+Contoh:
+```py
+x = 300
+
+def myfunc():
+ # ini adalah variabel x yang berbeda dengan yang diatas
+ x = 200
+ print(x)
+
+myfunc()
+
+print(x)
+```
+
+## Global Keyword
+Jika kamu ingin membuat atau mengganti variabel tapi hanya bisa di *local scope*, kamu bisa menggunakan keyword global.
+
+Contoh:
+```py
+def myfunc():
+ global x
+ x = 300
+
+myfunc()
+
+print(x)
+```
\ No newline at end of file
diff --git a/Basic/23_kalkulator_dengan_fungsi/kalkulator_fungsi.py b/Basic/23_kalkulator_dengan_fungsi/kalkulator_fungsi.py
new file mode 100644
index 00000000..885de563
--- /dev/null
+++ b/Basic/23_kalkulator_dengan_fungsi/kalkulator_fungsi.py
@@ -0,0 +1,70 @@
+def tambah(angka1: float, angka2: float) -> float:
+ """
+ hasil dari pertambahan antara angka1 dan angka2
+ >>> tambah(3.0, 2.0)
+ 5.0
+ """
+ return angka1 + angka2
+
+
+def kurang(angka1: float, angka2: float) -> float:
+ """
+ hasil dari pengurangan antara angka1 dan angka2
+ >>> kurang(3.0, 2.0)
+ 1.0
+ """
+ return angka1 - angka2
+
+
+def kali(angka1: float, angka2: float) -> float:
+ """
+ hasil dari perkalian antara angka1 dan angka2
+ >>> kali(3.0, 2.0)
+ 6.0
+ """
+ return angka1 * angka2
+
+
+def pangkat(angka1: float, angka2: float) -> float:
+ """
+ hasil dari pangkat antara angka1 dan angka2
+ >>> pangkat(3.0, 2.0)
+ 9.0
+ """
+ return angka1**angka2
+
+
+def bagi(angka1: float, angka2: float) -> float:
+ """
+ hasil dari pembagian antara angka1 dan angka2
+ >>> bagi(3.0, 2.0)
+ 1.5
+ """
+ return angka1 / angka2
+
+
+def modulus(angka1: float, angka2: float) -> float:
+ """
+ hasil dari modulus antara angka1 dan angka2
+ >>> modulus(3.0, 2.0)
+ 1.0
+ """
+ return angka1 % angka2
+
+
+print(tambah(3, 2))
+print(kurang(12, 4))
+print(kali(3, 2))
+print(pangkat(3, 2))
+print(bagi(12, 4))
+print(modulus(12, 4))
+
+# menggunakan input
+# angka1 = float(input("Masukkan angka pertama: "))
+# angka2 = float(input("Masukkan angka kedua: "))
+# print(tambah(angka1, angka2))
+# print(kurang(angka1, angka2))
+# print(kali(angka1, angka2))
+# print(pangkat(angka1, angka2))
+# print(bagi(angka1, angka2))
+# print(modulus(angka1, angka2))
diff --git a/Basic/casting_tipe_data.py b/Basic/24_casting_tipe_data/casting_tipe_data.py
similarity index 100%
rename from Basic/casting_tipe_data.py
rename to Basic/24_casting_tipe_data/casting_tipe_data.py
diff --git a/Basic/25_list_and_dict_comprehension/dict_comprehension.py b/Basic/25_list_and_dict_comprehension/dict_comprehension.py
new file mode 100644
index 00000000..5e2b9796
--- /dev/null
+++ b/Basic/25_list_and_dict_comprehension/dict_comprehension.py
@@ -0,0 +1,37 @@
+# Dictionary comprehension adalah
+# Sebuah metode atau cara untuk membuat dictionary menggunakan for loop
+
+# Syntax Dictionary Comprehension
+# {key : value for vars in iterable}
+
+# Kelebihan menggunakan Dictionary Comprehension adalah
+# mampu menulis koding dengan elegan
+
+# Membuat Dictionary
+# contoh bisa dilakukan dengan membuat terlebih dahulu
+# dengan membuat variabel dengan fungsi ``dict()``
+# angka = dict()
+
+# Basic Dict Comprehension
+angka = {nilai: nilai * 2 for nilai in range(1, 6)}
+print("Angka : ", angka)
+# Output = Angka : {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
+
+# Contoh lainnya pada Dict Comprehension
+pangkat = {key * 2: value**2 for (key, value) in angka.items()}
+print("Pangkat Dua: ", pangkat)
+# Output = Pangkat Dua: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
+
+# Implementasi Dict Comprehension Dengan If Else
+ten_nums = {value: value * 2 for value in range(1, 11)}
+genap_only = {key: value for (key, value) in ten_nums.items() if key % 2 == 0}
+print("Genap Only : ", genap_only)
+# Output = Genap Only : {2: 4, 4: 8, 6: 12, 8: 16, 10: 20}
+
+# Implementasi Dict Comprehension Dengan If Else
+age_name = {"Ronaldo": 37, "Messi": 34, "Greenwood": 20, "Sancho": 21}
+status_umur = {
+ nama: ("Tua" if umur > 30 else "Muda") for (nama, umur) in age_name.items()
+}
+print(status_umur)
+# Output = {'Ronaldo': 'Tua', 'Messi': 'Tua', 'Greenwood': 'Muda', 'Sancho': 'Muda'}
diff --git a/Basic/25_list_and_dict_comprehension/list_comprehension.py b/Basic/25_list_and_dict_comprehension/list_comprehension.py
new file mode 100644
index 00000000..321ad634
--- /dev/null
+++ b/Basic/25_list_and_dict_comprehension/list_comprehension.py
@@ -0,0 +1,55 @@
+# List Comprehension
+# adalah metode untuk menambahkan anggota dari suatu list melalui for loop
+
+# Syntax dari List Comprehension adalah
+# [expression for item in iterable]
+
+# Original List
+
+original = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+print(f"Original : {original}")
+# Output = Original : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+# Implementasi List Comprehension dengan Iterable
+
+original_dua = [value for value in range(5, 11)]
+
+print(f"Original Range : {original_dua}")
+# Output = Original Range : [5, 6, 7, 8, 9, 10]
+
+# Implementasi List Comprehension dengan Pemangkatan (Exponential)
+
+exp_list = [item**2 for item in original]
+
+print(f"Exponent List : {exp_list}")
+# Output = Exponent List : [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+
+# Implementasi List Comprehension dengan If Else
+
+genap = [item for item in original if item % 2 == 0]
+
+print(f"Genap : {genap}")
+# Output = Genap : [2, 4, 6, 8, 10]
+
+# Implementasi List Comprehension dengan Expression
+
+elemen = ["Api", "Air", "Tanah", "Udara"]
+
+huruf_awal = [item[0] for item in elemen]
+
+print(f"Huruf Awal : {huruf_awal}")
+# Output = Huruf Awal : ['A', 'A', 'T', 'U']
+
+# Implementasi List Comprehension dengan Nested List
+# Implementasi matriks 3 dimensi
+
+matriks_3_3 = [["X" for _ in range(3)] for _ in range(3)]
+# Output = [['X', 'X', 'X'], ['X', 'X', 'X'], ['X', 'X', 'X']]
+
+# Menggabungkan List Lebih dari satu dimensi
+
+indonesia = [["Kudus", "Solo"], ["Bekasi", "Bogor"], ["Madiun", "Malang"]]
+
+list_kota = [kota for grup_kota in indonesia for kota in grup_kota]
+# Output = ['Kudus', 'Solo', 'Bekasi', 'Bogor', 'Madiun', 'Malang']
diff --git a/Basic/26_dekorator/README.md b/Basic/26_dekorator/README.md
new file mode 100644
index 00000000..2d8c7df8
--- /dev/null
+++ b/Basic/26_dekorator/README.md
@@ -0,0 +1,81 @@
+# Python Dekorator
+
+Dalam python, Dekorator atau ``Decorator`` adalah pola desain dalam python yang memungkinkan pengguna menambahkan fungsi baru ke dalam objek yang sudah ada tanpa ada perubahan dalam strukturnya.
+Dekorator biasanya dipanggil sebelum definisi dari fungsi yang ingin dibuat.
+
+Python memperbolehkan penggunaan fungsi yang bercabang atau nested function untuk mengakses statement diluar dari fungsi yang dibuat, sebagai contoh
+
+```python
+def menampilkan_kata(pesan):
+ def kirim_pesan():
+ print(pesan)
+
+ kirim_pesan()
+
+menampilkan_kata("bellshade")
+```
+
+dengan contoh diatas, kita bisa membuat dekorator yang sederhana yang merubah huruf besar menjadi huruf kecil
+
+```python
+# mendifinisikan fungsi bernama 'dekorator_huruf_kecil'
+def dekorator_huruf_kecil(kata_besar):
+ # membuat fungsi nested yang kita sebut 'wrapper'
+ def wrapper():
+ # memanggil yang diteruskan dekorator_huruf_kecil
+ # dan kemudian dimasukkan ke dalam variabel
+ # 'kata_message'
+ kata_message = kata_besar()
+ # menggunakan fungsi 'lower()' untuk membuat
+ # variabel dari kata_message menjadi kecil
+ # dan kemudian ditugaskan dalam variabel
+ # buat_kata_kecil
+ buat_kata_kecil = kata_message.lower()
+ # mengembalikan nilai dari 'wrapper'
+ return buat_kata_kecil
+ # mengembalikan fungsi dari wrapper
+ return wrapper
+```
+
+kemudian disini kita bisa bisa menggunakan fungsi baru lagi dengan cara
+```python
+def kata():
+ return "BELLSHADE"
+
+jadikan_kata_kecil = dekorator_huruf_kecil(kata)
+jadikan_kata_kecil()
+```
+
+Python juga menyediakan cara yang lebih gampang dalam membuat kodingan diatas
+dari yang kita buat dengan cara menambahkan simbol ``@``
+
+```python
+@dekorator_huruf_kecil
+def kata():
+ return "BELLSHADE"
+kata()
+```
+
+## Aplikasikan dekorator yang banyak dalam satu fungsi
+
+Kita bisa menggunakan decorator yang banyak dalam satu fungsi sebagai contoh:
+
+sebelumnya kita sudah membuat dekorator yang bernama ``dekorator_huruf_kecil`` kali ini kita membuat kata menjadi dipecah menggunakan fungsi ``split()``
+
+```python
+def pecah_kata(kata_yang_mau_dipecah):
+ def wrapper():
+ kata = kata_yang_mau_dipecah()
+ split_kata = kata.split()
+ return split_kata
+ return wrapper
+```
+
+dengan ini kita sudah ada 2 fungsi dekorator, kemudian kita bisa membuat contoh untuk memanggil keduanya dengan ``@``
+
+```python
+@dekorator_huruf_kecil
+@pecah_kata
+def kata():
+ return "BELLSHADE"
+```
diff --git a/Basic/26_dekorator/dekorator.py b/Basic/26_dekorator/dekorator.py
new file mode 100644
index 00000000..c003acdb
--- /dev/null
+++ b/Basic/26_dekorator/dekorator.py
@@ -0,0 +1,34 @@
+def dekorator_huruf_kecil(kata):
+ # membuat fungsi nested yang kita sebut 'wrapper'
+ def wrapper():
+ # memanggil yang diteruskan dekorator_huruf_kecil
+ # dan kemudian dimasukkan ke dalam variabel
+ # 'kata_message'
+ kata_message = kata()
+ # menggunakan fungsi 'lower()' untuk membuat
+ # variabel dari kata_message menjadi kecil
+ # dan kemudian ditugaskan dalam variabel
+ # buat_kata_kecil
+ buat_kata_kecil = kata_message.lower()
+ # mengembalikan nilai dari 'wrapper'
+ return buat_kata_kecil
+
+ # mengembalikan fungsi dari wrapper
+ return wrapper
+
+
+def kata_besar():
+ return "BELLSHADE"
+
+
+dekorator = dekorator_huruf_kecil(kata_besar)
+
+print(dekorator() + "\n")
+
+
+@dekorator_huruf_kecil
+def kata_besar_():
+ return "BELLSHADE"
+
+
+print(kata_besar_())
diff --git a/Basic/Operator.py b/Basic/Operator.py
deleted file mode 100644
index a3022a22..00000000
--- a/Basic/Operator.py
+++ /dev/null
@@ -1,138 +0,0 @@
-"""
-Operator Pada Python ada 7 jenis, yaitu:
-
-1. Arithmetic Operators (Operator Aritmatika)
- a. + (tambah)
- b. - (kurang)
- c. * (kali)
- d. / (bagi)
- e. // (Floor Division)
- f. %% (modulo)
- g. ** (pangkat)
-
-2. Comparison Operators (Operator Pembanding)
- a. == (sama dengan)
- b. != (tidak sama dengan)
- c. > (lebih dari)
- d. < (kurang dari)
- e. >= (lebih dari atau sama dengan)
- f. <= (kurang dari atau sama dengan)
-
-3. Logical Operators (Operator Logika)
- a. and (akan mengembalikan True jika kedua pembanding bersifat True)
- b. or (akan mengembalikan True jika salah satu pembanding bersifat True)
- c. not (akan mengembalikan True jika kedua pembanding bersifat False)
-
-4. Membership Operators
- a. in (akan mengembalikan True jika nilai yang ditentukan berada di dalam objek)
- b. not in (akan mengembalikan True jika nilai yang ditentukan tidak dalam objek)
-
-5. Identity Operators (Operator Identitas)
- a. is (akan mengembalikan True jika kedua variable adalah objek yang sama)
- b. is not (akan mengembalikan True jika kedua variable bukanlah objek yang sama)
-
-6. Bitwise Operators (Operator Binary)
- a. & (Menjadikan setiap bit 1 jika kedua bit adalah 1)
- b. | (Menjadikan setiap bit 1 jika salah satu bit adalah 1)
- c. ^ (Menjadikan setiap bit 1 hanya jika salah satunya adalah 1)
- d. ~ (Membalikkan angka bit)
- e. << (Menambahkan angka 0 di kanan dan menghapus bit di paling kiri)
- g. >> (Menambahkan salinan bit paling kiri ke kiri dan menghapus bit paling kanan)
-
-7. Assignment Operators
-
- | Operator | Example | Same As |
- | = | x = 5 | x = 5 |
- | += | x += 3 | x = x + 3 |
- | -= | x -= 3 | x = x - 3 |
- | *= | x *= 3 | x = x * 3 |
- | /= | x /= 3 | x = x / 3 |
- | %= | x %= 3 | x = x % 3 |
- | //= | x //= 3 | x = x // 3 |
- | **= | x **= 3 | x = x ** 3 |
- | &= | x &= 3 | x = x & 3 |
- | |= | x |= 3 | x = x | 3 |
- | ^= | x ^= 3 | x = x ^ 3 |
- | <<= | x <<= 3 | x = x << 3 |
- | >>= | x >>= 3 | x = x >> 3 |
-
- nb: saya tidak membuat contoh ini karena ini adalah penyingkat kode
-
-source: https://www.w3schools.com/python/python_operators.asp
-"""
-
-a = 10
-b = 4
-c = False
-d = True
-e = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-
-print("Variables\n")
-print("a:", a)
-print("b:", b)
-print("c:", c)
-print("d:", d)
-print("e:", e)
-
-# Pemisah
-print("\n==================\n")
-
-# Arithmetic Operators
-
-print("Arithmetic Operators\n")
-print("10 + 4 =", a + b)
-print("10 - 4 =", a - b)
-print("10 * 4 =", a * b)
-print("10 / 4 =", a / b)
-print("10 ** 4 =", a ** b)
-print("10 // 4 =", a // b)
-
-# Pemisah
-print("\n==================\n")
-
-# Comparison Operators
-
-print("Comparison Operators\n")
-print("a == b:", a == b)
-print("a != b:", a != b)
-print("a > b:", a > b)
-print("a < b:", a < b)
-print("a >= b:", a >= b)
-print("a <= b:", a <= b)
-
-# Pemisah
-print("\n==================\n")
-
-# Logical Operators
-print("Logical Operators\n")
-print("c and d:", c and d)
-print("c or d:", c or d)
-print("not c:", not c)
-
-# Pemisah
-print("\n==================\n")
-
-# Membership Operators
-print("Membership Operators\n")
-print("a in e:", a in e)
-print("a not in e:", a not in e)
-
-# Pemisah
-print("\n==================\n")
-
-# Identity Operators
-print("Identity Operators\n")
-print("a is b:", a is b)
-print("a is a:", a is a) # lgtm [py/comparison-of-identical-expressions]
-print("a is not b:", a is not b)
-
-# Pemisah
-print("\n==================\n")
-
-# Bitwise Operators
-print("a & b:", a & b)
-print("a | b:", a | b)
-print("a ^ b:", a ^ b)
-print("~ a:", ~a)
-print("a << b:", a << b)
-print("a >> b:", a >> b)
diff --git a/Basic/README.md b/Basic/README.md
index cde781c6..d521312f 100644
--- a/Basic/README.md
+++ b/Basic/README.md
@@ -1,17 +1,48 @@
# Dasar - Dasar Python
-1. [Introduction](Introduction.py)
-2. Hello world
-3. [Variable dan data types ( primitive )](variable)
-4. [Operator](operator)
-5. [String](string_python.py)
-6. [Input / output](input_output.py)
-7. Logika
-8. Perulangan
-9. Basic kalkulator
-10. [Fungsi](fungsi)
-11. Basic kalkulator dengan fungsi
-12. Folder berisi contoh program sederhana dengan menggunakan fungsi
-13. List dan tuple
-14. Rekayasa string
-15. Rekayasa string dan tuple
-16. Folder yang berisi program dengan menggunakan list dan tuple
+
+
+
+
+
+
+Untuk kamu yang ingin belajar bahasa pemrograman python, berikut urutan basic untuk pemula yang ingin belajar dari bahasa pemograman python. **disarankan belajar sesuai list berikut**.
+
+1. [Introduction](01_introduction)
+2. [Data Types](02_tipe_data)
+3. [Variabel](03_variable)
+4. [Operator](04_operator)
+5. [String](05_string)
+6. [Input / Output](06_input_output)
+7. [Logika](07_logika_percabangan)
+8. [Perulangan](08_perulangan)
+9. [Fungsi](09_fungsi)
+10. [List dan Tuple](10_list_tuple)
+11. [Manipulasi String](11_manipulasi_string)
+12. [Exception](12_exception)
+13. [Modul](13_module)
+14. [Tanggal dan Waktu (Datetime)](14_python_datetime)
+15. [Fungsi Matematika](15_python_math)
+16. [Kelas](16_class)
+17. [Turunan](17_inheritance)
+18. [Akses Modifikasi](18_akses_modifikasi)
+19. [Iterator](19_iterator)
+20. [Lambda](20_lambda)
+21. [Regex](21_regex)
+22. [Scope](22_scope)
+23. [Kalkulator dengan Fungsi](23_kalkulator_dengan_fungsi)
+24. [Casting Tipe Data](24_casting_tipe_data)
+25. [list_and_dict](25_list_dict_comprehension)
+26. [dekorator](26_dekorator)
+
+## Install python pada perangkat
+
+- Windows
+
+ Untuk penginstalan python dan dipasangkan pada visual studio code bisa melihat link [disini](https://www.youtube.com/watch?v=OSmaWPSgvTQ&list=PLZS-MHyEIRo59lUBwU-XHH7Ymmb04ffOY&index=2)
+
+- Linux / macOS
+
+ untuk penginstalan, python sudah menyediakan pada linux dan macOS dengan membuka terminal dan memberikan perintah
+ ```
+ python3 --version
+ ```
diff --git a/Basic/fungsi/README.md b/Basic/fungsi/README.md
deleted file mode 100644
index 3dcbdc8f..00000000
--- a/Basic/fungsi/README.md
+++ /dev/null
@@ -1,103 +0,0 @@
-# fungsi
-
-fungsi adalah sebuah blok kode yang berjalan ketika ingin digunakan
-
-contoh
-```python
-def hello():
- print('Hello !')
-```
-
-apabila kita ingin meng-gunakan fungsi tersebut kita tinggal command
-```python
-hello()
-```
-
-lantas, apakah kita bisa memasukkan input ke dalam fungsi ? tentu bisa
-input yang kita kirimkan ke dalam fungsi disebut sebagai Argument, seperti apa contohnya ?
-
-```python
-def hello(nama):
- print('Hello '+str(nama)+' !')
-```
-
-apabila kita ingin memakai fungsi tersebut dan memasukkan argument kita cukup mengetikkan
-```python
-hello('Bellshade')
-```
-
-apa kita cuma bisa memasukkan satu argument aja kah ? jawabannya, tentunya ga dong, kita bisa memasukkan lebih dari satu argument
-contohnya
-```python
-def triangle(alas,tinggi):
- hasil = (alas * tinggi)/2
- print(hasil)
-```
-
-dan kita pun akan memakai fungsi segitiga kita !!
-```python
-triangle(2,3)
-```
-
-next, pembahasan kita tentang ```return```, apa itu return ? return adalah sebuah function keyword yang mengembalikan nilai dan juga sekaligus "mengakhiri" function itu sendiri
-
-contohnya
-```python
-def triangle(alas,tinggi):
- hasil = (alas * tinggi)/2
- return hasil
-
-print(triangle(2,3))
-```
-
-return pada koding diatas, mengakhiri function dari triangle, jadi kita tidak bisa lagi melakukan command apapun yang lewat dari line `return hasil`
-
-next, kita akan bahas sesuatu yang disebut, `default argument`, apa tu ? default argument terjadi apabila kita mendefault / mengatur nilai default dari sebuah argument, misalnya
-
-```python
-
-def salam(waktu="Pagi"):
- greet = "Selamat " + str(waktu)
- return greet
-
-print(salam("Siang")) # Selamat Siang
-print(salam("Malam")) # Selamat Malam
-print(salam("Sore")) # Selamat Sore
-print(salam()) # Selamat Pagi
-```
-
-disini kita melakukan default value terhadap argument dari waktu menjadi "Pagi", jadi apabila kita memanggil ```salam()```,
-maka itu tidak akan menimbulkan error, karena sudah ada default valuenya, dan default value juga bersifat `flexibel` dimana masih bisa diubah menjadi, 'Siang', 'Malam', dan lainnya.
-
-next kita akan bicara tentang suatu konsep yang menarik, yaitu, `Unlimited` atau `Infinite`, dimana artinya adalah, tak terbatas, apa yang tak terbatas ?
-yang tak terbatas di python function adalah argument yang dapat kita inputkan, "caranya begimane tuh ya ? pake infinity stone ga ?", berikut caranya
-
-```python
-def unlimited(*args):
- for item in args:
- print(item)
-
-unlimited(1,2,3,4)
-unlimited([1,2],[3,4])
-```
-
-contoh dari unlimited nya adalah, pada command pertama, kita memasukkan 4 parameter, command kedua, kita memasukkan 2 parameter
-
-last, but not least, unlimited keyword argument, dimana kita memberi tahu bahwa argument kita ini memiliki key, atau kunci, hal ini sama dengan dictionary
-dimana pada unlimited keyword argument, python memakai prinsip dictionary, sementara pada unlimited argument, python mengadopsi konsep tuple
-
-contohnya ?
-
-```python
-def unlimitedkeyword(**infinite):
- for key, value in infinite.items():
- print("index {} memiliki nilai {}".format(key,value))
-
-unlimitedkeyword(a=2,b=1,c=3)
-unlimitedkeyword(fname="Harry",lname="Potter")
-```
-
-dimana pada command pertama, kita memasukkan 3 parameter dengan masing-masing key a,b,c dan value 1,2,3
-dan pada command kedua, kita memasukkan 2 parameter dengan masing-masing key yaitu fname dan lname dengan value Harry, Potter
-
-Bellshade Python Function
diff --git a/Basic/operator/README.md b/Basic/operator/README.md
deleted file mode 100644
index c6ca7454..00000000
--- a/Basic/operator/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# operator
-
-operator digunakan untuk melakukan operasi pada kedua variabel atau value
-
-python memiliki beberapa jenis operator yaitu
-
-- [operator aritmatika](operator_aritmatika.py)
-- [operator penugasan](operator_penugasan.py)
-- [operator komparasi](operator_perbandingan.py)
-- operator logika
-- operator identitas
-- operasi member
-
-
-## operasi aritmatika
-operasi aritmatika adalah operasi yang digunakan untuk melakukan operasi matematika diantara kedua value atau kedua variabel
-
-sebagai contoh operasi pertambahan
-```python
-angka = 2
-angka_kedua = 3
-
-print(angka + angka_kedua)
-```
-operasi tersebut menambahkan kedua variabel yang memiliki value yaitu 2 dan 3
-
-berikut table dari operasi aritmatika
-
-| operator | nama operator | contoh penggunaan |
-|----------|---------------|-------------------|
-| + | penambahan | a + b |
-| - | pengurangan | a - b |
-| * | perkalian | a * b |
-| / | pembagian | a / b |
-| ** | perpangkatan | a ** b |
-| % | modulus | a % b |
-| // | floor | a // b |
-
-## operasi penugasan
-operasi penugasan adalah operasi yang digunakan untuk menetapkan suatu bilangan ke dalam variabel
-
-sebagai contoh operasi penugasan
-```python
-nilai = 5
-nilai += 3
-
-print("nilai adalah", nilai)
-```
-operasi tersebut menambahkan sekaligus menetapkan ke dalam variabel nilai
-
-berikut tabel dari operasi penugasan
-
-| Operator | Example | Sama Dengan |
-|---------------|---------------|---------------|
-| = | x = 5 | x = 5 |
-| += | x += 3 | x = x + 3 |
-| -= | x -= 3 | x = x - 3 |
-| *= | x *= 3 | x = x * 3 |
-| /= | x /= 3 | x = x / 3 |
-| %= | x %= 3 | x = x % 3 |
-| //= | x //= 3 | x = x // 3 |
-| **= | x **= 3 | x = x ** 3 |
-| &= | x &= 3 | x = x & 3 |
-| |= | x |= 3 | x = x | 3 |
-| ^= | x ^= 3 | x = x ^ 3 |
-| <<= | x <<= 3 | x = x << 3 |
-| >>= | x >>= 3 | x = x >> 3 |
-
-
-## operasi perbandingan
-
-operasi perbandingan adalah operasi yang digunakan untuk membandingkan suatu nilai dengan nilai yang lain
-
-sebagai contoh operasi perbandingan
-```python
-print(2 < 3) # True
-```
-
-operasi tersebut membadingkan apakah nilai pertama lebih kecil daripada nilai kedua
-
-berikut tabel dari operasi perbandingan
-| Operator | Artinya |
-|---------------|---------------------------------------|
-| == | Sama Dengan |
-| != | Tidak Sama Dengan |
-| > | Lebih besar dari |
-| < | Lebih Kecil dari |
-| >= | Lebih Besar dari atau sama dengan |
-| <= | Lebih Kecil dari atau sama dengan |
\ No newline at end of file
diff --git a/Basic/tipe_data/README.md b/Basic/tipe_data/README.md
deleted file mode 100644
index d5618c6f..00000000
--- a/Basic/tipe_data/README.md
+++ /dev/null
@@ -1,75 +0,0 @@
-## tipe data
-
-dalam pemograman, tipe data adalah salah satu konsep yang sangat penting, dalam pemograman variabel dapat memberikan beberapa tipe data value yang sangat berguna dalam menentukan hasil dan operasi pada pemograman, tipe data melingkupi
-
-- berupa text
-
- - ``str``
-
- merupakan salah satu tipe data yang berupa string, berfungsi untuk menghasilkan tipe data string seperti huruf abjad atau simbol lain
- ```python
- nama_saya = "franklin"
- email_saya = "benjamin@franklin"
- ```
-
-- berupa angka
-
- - ``int``
-
- merupakan salah satu tipe numerik yang sering dipakai dalam pemograman, yang berupa bilangan bulat
- ```python
- angka_saya = 25
- tahun_lahir = 1945
- ```
-
- - ``float``
-
- merupakan salah satu tipe numerik yang menghasilkan berupa bilangan pecahan, sangat berguna dalam menghasilkan nilai secara detail
- ```python
- nilai_saya = 95.281724
- nilai_teman = 30.25912
- ```
-
- - ``complex``
-
- merupakan salah satu tipe data numerik yang berfungsi menghasil sebuah angka complex, contoh angka complex bisa dilihat [disini](https://id.wikipedia.org/wiki/Bilangan_kompleks)
- ```python
- angka_kompleks_saya = complex(1.5)
- angka_teman_saya = complex(2j)
- ```
-
-- berupa urutan (sekuensial)
-
- - ``list``
-
- tipe data list adalah tipe data koleksi yang berisi beberapa value yang terdapat dalam satu variabel. list menggunakan kurung kotak
- ```python
- nama_siswa = ['woody', 'buzz', 'andy']
- nilai_siswa = [12, 13, 14]
- ```
-
- - ``tuple``
-
- tipe data tuple adalah tipe data koleksi yang berisi beberap valua yang terdapat dalam satu variabel. perbedaan diantara keduanya adalah
-
- - tipe data tuple jika diberi value, maka tipe data tersebut tidak dapat diubah kembali
- - tipe data tuple menggunakan tutup kurung biasa ``()``
-
- ```python
- nama_siswa = ('buzz', 'andy', 'woody')
- nilai = (12, 13, 14)
- ```
-
-- berupa map (kata kunci, dictionary)
-
- - ``dict``
-
- tipe data dict atau dictionary adalah tipe data array dimana kunci atau __key__ dari array bisa berbentuk string, dan angka
- ```python
- hari = {
- "sen": "senin",
- "sel": "selasa",
- "rab": "rabu"
- }
- ```
-
diff --git a/Basic/tipe_data/tipe_data.py b/Basic/tipe_data/tipe_data.py
deleted file mode 100644
index 8e7f9a4d..00000000
--- a/Basic/tipe_data/tipe_data.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# tipe data pada python adalah
-# tipe text yaitu string
-# tipe angka yaitu int, float, dan complex
-# tipe data majemuk yaitu list, tuple, set, dan range
-# tipe data map yaitu dict
-
-# penggunaan type() sebagai pemeriksa sebuah tipe data
-# pada variabel
-
-# suatu tipe data yang terdapat pada variabel
-# menampilkan contoh tipe data integer
-bilangan_integer = 2
-print(type(bilangan_integer))
-
-# menampilkan tipe data yang merupakan
-# hasil dari kedua value
-operasi = 3 + 3
-print(type(operasi))
-
-# contoh tipe data dari list
-nama_siswa = ["andi", "buzz", "wheezy", "army"]
-print(nama_siswa)
-print(type(nama_siswa))
-
-# contoh tipe data dari dict
-merk_mobil = {"merk": "ferrari", "asal": "italia"}
-print(merk_mobil)
-print(type(merk_mobil))
diff --git a/Basic/variable/string_variable.py b/Basic/variable/string_variable.py
deleted file mode 100644
index 8ac9b1b2..00000000
--- a/Basic/variable/string_variable.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# String dalam Python diidentifikasi
-# sebagai serangkaian karakter yang berdekatan
-# yangdiwakili dalam tanda kutip.
-
-pesan = "saya pergi ke pasar"
-
-# s a y a p e r g i
-# 0 1 2 3 4 5 5 6 7 8 9
-
-# k e p a s a r
-# 10 11 12 13 14 15 16 17
-
-
-print(pesan) # print secara keseluruhan
-print(pesan[0]) # print karakter 's'
-
-# print karakter dari karakter ke 3
-# ke karakter ke 5
-print(pesan[2:5])
-
-# print dimulai dari karakter ke 3
-print(pesan[2:])
-
-# print kata 2 kali
-print(pesan * 2)
-
-# gabung kata dengan kata baru
-# saya pergi kepasar dengan ibu saya
-print(pesan + " dengan ibu saya")
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000..5604744b
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+ and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+ overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+ advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+ address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[Discord Channel WPU](http://discord.gg/S4rrXQU).
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 92b51f7a..90e9944e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -18,7 +18,7 @@ Algoritma adalah satu atau lebih fungsi dan/atau kelas yang:
- memiliki satu atau lebih *input*;
- melakukan beberapa internal kalkulasi atau manipulasi data;
- mengembalikan satu atau lebih nilai hasil;
-- memiliki kekurangan minimal (contoh: `print()`,`plot()`,`read()`,`write()`).
+- memiliki kekurangan minimal (contoh: `print()`,`plot()`,`read()`,`write()`) terkecuali jika memperbaiki materi tutorial.
Algoritma harus dikemas sedemikian rupa agar dapat dengan mudah dimasukkan ke dalam program yang lebih besar.
@@ -49,11 +49,15 @@ def adding(num1, num2):
num1 = integer
num2 = integer
mengembalikan hasil yang berupa integer
+ >>> adding(2, 50)
+ 52
+ >>> adding(3, 2)
+ 5
"""
return num1 + num2
```
-***Docstring* yang buruk:**
+***Docstring* yang kurang baik:**
```py
def adding(num1, num2):
@@ -105,19 +109,25 @@ flake8 perubahan_kamu.py
flake8 .
```
-Untuk *doctests*:
+**Saran**
-```bash
-pytest . --doctest-modules
-```
+[Pemahaman list dan generator](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) lebih disukai daripada penggunaan `lambda`, `map`, `filter`. Tetapi yang penting adalah menunjukkan kekuatan Python dalam kode yang mudah dibaca dan dipelihara.
+
+kamu bisa dengan menggunakan pre-commit sebagai cek / menjalankan semua test dengan cara
```bash
-pytest perubahan_kamu.py --doctest-modules
-```
+# jika tidak ada pre-commit, install terlebih dahulu
+pip install pre-commit
-**Saran**
+# jika menggunakan uv, kamu bisa menginstall dengan menggunakan uv
+uv pip install pre-commit
-[Pemahaman list dan generator](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) lebih disukai daripada penggunaan `lambda`, `map`, `filter`. Tetapi yang penting adalah menunjukkan kekuatan Python dalam kode yang mudah dibaca dan dipelihara.
+# jalakan perintahnya
+pre-commit run --all-files
+
+# jika menggunakan uv
+uv run pre-commit run --all-files
+```
## Tambahan Perubahan
@@ -129,11 +139,14 @@ count_bullet_speed
└── file_tambahan.py
```
+**Catatan :** **Tidak boleh merubah-rubah apapun yang terdapat pada file [DIRECTORY.md](DIRECTORY.md) karena akan menggenerate daftar file kode secara otoamatis dan dimasukkan kedalam ``DIRECTORY.md``
+
# *Pull Request*
***Pull request* yang baik**
-Informasi: gunakan [*issue*](https://github.com/bellshade/Python/issues) apabila ingin menambahkan kode atau implementasi algoritma, dll (*basic*) agar tidak ada konflik dengan *pull request* lainnya.
+Informasi: gunakan [*issue*](https://github.com/bellshade/Python/issues) apabila ingin menambahkan kode atau implementasi algoritma, dll (*basic*) agar tidak ada konflik dengan *pull request* lainnya. Kamu juga bisa menggunakan issue jika kamu ada
+kendala atau masalah ketika melakukan pull request. Kamu juga bisa bertanya pada forum discord **WPU** dan **Kelas Terbuka** perihal bellshade.
- Lakukan penjelasan deskripsi perubahan yang anda lakukan pada repositori kami dengan membuat penjelasan di [*issue*](https://github.com/bellshade/Python/issues).
- Setelah menjelaskan perubahan anda di [*issue*](https://github.com/bellshade/Python/issues) kemudian lakukan *fork* pada repositori kami.
@@ -144,16 +157,26 @@ Informasi: gunakan [*issue*](https://github.com/bellshade/Python/issues) apabila
```bash
git checkout -b
git add . # atau git add nama_perubahan_kamu.py
- git commit -m "add: menambahkan algoritma terbaru"
+ git commit -m "feat: menambahkan algoritma terbaru"
```
- Lakukan *push* ke *branch* kamu dan kemudian *open pull request*.
**Saran pesan commit**
-- `add` untuk menambah algoritma atau tambahan lainnya;
-- `fix` untuk mengubah algoritma yang sudah ada atau memperbaiki;
-- `docs` untuk mengubah atau membuat dokumentasi;
-- `style` untuk mengubah atau memperbaiki *style* kode—untuk contohnya bisa dilihat pada contoh commit di atas.
+- `feat:` untuk menambah algoritma atau tambahan lainnya;
+- `fix:` untuk mengubah algoritma yang sudah ada atau memperbaiki;
+- `docs:` untuk mengubah atau membuat dokumentasi;
+- `add:` untuk menambah algoritma atau tambahan lainnya (opsional);
+
+Catatan: pesan commit harus menjelaskan perubahan secara singkat.
+
+Contoh yang benar:
+- ☒ feat: test_x.py
+- ☑ feat: tambah unittest untuk algoritma x
+
+Lebih lengkapnya bisa dilihat di:
+- [EN](https://www.conventionalcommits.org/en/v1.0.0/)
+- [ID](https://www.conventionalcommits.org/id/v1.0.0/)
Pull request akan di-*merge* jika:
@@ -166,3 +189,4 @@ Pull request akan di-*merge* jika:
- Jika ada tes yang tidak lewat atau gagal, kami akan cek kembali perubahan anda.
Untuk *pull request*, disarankan untuk menjelaskan secara detail yang kamu ubah atau tambahkan, dan bersikap sopan serta selalu berterima kasih. Itu salah satu bentuk tata krama yang baik terhadap sesama *contributor* dan *programmer* lainnya.
+
diff --git a/DIRECTORY.md b/DIRECTORY.md
new file mode 100644
index 00000000..e49bece0
--- /dev/null
+++ b/DIRECTORY.md
@@ -0,0 +1,403 @@
+
+## Basic
+ * 02 Tipe Data
+ * [Tipe Data](https://github.com/bellshade/Python/blob/main/Basic/02_tipe_data/tipe_data.py)
+ * 03 Variable
+ * [String Variable](https://github.com/bellshade/Python/blob/main/Basic/03_variable/string_variable.py)
+ * [Variable](https://github.com/bellshade/Python/blob/main/Basic/03_variable/variable.py)
+ * 04 Operator
+ * [Operator Aritmatika](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_aritmatika.py)
+ * [Operator Bitwise](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_bitwise.py)
+ * [Operator Identitas](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_identitas.py)
+ * [Operator Keanggotaan](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_keanggotaan.py)
+ * [Operator Logika](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_logika.py)
+ * [Operator Penugasan](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_penugasan.py)
+ * [Operator Penugasan Ekspresi](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_penugasan_ekspresi.py)
+ * [Operator Perbandingan](https://github.com/bellshade/Python/blob/main/Basic/04_operator/operator_perbandingan.py)
+ * 05 String
+ * [String Python](https://github.com/bellshade/Python/blob/main/Basic/05_string/string_python.py)
+ * 06 Input Output
+ * [Input Output](https://github.com/bellshade/Python/blob/main/Basic/06_input_output/input_output.py)
+ * 07 Logika Percabangan
+ * [Logika Percabangan](https://github.com/bellshade/Python/blob/main/Basic/07_logika_percabangan/logika_percabangan.py)
+ * 08 Perulangan
+ * [For Loop](https://github.com/bellshade/Python/blob/main/Basic/08_perulangan/for_loop.py)
+ * [While Loop](https://github.com/bellshade/Python/blob/main/Basic/08_perulangan/while_loop.py)
+ * 09 Fungsi
+ * [Fungsi](https://github.com/bellshade/Python/blob/main/Basic/09_fungsi/fungsi.py)
+ * [Recursion Example](https://github.com/bellshade/Python/blob/main/Basic/09_fungsi/recursion_example.py)
+ * 10 List Tuple
+ * [List Python](https://github.com/bellshade/Python/blob/main/Basic/10_list_tuple/list_python.py)
+ * [Tuple Python](https://github.com/bellshade/Python/blob/main/Basic/10_list_tuple/tuple_python.py)
+ * 12 Exception
+ * [Exception](https://github.com/bellshade/Python/blob/main/Basic/12_exception/exception.py)
+ * 13 Module
+ * [Kalkulator](https://github.com/bellshade/Python/blob/main/Basic/13_module/kalkulator.py)
+ * [Perhitungan1](https://github.com/bellshade/Python/blob/main/Basic/13_module/perhitungan1.py)
+ * [Perhitungan2](https://github.com/bellshade/Python/blob/main/Basic/13_module/perhitungan2.py)
+ * 14 Python Datetime
+ * [Module Datetime](https://github.com/bellshade/Python/blob/main/Basic/14_python_datetime/module_datetime.py)
+ * [Perhitungan Umur](https://github.com/bellshade/Python/blob/main/Basic/14_python_datetime/perhitungan_umur.py)
+ * 15 Python Math
+ * [Math Eksponen Logaritma](https://github.com/bellshade/Python/blob/main/Basic/15_python_math/math_eksponen_logaritma.py)
+ * [Math Konstanta](https://github.com/bellshade/Python/blob/main/Basic/15_python_math/math_konstanta.py)
+ * [Math Konversi Sudut](https://github.com/bellshade/Python/blob/main/Basic/15_python_math/math_konversi_sudut.py)
+ * [Math Pembulatan](https://github.com/bellshade/Python/blob/main/Basic/15_python_math/math_pembulatan.py)
+ * [Math Trigonometri](https://github.com/bellshade/Python/blob/main/Basic/15_python_math/math_trigonometri.py)
+ * 16 Class
+ * [Class](https://github.com/bellshade/Python/blob/main/Basic/16_class/class.py)
+ * [Const Desct](https://github.com/bellshade/Python/blob/main/Basic/16_class/const_desct.py)
+ * [Dunder Method](https://github.com/bellshade/Python/blob/main/Basic/16_class/dunder_method.py)
+ * [Methods](https://github.com/bellshade/Python/blob/main/Basic/16_class/methods.py)
+ * 17 Inheritance
+ * [Inheritance Python](https://github.com/bellshade/Python/blob/main/Basic/17_inheritance/inheritance_python.py)
+ * 18 Akses Modifikasi
+ * 01 Public
+ * [Public](https://github.com/bellshade/Python/blob/main/Basic/18_akses_modifikasi/01_public/public.py)
+ * 02 Private
+ * [Private](https://github.com/bellshade/Python/blob/main/Basic/18_akses_modifikasi/02_private/private.py)
+ * 03 Protected
+ * [Protected](https://github.com/bellshade/Python/blob/main/Basic/18_akses_modifikasi/03_protected/protected.py)
+ * 19 Iterator
+ * [Iterator](https://github.com/bellshade/Python/blob/main/Basic/19_iterator/iterator.py)
+ * 20 Lambda
+ * [Lambda](https://github.com/bellshade/Python/blob/main/Basic/20_lambda/lambda.py)
+ * 21 Regex
+ * [Regex Code](https://github.com/bellshade/Python/blob/main/Basic/21_regex/regex_code.py)
+ * 23 Kalkulator Dengan Fungsi
+ * [Kalkulator Fungsi](https://github.com/bellshade/Python/blob/main/Basic/23_kalkulator_dengan_fungsi/kalkulator_fungsi.py)
+ * 24 Casting Tipe Data
+ * [Casting Tipe Data](https://github.com/bellshade/Python/blob/main/Basic/24_casting_tipe_data/casting_tipe_data.py)
+ * 25 List And Dict Comprehension
+ * [Dict Comprehension](https://github.com/bellshade/Python/blob/main/Basic/25_list_and_dict_comprehension/dict_comprehension.py)
+ * [List Comprehension](https://github.com/bellshade/Python/blob/main/Basic/25_list_and_dict_comprehension/list_comprehension.py)
+ * 26 Dekorator
+ * [Dekorator](https://github.com/bellshade/Python/blob/main/Basic/26_dekorator/dekorator.py)
+ * [Introduction](https://github.com/bellshade/Python/blob/main/Basic/Introduction.py)
+
+## Algorithm
+ * Arithmetic Analysis
+ * [Bisection](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/bisection.py)
+ * [Gaussian Elimination](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/gaussian_elimination.py)
+ * [In Static Equilibrium](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/in_static_equilibrium.py)
+ * [Intersection](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/intersection.py)
+ * [Jacobi Iteration Method](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/jacobi_iteration_method.py)
+ * [Lu Decomposition](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/lu_decomposition.py)
+ * [Newton Forward Interpolation](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/newton_forward_interpolation.py)
+ * [Newton Method](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/newton_method.py)
+ * [Newton Raphson](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/newton_raphson.py)
+ * [Rootsearch](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/rootsearch.py)
+ * [Secant Method](https://github.com/bellshade/Python/blob/main/algorithm/arithmetic_analysis/secant_method.py)
+ * Backtracking
+ * [All Combinations](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/all_combinations.py)
+ * [Cari Kata](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/cari_kata.py)
+ * [Coloring](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/coloring.py)
+ * [Combination](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/combination.py)
+ * [Hamilton Cycle](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/hamilton_cycle.py)
+ * [Knight Tour](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/knight_tour.py)
+ * [Minimax](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/minimax.py)
+ * [N Queen Math](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/n_queen_math.py)
+ * [N Queens](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/n_queens.py)
+ * [Permutation](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/permutation.py)
+ * [Rat In Maze](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/rat_in_maze.py)
+ * [Subsequence](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/subsequence.py)
+ * [Sudoku](https://github.com/bellshade/Python/blob/main/algorithm/backtracking/sudoku.py)
+ * Boolean Algebra
+ * [Quinc Mc Cluskey](https://github.com/bellshade/Python/blob/main/algorithm/boolean_algebra/quinc_mc_cluskey.py)
+ * Divide And Conquer
+ * [Closest Pair Of Points](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/closest_pair_of_points.py)
+ * [Convex Hull](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/convex_hull.py)
+ * [Heap Algorithm](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/heap_algorithm.py)
+ * [Inversion](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/inversion.py)
+ * [Kth Order Statistic](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/kth_order_statistic.py)
+ * [Max Difference Pair](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/max_difference_pair.py)
+ * [Max Subarray Sum](https://github.com/bellshade/Python/blob/main/algorithm/divide_and_conquer/max_subarray_sum.py)
+ * Fuzzy Logic
+ * [Fuzzy Operation](https://github.com/bellshade/Python/blob/main/algorithm/fuzzy_logic/fuzzy_operation.py)
+ * Genetic Algo
+ * [Basic String](https://github.com/bellshade/Python/blob/main/algorithm/genetic_algo/basic_string.py)
+ * Manipulasi Bit
+ * [Binary And Operator](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_and_operator.py)
+ * [Binary Count Trailing Zero](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_count_trailing_zero.py)
+ * [Binary Or Operator](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_or_operator.py)
+ * [Binary Setbits](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_setbits.py)
+ * [Binary Shift](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_shift.py)
+ * [Binary Two Complement](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_two_complement.py)
+ * [Binary Xor Operator](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/binary_xor_operator.py)
+ * [Count One Of Bit](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/count_one_of_bit.py)
+ * [Reverse Bit](https://github.com/bellshade/Python/blob/main/algorithm/manipulasi_bit/reverse_bit.py)
+ * Matrix
+ * [Inverse Matrix](https://github.com/bellshade/Python/blob/main/algorithm/matrix/inverse_matrix.py)
+ * [Matrix Class](https://github.com/bellshade/Python/blob/main/algorithm/matrix/matrix_class.py)
+ * [Matrix Operation](https://github.com/bellshade/Python/blob/main/algorithm/matrix/matrix_operation.py)
+ * [Rotate Matrix](https://github.com/bellshade/Python/blob/main/algorithm/matrix/rotate_matrix.py)
+ * [Searching In Sorted Matrix](https://github.com/bellshade/Python/blob/main/algorithm/matrix/searching_in_sorted_matrix.py)
+ * [Sherman Morison](https://github.com/bellshade/Python/blob/main/algorithm/matrix/sherman_morison.py)
+ * [Spiral Matrix](https://github.com/bellshade/Python/blob/main/algorithm/matrix/spiral_matrix.py)
+ * Networking Flow
+ * [Ford Fulkerson](https://github.com/bellshade/Python/blob/main/algorithm/networking_flow/ford_fulkerson.py)
+ * [Minimum Cut](https://github.com/bellshade/Python/blob/main/algorithm/networking_flow/minimum_cut.py)
+ * Searching
+ * [ Types](https://github.com/bellshade/Python/blob/main/algorithm/searching/_types.py)
+ * [Binary Search](https://github.com/bellshade/Python/blob/main/algorithm/searching/binary_search.py)
+ * [Linear Search](https://github.com/bellshade/Python/blob/main/algorithm/searching/linear_search.py)
+ * Sorting
+ * [Bead Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bead_sort.py)
+ * [Bitonic Sorting](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bitonic_sorting.py)
+ * [Bogo Sorting](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bogo_sorting.py)
+ * [Bubble Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bubble_sort.py)
+ * [Bubble Sort Ascii](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bubble_sort_ascii.py)
+ * [Bucket Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/bucket_sort.py)
+ * [Circle Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/circle_sort.py)
+ * [Gnome Sorting](https://github.com/bellshade/Python/blob/main/algorithm/sorting/gnome_sorting.py)
+ * [Merge Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/merge_sort.py)
+ * [Pop Sort](https://github.com/bellshade/Python/blob/main/algorithm/sorting/pop_sort.py)
+ * [Quick Sorting](https://github.com/bellshade/Python/blob/main/algorithm/sorting/quick_sorting.py)
+
+## Implementation
+ * Artificial Intelligence
+ * [Decision Tree](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/decision_tree.py)
+ * [Fungsi Skoring](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/fungsi_skoring.py)
+ * [Gaussian Naive Bayes](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/gaussian_naive_bayes.py)
+ * [Gradient Descent](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/gradient_descent.py)
+ * [K Means Clutser](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/k_means_clutser.py)
+ * [K Nearest Neighbour](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/k_nearest_neighbour.py)
+ * [Lasso Regession](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/lasso_regession.py)
+ * [Linear Regression](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/linear_regression.py)
+ * [Logistic Regression](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/logistic_regression.py)
+ * [Lstm](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/lstm.py)
+ * [Normalization Data Tranform](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/normalization_data_tranform.py)
+ * [Polynominal](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/polynominal.py)
+ * [Random Forest](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/random_forest.py)
+ * [Rigde Regession](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/rigde_regession.py)
+ * [Similarity Searching](https://github.com/bellshade/Python/blob/main/implementation/artificial_intelligence/similarity_searching.py)
+ * Audio Filter
+ * [Audio Response](https://github.com/bellshade/Python/blob/main/implementation/audio_filter/audio_response.py)
+ * [Iir Filter](https://github.com/bellshade/Python/blob/main/implementation/audio_filter/iir_filter.py)
+ * Blockchain
+ * [Chinese Remainder](https://github.com/bellshade/Python/blob/main/implementation/blockchain/chinese_remainder.py)
+ * [Diophantine Equation](https://github.com/bellshade/Python/blob/main/implementation/blockchain/diophantine_equation.py)
+ * [Modular Division](https://github.com/bellshade/Python/blob/main/implementation/blockchain/modular_division.py)
+ * Celular Automata
+ * [Game Of Life](https://github.com/bellshade/Python/blob/main/implementation/celular_automata/game_of_life.py)
+ * [Nagel Schrekenberg](https://github.com/bellshade/Python/blob/main/implementation/celular_automata/nagel_schrekenberg.py)
+ * [One Dimensional](https://github.com/bellshade/Python/blob/main/implementation/celular_automata/one_dimensional.py)
+ * Chiper
+ * [Affine](https://github.com/bellshade/Python/blob/main/implementation/chiper/affine.py)
+ * [Atbash](https://github.com/bellshade/Python/blob/main/implementation/chiper/atbash.py)
+ * [Base16](https://github.com/bellshade/Python/blob/main/implementation/chiper/base16.py)
+ * [Base32](https://github.com/bellshade/Python/blob/main/implementation/chiper/base32.py)
+ * [Base64](https://github.com/bellshade/Python/blob/main/implementation/chiper/base64.py)
+ * [Base85](https://github.com/bellshade/Python/blob/main/implementation/chiper/base85.py)
+ * [Caesar](https://github.com/bellshade/Python/blob/main/implementation/chiper/caesar.py)
+ * [Cryptomath Module](https://github.com/bellshade/Python/blob/main/implementation/chiper/cryptomath_module.py)
+ * [Hill Chiper](https://github.com/bellshade/Python/blob/main/implementation/chiper/hill_chiper.py)
+ * [Playfair](https://github.com/bellshade/Python/blob/main/implementation/chiper/playfair.py)
+ * [Rot13](https://github.com/bellshade/Python/blob/main/implementation/chiper/rot13.py)
+ * Compression
+ * [Burrows Wheeler](https://github.com/bellshade/Python/blob/main/implementation/compression/burrows_wheeler.py)
+ * [Huffman](https://github.com/bellshade/Python/blob/main/implementation/compression/huffman.py)
+ * [Lempel Ziv](https://github.com/bellshade/Python/blob/main/implementation/compression/lempel_ziv.py)
+ * Computer Vision
+ * [Klasifikasi Cnn](https://github.com/bellshade/Python/blob/main/implementation/computer_vision/klasifikasi_cnn.py)
+ * Electro
+ * Conversion
+ * [Binary To Decimal](https://github.com/bellshade/Python/blob/main/implementation/electro/conversion/binary_to_decimal.py)
+ * [Binary To Octal](https://github.com/bellshade/Python/blob/main/implementation/electro/conversion/binary_to_octal.py)
+ * [Binary To String](https://github.com/bellshade/Python/blob/main/implementation/electro/conversion/binary_to_string.py)
+ * [Temperature Conversion](https://github.com/bellshade/Python/blob/main/implementation/electro/conversion/temperature_conversion.py)
+ * [Ohm](https://github.com/bellshade/Python/blob/main/implementation/electro/ohm.py)
+ * File Transfer
+ * [Receive File](https://github.com/bellshade/Python/blob/main/implementation/file_transfer/receive_file.py)
+ * [Send File](https://github.com/bellshade/Python/blob/main/implementation/file_transfer/send_file.py)
+ * Finansial
+ * [Angsuran](https://github.com/bellshade/Python/blob/main/implementation/finansial/angsuran.py)
+ * Fractal
+ * [Koch](https://github.com/bellshade/Python/blob/main/implementation/fractal/koch.py)
+ * [Mandelbrot](https://github.com/bellshade/Python/blob/main/implementation/fractal/mandelbrot.py)
+ * [Sierpinski Triangle](https://github.com/bellshade/Python/blob/main/implementation/fractal/sierpinski_triangle.py)
+ * Fuzzy Logic
+ * [Fuzzy Logic](https://github.com/bellshade/Python/blob/main/implementation/fuzzy_logic/fuzzy_logic.py)
+ * Geodesy Egineering
+ * [Ellipsodial Distance](https://github.com/bellshade/Python/blob/main/implementation/geodesy_egineering/ellipsodial_distance.py)
+ * [Haversine](https://github.com/bellshade/Python/blob/main/implementation/geodesy_egineering/haversine.py)
+ * Graphic
+ * [Bezier Curve](https://github.com/bellshade/Python/blob/main/implementation/graphic/bezier_curve.py)
+ * Image Processing
+ * [Gambar Sepia](https://github.com/bellshade/Python/blob/main/implementation/image_processing/gambar_sepia.py)
+ * Linear Algebra
+ * [Faktorisasi Lu](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/Faktorisasi_LU.py)
+ * [Ldlt Decomposition](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/LDLT_decomposition.py)
+ * [Lu Decomposition](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/LU_decomposition.py)
+ * [Conjugate Gradient](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/conjugate_gradient.py)
+ * [Operasi Matriks](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/operasi_matriks.py)
+ * [Polynom For Point](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/polynom_for_point.py)
+ * [Rayleigh Quotient](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/rayleigh_quotient.py)
+ * [Transformation 2D](https://github.com/bellshade/Python/blob/main/implementation/linear_algebra/transformation_2d.py)
+ * Physics
+ * [N Body Simulation](https://github.com/bellshade/Python/blob/main/implementation/physics/n_body_simulation.py)
+ * [Pendulum](https://github.com/bellshade/Python/blob/main/implementation/physics/pendulum.py)
+ * [Percepatan](https://github.com/bellshade/Python/blob/main/implementation/physics/percepatan.py)
+ * Statistic
+ * [Labelencoding](https://github.com/bellshade/Python/blob/main/implementation/statistic/LabelEncoding.py)
+ * [Correlation](https://github.com/bellshade/Python/blob/main/implementation/statistic/correlation.py)
+ * [Covariance](https://github.com/bellshade/Python/blob/main/implementation/statistic/covariance.py)
+ * [Entropy](https://github.com/bellshade/Python/blob/main/implementation/statistic/entropy.py)
+ * [Factoranalitic](https://github.com/bellshade/Python/blob/main/implementation/statistic/factorAnalitic.py)
+ * [Information Gain](https://github.com/bellshade/Python/blob/main/implementation/statistic/information_gain.py)
+ * [Median](https://github.com/bellshade/Python/blob/main/implementation/statistic/median.py)
+ * [Modus](https://github.com/bellshade/Python/blob/main/implementation/statistic/modus.py)
+ * [Multivariate Normal](https://github.com/bellshade/Python/blob/main/implementation/statistic/multivariate_normal.py)
+ * [Normaldistribution Multivariate](https://github.com/bellshade/Python/blob/main/implementation/statistic/normalDistribution_multivariate.py)
+ * [Rata Rata](https://github.com/bellshade/Python/blob/main/implementation/statistic/rata_rata.py)
+ * [Softmax](https://github.com/bellshade/Python/blob/main/implementation/statistic/softmax.py)
+ * [Standard Deviasi](https://github.com/bellshade/Python/blob/main/implementation/statistic/standard_deviasi.py)
+ * [Variance](https://github.com/bellshade/Python/blob/main/implementation/statistic/variance.py)
+
+## Math
+ * [ Runge Kutta](https://github.com/bellshade/Python/blob/main/math/%20runge_kutta.py)
+ * [Aliquot Sum](https://github.com/bellshade/Python/blob/main/math/aliquot_sum.py)
+ * [Angka Proth](https://github.com/bellshade/Python/blob/main/math/angka_proth.py)
+ * [Bisection Math](https://github.com/bellshade/Python/blob/main/math/bisection_math.py)
+ * [Convolution](https://github.com/bellshade/Python/blob/main/math/convolution.py)
+ * [Cos](https://github.com/bellshade/Python/blob/main/math/cos.py)
+ * [Counter](https://github.com/bellshade/Python/blob/main/math/counter.py)
+ * [Deret Taylor](https://github.com/bellshade/Python/blob/main/math/deret_taylor.py)
+ * [Digit Sum](https://github.com/bellshade/Python/blob/main/math/digit_sum.py)
+ * [Exponential Function](https://github.com/bellshade/Python/blob/main/math/exponential_function.py)
+ * [Faktor Prima](https://github.com/bellshade/Python/blob/main/math/faktor_prima.py)
+ * [Faktorial Looping](https://github.com/bellshade/Python/blob/main/math/faktorial_looping.py)
+ * [Faktorial Rekursif](https://github.com/bellshade/Python/blob/main/math/faktorial_rekursif.py)
+ * [Fft](https://github.com/bellshade/Python/blob/main/math/fft.py)
+ * [Fibonacci](https://github.com/bellshade/Python/blob/main/math/fibonacci.py)
+ * [Fungsi Gamma](https://github.com/bellshade/Python/blob/main/math/fungsi_gamma.py)
+ * [Geometric Sum](https://github.com/bellshade/Python/blob/main/math/geometric_sum.py)
+ * [Intergration](https://github.com/bellshade/Python/blob/main/math/intergration.py)
+ * [Is Prime](https://github.com/bellshade/Python/blob/main/math/is_prime.py)
+ * [Iteration Power](https://github.com/bellshade/Python/blob/main/math/iteration_power.py)
+ * [Jumlah Deret Geomteri](https://github.com/bellshade/Python/blob/main/math/jumlah_deret_geomteri.py)
+ * [Kombinasi Permutasi](https://github.com/bellshade/Python/blob/main/math/kombinasi_permutasi.py)
+ * [Midpoint](https://github.com/bellshade/Python/blob/main/math/midpoint.py)
+ * [Pascal Triangle](https://github.com/bellshade/Python/blob/main/math/pascal_triangle.py)
+ * [Persamaan Kuadarat Bilangan Kompleks](https://github.com/bellshade/Python/blob/main/math/persamaan_kuadarat_bilangan_kompleks.py)
+ * [Prime Number Library](https://github.com/bellshade/Python/blob/main/math/prime_number_library.py)
+ * [Proth Number](https://github.com/bellshade/Python/blob/main/math/proth_number.py)
+ * [Qr Decomposition](https://github.com/bellshade/Python/blob/main/math/qr_decomposition.py)
+ * [R2 Score](https://github.com/bellshade/Python/blob/main/math/r2_score.py)
+ * [Radian](https://github.com/bellshade/Python/blob/main/math/radian.py)
+ * [Random Generator](https://github.com/bellshade/Python/blob/main/math/random_generator.py)
+ * [Rectangle](https://github.com/bellshade/Python/blob/main/math/rectangle.py)
+ * [Recursion Power](https://github.com/bellshade/Python/blob/main/math/recursion_power.py)
+ * [Relu](https://github.com/bellshade/Python/blob/main/math/relu.py)
+ * [Rieman Integral](https://github.com/bellshade/Python/blob/main/math/rieman_integral.py)
+ * [Segmented Sieve](https://github.com/bellshade/Python/blob/main/math/segmented_sieve.py)
+ * [Sieve Of Eratosthenes](https://github.com/bellshade/Python/blob/main/math/sieve_of_eratosthenes.py)
+ * [Sigmoid](https://github.com/bellshade/Python/blob/main/math/sigmoid.py)
+ * [Simpson](https://github.com/bellshade/Python/blob/main/math/simpson.py)
+ * [Sin](https://github.com/bellshade/Python/blob/main/math/sin.py)
+ * [Sock Merchant](https://github.com/bellshade/Python/blob/main/math/sock_merchant.py)
+ * [Softmax](https://github.com/bellshade/Python/blob/main/math/softmax.py)
+ * [Sum Geometric Progression](https://github.com/bellshade/Python/blob/main/math/sum_geometric_progression.py)
+ * [Sylvester Sequence](https://github.com/bellshade/Python/blob/main/math/sylvester_sequence.py)
+ * [Teorema Pytaghoras](https://github.com/bellshade/Python/blob/main/math/teorema_pytaghoras.py)
+ * [Trapezoid](https://github.com/bellshade/Python/blob/main/math/trapezoid.py)
+ * [Triplet Sum](https://github.com/bellshade/Python/blob/main/math/triplet_sum.py)
+ * [Two Pointer](https://github.com/bellshade/Python/blob/main/math/two_pointer.py)
+ * [Two Sum](https://github.com/bellshade/Python/blob/main/math/two_sum.py)
+ * [Ugly Number](https://github.com/bellshade/Python/blob/main/math/ugly_number.py)
+ * [Variance](https://github.com/bellshade/Python/blob/main/math/variance.py)
+ * [Volume](https://github.com/bellshade/Python/blob/main/math/volume.py)
+ * [Zellers Congruence](https://github.com/bellshade/Python/blob/main/math/zellers_congruence.py)
+
+## Matrix
+ * [Matriks Special](https://github.com/bellshade/Python/blob/main/matrix/matriks_special.py)
+ * [Median Matriks](https://github.com/bellshade/Python/blob/main/matrix/median_matriks.py)
+ * [Pencarian Biner Matrix](https://github.com/bellshade/Python/blob/main/matrix/pencarian_biner_matrix.py)
+
+## Object Oriented
+ * Advance
+ * Pycode
+ * Argument
+ * [Args](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/argument/args.py)
+ * Decorators
+ * [Contoh Decorators1](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/contoh_decorators1.py)
+ * [Contoh Decorators2](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/contoh_decorators2.py)
+ * [Contoh Decorators3](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/contoh_decorators3.py)
+ * [Decorators](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/decorators.py)
+ * [Decorators Chaining](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/decorators_chaining.py)
+ * [Decorators Return](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/decorators/decorators_return.py)
+ * Generators
+ * [Generators For](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/generators/generators_for.py)
+ * [Generators While](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/generators/generators_while.py)
+ * Magic Methods
+ * [Mmethod](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/magic_methods/Mmethod.py)
+ * Metaclass
+ * [Composite](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/metaclass/composite.py)
+ * [Factory](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/metaclass/factory.py)
+ * [Proxy](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/metaclass/proxy.py)
+ * [Singleton](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/metaclass/singleton.py)
+ * Type Hint
+ * [Hinter](https://github.com/bellshade/Python/blob/main/object_oriented/advance/pycode/type_hint/hinter.py)
+ * Basic Oop
+ * 01 Atribut Kelas
+ * [Atribut Kelas](https://github.com/bellshade/Python/blob/main/object_oriented/basic_oop/01_atribut_kelas/atribut_kelas.py)
+ * Intermediate
+ * Abstraksi
+ * [Abstraksi](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/abstraksi/abstraksi.py)
+ * Encapsulation
+ * [Encapsulation](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/encapsulation/encapsulation.py)
+ * [Encapsulation2](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/encapsulation/encapsulation2.py)
+ * Inheritance
+ * [Inheritance](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/inheritance/inheritance.py)
+ * Polimorfis
+ * [Polimorfisme Kelas](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/polimorfis/polimorfisme_kelas.py)
+ * [Polimorfisme Sederhana](https://github.com/bellshade/Python/blob/main/object_oriented/intermediate/polimorfis/polimorfisme_sederhana.py)
+
+## Other
+ * [Anagramcheck](https://github.com/bellshade/Python/blob/main/other/anagramCheck.py)
+ * [Composite Number](https://github.com/bellshade/Python/blob/main/other/composite_number.py)
+ * [Date To Weekday](https://github.com/bellshade/Python/blob/main/other/date_to_weekday.py)
+ * [Doomsday Alg](https://github.com/bellshade/Python/blob/main/other/doomsday_alg.py)
+ * [Happy Number](https://github.com/bellshade/Python/blob/main/other/happy_number.py)
+ * [Hex To Rgb](https://github.com/bellshade/Python/blob/main/other/hex_to_rgb.py)
+ * [Is Palindrom](https://github.com/bellshade/Python/blob/main/other/is_palindrom.py)
+ * [Kaprekar Number](https://github.com/bellshade/Python/blob/main/other/kaprekar_number.py)
+ * [Krisnamurtycheck](https://github.com/bellshade/Python/blob/main/other/krisnamurtyCheck.py)
+ * [Logic Gate](https://github.com/bellshade/Python/blob/main/other/logic_gate.py)
+ * [Lucky Number](https://github.com/bellshade/Python/blob/main/other/lucky_number.py)
+ * [Power Dac](https://github.com/bellshade/Python/blob/main/other/power_dac.py)
+ * [Rgb To Hex](https://github.com/bellshade/Python/blob/main/other/rgb_to_hex.py)
+ * [Strong Password Check](https://github.com/bellshade/Python/blob/main/other/strong_password_check.py)
+ * [Taxicab](https://github.com/bellshade/Python/blob/main/other/taxicab.py)
+ * [Tower Of Hanoi](https://github.com/bellshade/Python/blob/main/other/tower_of_hanoi.py)
+ * Turtle
+ * [Logo Apple](https://github.com/bellshade/Python/blob/main/other/turtle/logo_apple.py)
+
+## Regular Expression
+ * 00 Pengenalan Regex
+ * [Contoh Regex](https://github.com/bellshade/Python/blob/main/regular_expression/00_pengenalan_regex/contoh_regex.py)
+
+## Struktur Data
+ * [Doubly Linked List](https://github.com/bellshade/Python/blob/main/struktur_data/doubly_linked_list.py)
+ * [Singly Linked List](https://github.com/bellshade/Python/blob/main/struktur_data/singly_linked_list.py)
+ * Stack
+ * [Stack List](https://github.com/bellshade/Python/blob/main/struktur_data/stack/stack_list.py)
+ * Tree
+ * Avl Tree
+ * [Avl Tree](https://github.com/bellshade/Python/blob/main/struktur_data/tree/avl_tree/avl_tree.py)
+ * Binary Search Tree
+ * [Basic Binary Tree](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_search_tree/basic_binary_tree.py)
+ * [Binary Search Tree](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_search_tree/binary_search_tree.py)
+ * [Binary Search Tree Rekursif](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_search_tree/binary_search_tree_rekursif.py)
+ * [Binary Tree Node Sum](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_search_tree/binary_tree_node_sum.py)
+ * [Binary Tree Path Sum](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_search_tree/binary_tree_path_sum.py)
+ * [Binary Tree Mirror](https://github.com/bellshade/Python/blob/main/struktur_data/tree/binary_tree_mirror.py)
+ * [Fenwick Tree](https://github.com/bellshade/Python/blob/main/struktur_data/tree/fenwick_tree.py)
+
+## Web Programming
+ * [Breadcrumb Generator](https://github.com/bellshade/Python/blob/main/web_programming/breadcrumb_generator.py)
+ * [Covid Stat Xpath](https://github.com/bellshade/Python/blob/main/web_programming/covid_stat_xpath.py)
+ * [Emisi Co2](https://github.com/bellshade/Python/blob/main/web_programming/emisi_co2.py)
+ * [Get Random Quote](https://github.com/bellshade/Python/blob/main/web_programming/get_random_quote.py)
+ * [Pagination Helper](https://github.com/bellshade/Python/blob/main/web_programming/pagination_helper.py)
+ * [Statik Corona](https://github.com/bellshade/Python/blob/main/web_programming/statik_corona.py)
diff --git a/chiper/__init__.py b/Dockerfile
similarity index 100%
rename from chiper/__init__.py
rename to Dockerfile
diff --git a/LICENSE b/LICENSE
index f745e0b4..142d8430 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) 2021 Bell shade community
+Copyright (c) 2022 Bell shade community
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index a3c17c6d..0a6ce840 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,101 @@
-# Python
-
-
-
-
-
-
-
-Repositori ini berisi kumpulan dari berbagai macam contoh struktur data, algoritma dan komputasi matematika yang diimplementasikan dengan menggunakan bahasa pemrograman Python.
-
-## Peraturan dan Pedoman Kontribusi
-Dipersilahkan bila ingin melakukan open pull requets atau kontribusi pada repositori **Python**. Sebelum itu, bacalah terlebih dahulu [peraturan dan pedomannya](CONTRIBUTING.md) yang dapat ditemukan pada ``CONTRIBUTING.md``.
-
-## Quick Access
-Semua *script* yang ada pada repositori ini, dapat diakses dengan cepat lewat link berikut:
-- [Arithmetic Analysis](https://github.com/bellshade/Python/tree/main/arithmetic_analysis)
-- [Backtracking](https://github.com/bellshade/Python/tree/main/Backtracking)
-- [Basic: Variable](https://github.com/bellshade/Python/tree/main/Basic/variable)
-- [Blockchain](https://github.com/bellshade/Python/tree/main/blockchain)
-- [Boolean Algebra](https://github.com/bellshade/Python/tree/main/boolean_algebra)
-- [Bit Manipulation](https://github.com/bellshade/Python/tree/main/manipulasi_bit)
-- [Cipher/Cryptograph](https://github.com/bellshade/Python/tree/main/chiper)
-- [Compression](https://github.com/bellshade/Python/tree/main/compression)
-- [Conversion](https://github.com/bellshade/Python/tree/main/conversion)
-- [Divide and Conquer](https://github.com/bellshade/Python/tree/main/divide_and_conquer)
-- [Electro](https://github.com/bellshade/Python/tree/main/electro)
-- [File Transfer](https://github.com/bellshade/Python/tree/main/file_transfer)
-- [Fractal](https://github.com/bellshade/Python/tree/main/fractal)
-- [Fuzzy Logic](https://github.com/bellshade/Python/tree/main/fuzzy_logic)
-- [Genetic Algorithm](https://github.com/bellshade/Python/tree/main/genetic_algo)
-- [Geodesy Engineering](https://github.com/bellshade/Python/tree/main/geodesy_egineering)
-- [Linear Algebra](https://github.com/bellshade/Python/tree/main/linear_algebra)
-- [Matrix](https://github.com/bellshade/Python/tree/main/matrix)
-- [Networking Flow](https://github.com/bellshade/Python/tree/main/networking_flow)
-- [Numerical Integration](https://github.com/bellshade/Python/tree/main/numerical_integration)
-- [Physics](https://github.com/bellshade/Python/tree/main/physics)
-- [Others Algorithm](https://github.com/bellshade/Python/tree/main/other)
+
+ 
+ Part of Bellshade Project, managed by WPU Discord Community and Kelas terbuka Discord Community
+ WPU Community is the fastest growing software developer forum initiated by Mr. Sandhika Galih
+
+
+
+
+
+
+
+
+Repositori ini berisi kumpulan berbagai macam _source code_ struktur data, algoritma, analisis matematika, dan sebagainya yang diimplementasikan dengan menggunakan bahasa pemrograman Python.
+
+## 🎉🎉 Selamat Datang di Python 🎉🎉
+
+Python dibuat dan dikembangkan oleh Guido Van Rossum, programmer yang berasal dari Belanda. Pemilihan nama python itu sendiri diambil dari sebuah acara televisi yang lumayan terkenal yang bernama **Moth Python Flying Circus** yang merupakan acara sirkus favorit dari Guido.
+
+Python adalah bahasa pemrograman multi paradigma, pemrogramaan berorientasi objek dan pemrograman terstruktur juga didukung penuh, serta banyak fiturnya mendukung pemrograman fungsional.
+
+Kelebihan diantara python antara lain
+
+- Mudah digunakan untuk menulis di perangkat lunak terbaru
+- Mudah untuk diajarkan
+- Mendukung **IoT** (**Internet of Things**)
+- Mudah dipahami
+- Serta mudah didapatkan, karena mudah diinstal, python juga termasuk **multiplatform**
+
+Contoh implementasi dari bahasa pemrograman python adalah
+
+- Komputasi ilmiah dan numerik contohnya seperti scipy
+- Aplikasi bisnis seperti tryton
+- Pembuatan game seperti battlefield 2
+- Pengembangan web seperti django atau flask (library)
+- Pengembangan dari situs web dan layanan seperti dropbox, buzfeed dan uber
+
+### Baru Belajar? Mulai dari [sini](Basic) 🌟
+
+Untuk menggunakan repositori dengan maksimal, kalian perlu belajar programming dasar dahulu. Silakan ikuti alur belajar berikut untuk mempelajari dasar-dasar pemograman langsung menggunakan Python
+
+| Langkah | Topik | Target Pembelajaran | Materi Rujukan |
+| :-----: | :------------------------------: | :-----------------------------------------------------------------------------------: | :-----------------------------------: |
+| 01 | Introduksi Pemrograman dan Python | Memahami apa itu membuat program dan apa peran Python dalam proses pembuatan program | [Materi](Basic/01_introduction) |
+| 02 | Tipe data | Memahami apa itu tipe data | [Materi](Basic/02_tipe_data) |
+| 03 | Variabel | Memahami apa itu variabel | [Materi](Basic/03_variable) |
+| 04 | Operasi | Dapat melakukan operasi sederhana menggunakan program yang ditulis menggunakan Python | [Materi](Basic/04_operator) |
+| 05 | String | Memahami String | [Materi](Basic/05_string) |
+| 06 | Input dan Output | Memahami cara mengambil input dari user | [Materi](Basic/06_input_output) |
+| 07 | Pengkondisian | Memahami salah satu dari inti dari membuat pemograman yaitu melakukan pengkondisian | [Materi](Basic/07_logika_percabangan) |
+| 08 | Perulangan | Memahami inti kedua dari pemograman yaitu melakukan perulangan | [Materi](Basic/08_perulangan) |
+| 09 | Fungsi | Mengenal konsep fungsi dalam teknik pemograman | [Materi](Basic/09_fungsi) |
+| 10 | List dan Tuple | Memahami konsep list dan tuple secara mendalam | [Materi](Basic/10_list_tuple) |
+| 11 | Manipulasi String | Memahami cara memanipulasi sebuah string | [Materi](Basic/11_manipulasi_string) |
+| 12 | Exception | Memahami konsep exception pada python | [Materi](Basic/12_exception) |
+| 13 | Module | Memahami cara mengimport sebuah module pada python | [Materi](Basic/13_module) |
+| 14 | Datetime | Mengenal module datetime pada python | [Materi](Basic/14_python_datetime) |
+| 15 | Math | Mengenal module math pada python | [Materi](Basic/15_python_math) |
+| 16 | kelas | Mengenal kelas pada python | [Materi](Basic/16_class) |
+
+Setelah menyelesaikan seluruh rangkaian pengenalan dasar-dasar pemrograman, kalian dapat mulai untuk mempelajari topik-topik lain yang jauh lebih seru!
+Untuk sekarang, mulai saja dulu dengan [Object Oriented Programming](object_oriented_programming/README.md)
+
+## 🎓 Topik Lanjutan 🎓
+
+Jika kalian sudah menguasai dasar-dasar pemrograman beserta dengan paradigma _Object Oriented Programming_, kalian bisa langsung mengeksplorasi topik-topik lain yang jauh lebih menantang dan tidak kalah seru. Di repositori ini, kami telah menyiapkan beberapa topik yang mungkin kamu suka.
+
+1. [Struktur Data](/struktur_data)
+
+2. [Web Programming](/web_programming)
+
+## ⚡ Quick Access ⚡
+
+Semua _script_ yang ada pada repositori ini, dapat diakses dengan cepat lewat link berikut:
+
+- [Basic](Basic/README.md)
+- [Algoritma](algorithm)
+- [Implementasi](implementation)
+ - [Blockchain](implementation/blockchain)
+ - [Celular automata](implementation/celular_automata)
+ - [Chiper](implementation/chiper)
+ - [Compression](implementation/compression)
+ - [Electro](implementation/electro)
+ - [File transfer](implementation/file_transfer)
+ - [Fractal](implementation/fractal)
+ - [Geodesy](implementation/geodesy_programming)
+ - [Physics](implementation/physics)
+- [Web Programming](web_programming)
+- [Implementasi Matematika](math)
+
+## 🤩 Ayo ikut kami dan berkontribusi! 🤩
+
+Bantuan kalian diperlukan Agar Bellshade dapat lebih jauh lagi membantu anak-anak Indonesia belajar _programming_, kita butuh tenaga kalian!
+
+> "Dengan Bellshade, aku jadi bisa _ngoding_! Terima kasih Bellshade!"
+
+Kami sangat senang bila kalian ingin melakukan kontribusi pada repositori **Python** ini. Tapi, sebelum itu, silahkan baca terlebih dahulu [peraturan dan pedomannya](CONTRIBUTING.md) yang telah kami siapkan. Terima kasih!
+
+Untuk informasi lebih lanjut, mari gabung dalam komunitas [Discord Channel WPU](http://discord.gg/S4rrXQU) dan [Discord Channel Kelas Terbuka](https://discord.gg/eavqxxTU)
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..034e8480
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported |
+| ------- | ------------------ |
+| 5.1.x | :white_check_mark: |
+| 5.0.x | :x: |
+| 4.0.x | :white_check_mark: |
+| < 4.0 | :x: |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.
diff --git a/algorithm/arithmetic_analysis/README.md b/algorithm/arithmetic_analysis/README.md
new file mode 100644
index 00000000..7ae2b29a
--- /dev/null
+++ b/algorithm/arithmetic_analysis/README.md
@@ -0,0 +1,32 @@
+# Arithmetic analysis
+
+Analisis numerik adalah studi algoritma untuk memecahkan masalah dalam __matematika kontinu__ (sebagimana dibedakan dalam matematika diskrit).
+
+Analisis numerik secara alami diterapkan di semua bidang rekayasa dan ilmu-ilmu fisi, tetapi pada abad ke 21, ilmu-ilmu hayati dan seni mulai mengadopsi unsur-unsur komputasi ilmiah. persamaan diferensial biasa muncul dalam pergerakan benda langit (planet, bintang dan galaksi). optimisasi muncul dalam pengeloloaan portofolio. aljabar linear numerik sangat penting dalam psikologi kuantitatif. persamaan diferensial stokastik dan rantai markov penting dalam mensimulasikan sel hidup dalam kedokteran dan biologi.
+
+list dari penerapan arithmetic analysis
+- [bisection](bisection.py)
+- [gaussian elimination](gaussian_elimination.py)
+- [in static equilibirum](in_static_equilibrium.py)
+- [intersection](intersection.py)
+- [jacobi iteration method](jacobi_iteration_method.py)
+- [newton forward interpolation](newton_forward_interpolation.py)
+- [newton method](newton_method.py)
+- [newton raphson](newton_raphson.py)
+- [root search](rootsearch.py)
+- [secant method](secant_method.py)
+
+Materi Selanjutnya: [Backtracking](../backtracking)
+
+
+## Bisection
+
+Metode bisection digunakan untuk mencari akar-akar persamaan polinomial. ini memisahkan interval dan membagi interval dimana akar persmaan terletak. Prinsip dibalik metode ini adalah teorema perantara untuk fungsi kontinu. Ia bekerja dengan mempersempit kesenjangan antara interval positif dan negatif. Ini adalah metode yagn sederhana dan relatif lambat. metode bisection juga dikenal sebagai metode interval halving, metode pencarian akar, metode pencarian biner atau metode dikotomi.
+
+## Gaussian elimination
+
+dalam matematika, _gaussian elimination_ juga dikenal dengan reduksi baris, adalah algoritma untuk menyelesaikan persamaan linier. Ini terdiri dari urutan operasi yagn dilakukan pada matrik koefisien yang sesuai. Metode ini juga dapat digunakan untuk menghitung rank suatu matriks, determinan matriks persegi, dan invers matrik yang dapat dibalik.
+
+## Static equilibrium
+
+keseimbangan statis (_static equilibrium_) mengacu pada sistem apapun dimana jumlah gaya, dan torsi, pada setiap partikel sistem adalah nol. Sederhananya, ini adalah keseimbangan sistem yang bagian-bagiannya diam.
diff --git a/arithmetic_analysis/bisection.py b/algorithm/arithmetic_analysis/bisection.py
similarity index 91%
rename from arithmetic_analysis/bisection.py
rename to algorithm/arithmetic_analysis/bisection.py
index 48d23b4e..bfcab07e 100644
--- a/arithmetic_analysis/bisection.py
+++ b/algorithm/arithmetic_analysis/bisection.py
@@ -3,7 +3,7 @@
def bisection(function: Callable[[float], float], a: float, b: float) -> float:
"""
- menemukan di mana fungsi menjadi 0 dalam [a,b] menggunakan bolzano
+ menemukan dimana fungsi menjadi 0 dalam [a,b] menggunakan bolzano
>>> bisection(lambda x: x ** 3 - 1, -5, 5)
1.0000000149011612
>>> bisection(lambda x: x ** 3 - 1, 2, 1000)
@@ -32,7 +32,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
raise ValueError("tidak dapat menemukan root dalam interval yang diberikan.")
else:
mid: float = start + (end - start) / 2.0
- while abs(start - mid) > 10 ** -7:
+ while abs(start - mid) > 10**-7:
if function(mid) == 0:
return mid
elif function(mid) * function(start) < 0:
@@ -44,7 +44,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
def float_float(x: float) -> float:
- return x ** 3 - 2 * x - 5
+ return x**3 - 2 * x - 5
if __name__ == "__main__":
diff --git a/arithmetic_analysis/gaussian_elimination.py b/algorithm/arithmetic_analysis/gaussian_elimination.py
similarity index 100%
rename from arithmetic_analysis/gaussian_elimination.py
rename to algorithm/arithmetic_analysis/gaussian_elimination.py
diff --git a/algorithm/arithmetic_analysis/in_static_equilibrium.py b/algorithm/arithmetic_analysis/in_static_equilibrium.py
new file mode 100644
index 00000000..5a8a0a17
--- /dev/null
+++ b/algorithm/arithmetic_analysis/in_static_equilibrium.py
@@ -0,0 +1,59 @@
+"""
+Memeriksa apakah sistem gaya berada dalam kesetimbangan statis.
+"""
+
+from numpy import array, cos, cross, ndarray, radians, sin
+
+
+def polar_force(
+ magnitude: float, angle: float, radian_mode: bool = False
+) -> list[float]:
+ # Menghitung force pada suatu sistem dengan menggunakan matriks
+ # rotasi dan magnitudenya.
+ # polar 10, 45 = 7.0710678118654755, 7.071067811865475
+ # polar 10, 3.14, True = -9.999987317275394, 0.01592652916486828
+ if radian_mode:
+ return [magnitude * cos(angle), magnitude * sin(angle)]
+ return [magnitude * cos(radians(angle)), magnitude * sin(radians(angle))]
+
+
+def in_static_equilibrium(
+ forces: ndarray, location: ndarray, eps: float = 10**-1
+) -> bool:
+ """
+ Menentukan apakah sistem berada dalam kesetimbangan statis.
+ Periksa apakah suatu sistem dalam keadaan setimbang.
+ Dibutuhkan dua objek numpy.array.
+ >>> force = array([[1, 1], [-1, 2]])
+ >>> location = array([[1, 0], [10, 0]])
+ >>> in_static_equilibrium(force, location)
+ False
+ """
+ moments: ndarray = cross(location, forces)
+ sum_moments: float = sum(moments)
+ return abs(sum_moments) < eps
+
+
+if __name__ == "__main__":
+ forces = array(
+ [polar_force(718.4, 180 - 30), polar_force(879.54, 45), polar_force(100, -90)]
+ )
+
+ location = array([[0, 0], [0, 0], [0, 0]])
+ assert in_static_equilibrium(forces, location)
+ forces = array(
+ [
+ polar_force(30 * 9.81, 15),
+ polar_force(215, 180 - 45),
+ polar_force(264, 90 - 30),
+ ]
+ )
+ location = array([[0, 0], [0, 0], [0, 0]])
+ assert in_static_equilibrium(forces, location)
+ forces = array([[0, -2000], [0, -1200], [0, 15600], [0, -12400]])
+ location = array([[0, 0], [6, 0], [10, 0], [12, 0]])
+ assert in_static_equilibrium(forces, location)
+
+ import doctest
+
+ doctest.testmod()
diff --git a/arithmetic_analysis/intersection.py b/algorithm/arithmetic_analysis/intersection.py
similarity index 97%
rename from arithmetic_analysis/intersection.py
rename to algorithm/arithmetic_analysis/intersection.py
index 08705e49..20085f9a 100644
--- a/arithmetic_analysis/intersection.py
+++ b/algorithm/arithmetic_analysis/intersection.py
@@ -39,7 +39,7 @@ def intersection(function: Callable[[float], float], num1: float, num2: float) -
function(x_number2)
/ ((function(x_number2) - function(x_number1)) / (x_number2 - x_number1))
)
- if abs(x_number3 - x_number2) < 10 ** -5:
+ if abs(x_number3 - x_number2) < 10**-5:
return x_number3
x_number1 = x_number2
x_number2 = x_number3
diff --git a/algorithm/arithmetic_analysis/jacobi_iteration_method.py b/algorithm/arithmetic_analysis/jacobi_iteration_method.py
new file mode 100644
index 00000000..3ade30e8
--- /dev/null
+++ b/algorithm/arithmetic_analysis/jacobi_iteration_method.py
@@ -0,0 +1,113 @@
+# dalam aljabar linier numerik, metode jacobi adalah algoritma iteratif
+# untuk menentukan solusi dari sistem persamaan linier yang dominan
+# secara diagonal.setiap elemen diagonal diselesaikan, dan nilai
+# perkiraan dimasukkan. proses ini kemudian diulang sampe konvergen.
+# algoritma ini adalah versi stipped-down dari metode transformasi jacobi
+# dari diagonalisasi matriks. metode ini dinamai carl gustav jacob jacobi
+
+
+from __future__ import annotations
+
+import numpy as np
+
+
+# metode untuk mencari solusi sistem persamaan linear
+def jacobi_iteration_method(
+ coefficient_matrix: np.ndarray,
+ constant_matrix: np.ndarray,
+ init_val: list,
+ iterations: int,
+) -> list[float]:
+ """
+ algoritma iteratif untuk menentukan solusi dari
+ dominan diagonal tegas sistem persamaan linear
+
+ 4x1 + x2 + x3 = 2
+ x2 + 5x2 + 2x3 = -6
+
+ >>> coefficient = np.array([[4, 1, 1], [1, 5, 2], [1, 2, 4]])
+ >>> constant = np.array([[2], [-6], [-4]])
+ >>> init_val = [0.5, -0.5, -0.5]
+ >>> iterations = 3
+ >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
+ [0.909375, -1.14375, -0.7484375]
+ """
+
+ rows1, cols1 = coefficient_matrix.shape
+ rows2, cols2 = constant_matrix.shape
+
+ if rows1 != cols1:
+ raise ValueError(f"koefisien matriks harus nxn tetapi sekarang {rows1}x{cols1}")
+
+ if cols2 != 1:
+ raise ValueError(f"konstanta matriks harus nx1 tetapi sekarang {rows2}x{cols2}")
+
+ if rows1 != rows2:
+ raise ValueError(
+ f"""koeifisien dan konstanta matriks harus ukuran nxn dan nx1
+ tetapi sekarang {rows1}x{cols1} dan {rows2}x{cols2}"""
+ )
+
+ if len(init_val) != rows1:
+ raise ValueError(
+ f"""jumlah nilai awal harus sama dengan jumlah baris dalam
+ koefisien matriks tetapi sekarang {len(init_val)} dan {rows1}"""
+ )
+
+ if iterations <= 0:
+ raise ValueError("iterasi setidaknya harus 1")
+
+ table = np.concatenate((coefficient_matrix, constant_matrix), axis=1)
+ rows, cols = table.shape
+
+ strictly_diagonally_dominant(table)
+
+ for i in range(iterations):
+ new_val = []
+ for row in range(rows):
+ temp = 0
+ for col in range(cols):
+ if col == row:
+ denom = table[row][col]
+ elif col == cols - 1:
+ val = table[row][col]
+ else:
+ temp += (-1) * table[row][col] * init_val[col]
+ temp = (temp + val) / denom
+ new_val.append(temp)
+ init_val = new_val
+
+ return [float(i) for i in new_val]
+
+
+# memeriksa apakah matriks yang diberikan benar-benar dominan diagonal
+def strictly_diagonally_dominant(table: np.ndarray) -> bool:
+ """
+ >>> table = np.array([[4, 1, 1, 2], [1, 5, 2, -6], [1, 2, 4, -4]])
+ >>> strictly_diagonally_dominant(table)
+ True
+ """
+ rows, cols = table.shape
+
+ is_diagonally_dominant = True
+
+ for i in range(0, rows):
+ sum = 0
+ for j in range(0, cols - 1):
+ if i == j:
+ continue
+ else:
+ sum += table[i][j]
+
+ if table[i][i] <= sum:
+ raise ValueError(
+ "matriks koefisien tidak sepenuhnya dominan secara diagonal"
+ )
+
+ return is_diagonally_dominant
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/arithmetic_analysis/lu_decomposition.py b/algorithm/arithmetic_analysis/lu_decomposition.py
similarity index 94%
rename from arithmetic_analysis/lu_decomposition.py
rename to algorithm/arithmetic_analysis/lu_decomposition.py
index 98a2c141..f2fa5fb0 100644
--- a/arithmetic_analysis/lu_decomposition.py
+++ b/algorithm/arithmetic_analysis/lu_decomposition.py
@@ -1,12 +1,9 @@
# informasi tentang lu decomposition bisa cek disini
# https://en.wikipedia.org/wiki/LU_decomposition
-
-from typing import Tuple
-
import numpy as np
-def lower_upper_decomposition(table: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
"""
contoh:
>>> matrix = np.array([[2, -2, 1], [0, 1, 2], [5, 3, 1]])
diff --git a/arithmetic_analysis/newton_forward_interpolation.py b/algorithm/arithmetic_analysis/newton_forward_interpolation.py
similarity index 95%
rename from arithmetic_analysis/newton_forward_interpolation.py
rename to algorithm/arithmetic_analysis/newton_forward_interpolation.py
index 975471e5..4d6ab56c 100644
--- a/arithmetic_analysis/newton_forward_interpolation.py
+++ b/algorithm/arithmetic_analysis/newton_forward_interpolation.py
@@ -1,5 +1,4 @@
import math
-from typing import List
# kalkulasi nilai u
@@ -21,7 +20,7 @@ def ucal(u: float, p: int) -> float:
def setcal() -> None:
n = int(input("masukkan jumlah nilai: "))
- y: List[List[float]] = []
+ y: list[list[float]] = []
for i in range(n):
y.append([])
for i in range(n):
diff --git a/arithmetic_analysis/newton_method.py b/algorithm/arithmetic_analysis/newton_method.py
similarity index 92%
rename from arithmetic_analysis/newton_method.py
rename to algorithm/arithmetic_analysis/newton_method.py
index 0fcaa1c6..5227cf85 100644
--- a/arithmetic_analysis/newton_method.py
+++ b/algorithm/arithmetic_analysis/newton_method.py
@@ -32,17 +32,17 @@ def newton(
next_guess = prev_guess - function(prev_guess) / derivative(prev_guess)
except ZeroDivisionError:
raise ZeroDivisionError("tidak dapat menemukan akar") from None
- if abs(prev_guess - next_guess) < 10 ** -5:
+ if abs(prev_guess - next_guess) < 10**-5:
return next_guess
prev_guess = next_guess
def f(x: float) -> float:
- return (x ** 3) - (2 * x) - 5
+ return (x**3) - (2 * x) - 5
def f1(x: float) -> float:
- return 3 * (x ** 2) - 2
+ return 3 * (x**2) - 2
if __name__ == "__main__":
diff --git a/arithmetic_analysis/newton_raphson.py b/algorithm/arithmetic_analysis/newton_raphson.py
similarity index 98%
rename from arithmetic_analysis/newton_raphson.py
rename to algorithm/arithmetic_analysis/newton_raphson.py
index 6174c270..434dedd9 100644
--- a/arithmetic_analysis/newton_raphson.py
+++ b/algorithm/arithmetic_analysis/newton_raphson.py
@@ -12,7 +12,7 @@
from sympy import diff
-def newton_raphson(func: str, a: float | Decimal, pres: float = 10 ** -10) -> float:
+def newton_raphson(func: str, a: float | Decimal, pres: float = 10**-10) -> float:
"""
Menemukan akar dari titik 'a' dan seterusnya dengan metode Newton-Raphson
>>> newton_raphson("sin(x)", 2)
diff --git a/algorithm/arithmetic_analysis/rootsearch.py b/algorithm/arithmetic_analysis/rootsearch.py
new file mode 100644
index 00000000..687b964e
--- /dev/null
+++ b/algorithm/arithmetic_analysis/rootsearch.py
@@ -0,0 +1,81 @@
+from typing import Callable
+
+from numpy import sign
+
+
+def root_search(
+ f: Callable[[float], float], a: float, b: float, dx: float
+) -> tuple[float, float]:
+ # Fungsi untuk menghitung nilai akar dari sebuah persamaan non linear
+ # satu variable. Ide dasarnya adalah jika f(a) dan f(b) punya tanda yang berbeda
+ # (f(a) positif, f(b) negatif atau sebaliknya),
+ # maka setidaknya ada 1 akar di interval [a, b].
+ #
+ # Parameter:
+ # f -- persamaan yang akan dihitung nilai akarnya (function)
+ # a -- batas bawah interval (float)
+ # b -- batas atas interval (float)
+ # dx -- lebar bins (besar interval yang digunakan untuk membagi suatu
+ # area di bawah kurva persamaan f.
+ x0 = a
+ f0 = f(a)
+ x1 = a + dx
+ f1 = f(x1)
+
+ while sign(f0) == sign(f1):
+ if x0 >= b:
+ raise ValueError("Akar tidak ditemukan pada interval tersebut")
+ x0 = x1
+ f0 = f1
+ x1 = x0 + dx
+ f1 = f(x1)
+ return x0, x1
+
+
+def incremental_root_search(
+ f: Callable[[float], float], x0: float, x1: float, n: int
+) -> float:
+ """
+ Secara iteratif mencari nilai akar berdasarkan fungsi root_search.
+ Secara intuitif, semakin besar nilai n, semakin akurat nilai akar yang didapatkan.
+
+ Parameter:
+ f -- persamaan yang akan dihitung nilai akarnya (function)
+ x0 -- batas bawah interval (float)
+ x1 -- batas atas interval (float)
+ n -- jumlah bins yang membagi interval [x0, x1] sama besar.
+
+ >>> incremental_root_search(lambda x: x ** 3 - 10.0 * x ** 2 + 5.0, 0.7, 1.0, 6)
+ 0.7346036499999994
+ >>> x = incremental_root_search(lambda x: x**2 - 4*x + 1, 2.0, 4.0, 6)
+ >>> x
+ 3.7320509999999993
+ >>> incremental_root_search(lambda x: x**2 - 4*x + 4, 0.0, 4.0, 6)
+ 1.9999980000000013
+ >>> incremental_root_search(lambda x: x**2 - 4*x + 4, 0.0, 1.0, 6)
+ Traceback (most recent call last):
+ ...
+ ValueError: Akar tidak ditemukan pada interval tersebut
+ """
+ for _ in range(n):
+ dx = (x1 - x0) / 10.0
+ x0, x1 = root_search(f, x0, x1, dx)
+ x = (x0 + x1) / 2.0
+
+ return x
+
+
+def equation(x: float) -> float:
+ # Berisi persamaan polinomial yang akan dicari akarnya.
+ # Bilangan basis berupa float. Bilangan pangkat (eksponen) berupa bilangan bulat.
+ # Persamaan di bawah dapat diganti-ganti.
+ #
+ # Pada kasus ini:
+ # f(x) = x^3 - 10x^2 + 5
+ return x**3 - 10.0 * x**2 + 5.0
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/arithmetic_analysis/secant_method.py b/algorithm/arithmetic_analysis/secant_method.py
similarity index 100%
rename from arithmetic_analysis/secant_method.py
rename to algorithm/arithmetic_analysis/secant_method.py
diff --git a/backtracking/README.md b/algorithm/backtracking/README.md
similarity index 93%
rename from backtracking/README.md
rename to algorithm/backtracking/README.md
index 92aaab3a..e66ed423 100644
--- a/backtracking/README.md
+++ b/algorithm/backtracking/README.md
@@ -5,4 +5,6 @@ Algoritma rekursi merupakan algoritma yang memanggil dirinya sendiri secara beru
Backtracking tidaklah berguna untuk menyelesaikan permasalahaan seperti menentukan sebuah nilai yang diberikan pada sebuah tabel yang tidak beraturan. Akan tetapi ketika diaplikasikan, backtracking biasanya lebih cepat bila dibandingkan proses pemecahan masalah brute force yang mana harus mencoba semua kandidat kemungkinannya.
-Sebagai salah satu algoritma yang banyak digunakan oleh para programmer. Backtracking merupakan sebuah alat yang penting untuk dapat menyelesaikan permasalahan pemenuhan terbatas, seperti teka – teki silang, aritmatika verbal, sudoku dan berbagai macam puzzle sejenisnya. Algoritma ini juga dapat digunakan untuk menyelesaikan permasalahan komputasional seperti memecahkan kata sandi atau password pada suatu program, membuat sistem kerja atau mekanisme kerja dari suatu video game, ataupun sistem dasar dari suatu simulasi komputer terhadap permasalahan di dunia nyata.
\ No newline at end of file
+Sebagai salah satu algoritma yang banyak digunakan oleh para programmer. Backtracking merupakan sebuah alat yang penting untuk dapat menyelesaikan permasalahan pemenuhan terbatas, seperti teka – teki silang, aritmatika verbal, sudoku dan berbagai macam puzzle sejenisnya. Algoritma ini juga dapat digunakan untuk menyelesaikan permasalahan komputasional seperti memecahkan kata sandi atau password pada suatu program, membuat sistem kerja atau mekanisme kerja dari suatu video game, ataupun sistem dasar dari suatu simulasi komputer terhadap permasalahan di dunia nyata.
+
+Materi Selanjutnya: [Boolean Algebra](../boolean_algebra)
\ No newline at end of file
diff --git a/algorithm/backtracking/all_combinations.py b/algorithm/backtracking/all_combinations.py
new file mode 100644
index 00000000..2665325c
--- /dev/null
+++ b/algorithm/backtracking/all_combinations.py
@@ -0,0 +1,48 @@
+# dalam soal contoh ini kita ingin menentukan semua
+# kemungkinan kombinasi dari k
+# angka dari 1 ... n. kita menggunakan algoritma
+# backtracking untuk memcahkan masalah
+
+from __future__ import annotations
+
+
+def generate_all_combinations(n: int, k: int) -> list[list[int]]:
+ """
+ >>> generate_all_combinations(n=4, k=2)
+ [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
+ """
+ result: list[list[int]] = []
+ create_all_state(1, n, k, [], result)
+ return result
+
+
+def create_all_state(
+ increment: int,
+ total_number: int,
+ level: int,
+ current_list: list[int],
+ total_list: list[list[int]],
+) -> None:
+ if level == 0:
+ total_list.append(current_list[:])
+ return
+
+ for i in range(increment, total_number - level + 2):
+ current_list.append(i)
+ create_all_state(i + 1, total_number, level - 1, current_list, total_list)
+ current_list.pop()
+
+
+def print_all_state(total_list: list[list[int]]) -> None:
+ for i in total_list:
+ print(*i)
+
+
+if __name__ == "__name__":
+ import doctest
+
+ doctest.testmod()
+ n = 4
+ k = 2
+ total_list = generate_all_combinations(n, k)
+ print_all_state(total_list)
diff --git a/algorithm/backtracking/cari_kata.py b/algorithm/backtracking/cari_kata.py
new file mode 100644
index 00000000..5de6eed2
--- /dev/null
+++ b/algorithm/backtracking/cari_kata.py
@@ -0,0 +1,97 @@
+# diberikan m x n grid matriks yang berisi kata
+# dan diberikan input kata yang diinginkan
+# maka akan huruf tersebut dicari, jika huruf dalam inputan
+# memenuhi maka ouput bernilai true
+# contoh problem
+# https://leetcode.com/problems/word-search/
+
+
+def dapatkan_kata_kunci(
+ panjang_papan: int, panjang_kolom_papan: int, baris: int, kolom: int
+) -> int:
+ """
+ >>> dapatkan_kata_kunci(10, 20, 1, 0)
+ 200
+ """
+ return panjang_papan * panjang_kolom_papan * baris + kolom
+
+
+def cari_kata(
+ papan: list[list[str]],
+ kata: str,
+ baris: int,
+ kolom: int,
+ indeks_kata: int,
+ set_poin: set[int],
+) -> bool:
+ """
+ >>> cari_kata([["A"]], "B", 0, 0, 0, set())
+ False
+ """
+ if papan[baris][kolom] != kata[indeks_kata]:
+ return False
+ if indeks_kata == len(kata) - 1:
+ return True
+
+ traverts_diversion = [(0, 1), (0, -1), (-1, 0), (1, 0)]
+ panjang_papan = len(papan)
+ panjang_kolom_papan = len(papan[0])
+ for direction in traverts_diversion:
+ next_i = baris + direction[0]
+ next_j = kolom + direction[1]
+ if not (0 <= next_i < panjang_papan and 0 <= next_j < panjang_kolom_papan):
+ continue
+
+ kunci = dapatkan_kata_kunci(panjang_papan, panjang_kolom_papan, next_i, next_j)
+ if kunci in set_poin:
+ continue
+
+ set_poin.add(kunci)
+ if cari_kata(papan, kata, next_i, next_j, indeks_kata + 1, set_poin):
+ return True
+
+ set_poin.remove(kunci)
+
+ return False
+
+
+def cek_kata(papan: list[list[str]], kata: str) -> bool:
+ """
+ >>> cek_kata([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "ABCCED")
+ True
+ """
+ pesan_error = "papan tidak boleh kosong,"
+ panjang_papan = len(papan)
+ if not isinstance(papan, list) or len(papan) == 0:
+ raise ValueError(pesan_error)
+
+ for baris in papan:
+ if not isinstance(baris, list) or len(baris) == 0:
+ raise ValueError(pesan_error)
+
+ for item in baris:
+ if not isinstance(item, str) or len(item) != 1:
+ raise ValueError(pesan_error)
+
+ if not isinstance(kata, str) or len(kata) == 0:
+ raise ValueError("parameter kata tidak boleh kosong")
+
+ panjang_kolom_papan = len(papan[0])
+ for i in range(panjang_papan):
+ for j in range(panjang_kolom_papan):
+ if cari_kata(
+ papan,
+ kata,
+ i,
+ j,
+ 0,
+ {dapatkan_kata_kunci(panjang_papan, panjang_kolom_papan, i, j)},
+ ):
+ return True
+ return False
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.tesmod()
diff --git a/backtracking/coloring.py b/algorithm/backtracking/coloring.py
similarity index 93%
rename from backtracking/coloring.py
rename to algorithm/backtracking/coloring.py
index 44642972..07ad415c 100644
--- a/backtracking/coloring.py
+++ b/algorithm/backtracking/coloring.py
@@ -3,10 +3,8 @@
# sedemikian rupa sehingga tidak ada simpul yang berdekatan yang diberi warna yang sama
# Wikipedia: https://en.wikipedia.org/wiki/Graph_coloring
-from typing import List
-
-def coloring(neighbours: List[int], colored_vertices: List[int], color: int) -> bool:
+def coloring(neighbours: list[int], colored_vertices: list[int], color: int) -> bool:
"""
Untuk setiap pemeriksaan apakah kendala pewarna terpenuhi
Jika salah satu dari kegagalan, kendala return False
@@ -25,7 +23,7 @@ def coloring(neighbours: List[int], colored_vertices: List[int], color: int) ->
def util_color(
- graph: List[List[int]], max_color: int, colored_vertices: List[int], index: int
+ graph: list[list[int]], max_color: int, colored_vertices: list[int], index: int
) -> bool:
"""
alur :
@@ -70,7 +68,7 @@ def util_color(
return False
-def color(graph: List[List[int]], max_color: int) -> List[int]:
+def color(graph: list[list[int]], max_color: int) -> list[int]:
"""
Fungsi pembungkus untuk memanggil subrutin yang disebut util_color
yang akan mengembalikan True atau False.
diff --git a/backtracking/combination.py b/algorithm/backtracking/combination.py
similarity index 80%
rename from backtracking/combination.py
rename to algorithm/backtracking/combination.py
index 66683f36..b75008c1 100644
--- a/backtracking/combination.py
+++ b/algorithm/backtracking/combination.py
@@ -2,16 +2,14 @@
# nomor dari 1 ... n. Kami menggunakan backtracking untuk memecahkan masalah ini.
# Kompleksitas waktu: O(C(n,k)) yaitu O(n pilih k) = O((n!/(k! * (n - k)!)))
-from typing import List
-
-def generate_combination(n: int, k: int) -> List[List[int]]:
+def generate_combination(n: int, k: int) -> list[list[int]]:
"""
>>> generate_combination(n=4, k=2)
[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
"""
- result: List[List[int]] = []
+ result: list[list[int]] = []
create_state(1, n, k, [], result)
@@ -22,10 +20,9 @@ def create_state(
increment: int,
total_number: int,
level: int,
- current_list: List[int],
- total_list: List[List[int]],
+ current_list: list[int],
+ total_list: list[list[int]],
) -> None:
-
if level == 0:
total_list.append(current_list[:])
return
@@ -35,7 +32,7 @@ def create_state(
current_list.pop()
-def print_state(total_list: List[List[int]]) -> None:
+def print_state(total_list: list[list[int]]) -> None:
for i in total_list:
print(*i)
diff --git a/backtracking/hamilton_cycle.py b/algorithm/backtracking/hamilton_cycle.py
similarity index 95%
rename from backtracking/hamilton_cycle.py
rename to algorithm/backtracking/hamilton_cycle.py
index 5675b3e5..de991c09 100644
--- a/backtracking/hamilton_cycle.py
+++ b/algorithm/backtracking/hamilton_cycle.py
@@ -6,11 +6,9 @@
# 'masalah jalur Hamiltonian', yang NP-complete.
# Wikipedia: https://en.wikipedia.org/wiki/Hamiltonian_path
-from typing import List
-
def connect(
- graph: List[List[int]], next_ver: int, current_ind: int, path: List[int]
+ graph: list[list[int]], next_ver: int, current_ind: int, path: list[int]
) -> bool:
"""
Memeriksa apakah mungkin untuk menambahkan
@@ -41,7 +39,7 @@ def connect(
return not any(vertex == next_ver for vertex in path)
-def set_hamilton_cycle(graph: List[List[int]], path: List[int], curr_ind: int) -> bool:
+def set_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int) -> bool:
"""
kode base:
1. cek jika mengecek semua sudut
@@ -97,7 +95,7 @@ def set_hamilton_cycle(graph: List[List[int]], path: List[int], curr_ind: int) -
return False
-def hamilton_cycle(graph: List[List[int]], start_index: int = 0) -> List[int]:
+def hamilton_cycle(graph: list[list[int]], start_index: int = 0) -> list[int]:
r"""
fungsi untuk memanggil subrutin yang disebut set_hamilton_cycle,
yang akan mengembalikan array simpul yang menunjukkan siklus hamiltonian
diff --git a/algorithm/backtracking/knight_tour.py b/algorithm/backtracking/knight_tour.py
new file mode 100644
index 00000000..d6ae8765
--- /dev/null
+++ b/algorithm/backtracking/knight_tour.py
@@ -0,0 +1,93 @@
+# informasi tentang knight tour
+# https://www.youtube.com/watch?v=ab_dY3dZFHM
+
+from __future__ import annotations
+
+
+def get_valid_pos(position: tuple[int, int], n: int) -> list[tuple[int, int]]:
+ """
+ mencari posisi yang valid
+ >>> get_valid_pos((1, 3), 4)
+ [(2, 1), (0, 1), (3, 2)]
+ """
+ y, x = position
+ positions = [
+ (y + 1, x + 2),
+ (y - 1, x + 2),
+ (y + 1, x - 2),
+ (y - 1, x - 2),
+ (y + 2, x + 1),
+ (y + 2, x - 1),
+ (y - 2, x + 1),
+ (y - 2, x - 1),
+ ]
+ permission_positions = []
+ for position in positions:
+ y_test, x_test = position
+ if 0 <= y_test < n and 0 <= x_test < n:
+ permission_positions.append(position)
+
+ return permission_positions
+
+
+def is_complete(board: list[list[int]]) -> bool:
+ """
+ Periksa apakah papan (matriks) telah terisi penuh dengan nilai bukan nol.
+
+ >>> is_complete([[1]])
+ True
+
+ >>> is_complete([[1, 2], [3, 0]])
+ False
+ """
+ return not any(elem == 0 for row in board for elem in row)
+
+
+def open_knight_tour_helper(
+ board: list[list[int]], pos: tuple[int, int], curr: int
+) -> bool:
+ # fungsi untuk solver dari kngiht tour
+
+ if is_complete(board):
+ return True
+
+ for position in get_valid_pos(pos, len(board)):
+ y, x = position
+
+ if board[y][x] == 0:
+ board[y][x] = curr + 1
+ if open_knight_tour_helper(board, position, curr + 1):
+ return True
+ board[y][x] = 0
+
+ return False
+
+
+def open_knight_tour(n: int) -> list[list[int]]:
+ """
+ Temukan solusi untuk masalah ksatria untuk papan berukuran n. meningkatkan
+ ValueError jika tur tidak dapat dilakukan untuk ukuran tertentu.
+
+ >>> open_knight_tour(1)
+ [[1]]
+
+ >>> open_knight_tour(2)
+ Traceback (most recent call last):
+ ...
+ ValueError: Open Knight Tour tidak dapat dilakukan di papan berukuran 2
+ """
+ board = [[0 for _ in range(n)] for _ in range(n)]
+ for i in range(n):
+ for j in range(n):
+ board[i][j] = 1
+ if open_knight_tour_helper(board, (i, j), 1):
+ return board
+ board[i][j] = 0
+
+ raise ValueError(f"Open Knight Tour tidak dapat dilakukan di papan berukuran {n}")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/backtracking/minimax.py b/algorithm/backtracking/minimax.py
similarity index 100%
rename from backtracking/minimax.py
rename to algorithm/backtracking/minimax.py
diff --git a/algorithm/backtracking/n_queen_math.py b/algorithm/backtracking/n_queen_math.py
new file mode 100644
index 00000000..7c57468e
--- /dev/null
+++ b/algorithm/backtracking/n_queen_math.py
@@ -0,0 +1,106 @@
+# Masalah n ratu adalah: menempatkan N ratu
+# di papan catur N * N sedemikian rupa sehingga tidak ada ratu
+# dapat menyerang ratu lain yang ditempatkan di papan catur itu.
+# Ini berarti bahwa satu ratu
+# tidak dapat memiliki ratu lain pada garis horizontal, vertikal dan diagonal.
+
+# solusi
+# Untuk menyelesaikan soal ini kita akan menggunakan matematika sederhana.
+# Pertama kita tahu ratu bisa bergerak semua
+# cara yang mungkin, kita dapat menyederhanakannya dalam hal ini:
+# vertikal, horizontal, diagonal kiri dan
+# diagonal kanan.
+
+# kita bisa menganalogikan
+
+# diagonal kiri = \
+# diagonal kanan = /
+
+# Pada papan catur gerakan vertikal bisa berupa baris
+# dan gerakan horizontal bisa
+# kolom.
+
+# Dalam pemrograman kita dapat menggunakan array,
+# dan dalam array ini setiap indeks dapat berupa baris dan
+# setiap nilai dalam array bisa menjadi kolom. Sebagai contoh:
+
+# . Q . .
+# . . . Q tidak bisa menyerang satu sama lain.
+# Q . . . Array untuk contoh ini akan terlihat seperti ini: [1, 3, 0, 2]
+# . . Q .
+# Kita memiliki papan catur ini dengan satu ratu di setiap kolom dan setiap ratu
+
+
+# Jadi jika kita menggunakan array
+# dan kita memverifikasi bahwa setiap nilai dalam array berbeda untuk masing-masing
+# lain kita tahu bahwa setidaknya ratu
+# tidak bisa menyerang satu sama lain secara horizontal dan
+# vertikal.
+
+
+from __future__ import annotations
+
+
+def depth_first_search(
+ possible_board: list[int],
+ diagonal_right_collisions: list[int],
+ diagonal_left_collisions: list[int],
+ boards: list[list[str]],
+ n: int,
+) -> None:
+ """
+ >>> boards = []
+ >>> depth_first_search([], [], [], boards, 4)
+ >>> for board in boards:
+ ... print(board)
+ ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . ']
+ ['. . Q . ', 'Q . . . ', '. . . Q ', '. Q . . ']
+ """
+
+ # Dapatkan baris berikutnya
+ # di papan saat ini (possible_board) untuk mengisinya dengan ratu
+ row = len(possible_board)
+
+ # Jika baris sama dengan ukuran papan itu
+ # berarti ada ratu di setiap baris di papan saat ini (kemungkinan papan)
+
+ if row == n:
+ boards.append([". " * i + "Q " + ". " * (n - 1 - i) for i in possible_board])
+ return
+
+ for col in range(n):
+ # 45 derajat = y - x = b atau 45 = row - col = b
+ # 145 derajat = y + x = b atau row + col = b
+ if (
+ col in possible_board
+ or row - col in diagonal_right_collisions
+ or row + col in diagonal_left_collisions
+ ):
+ continue
+
+ depth_first_search(
+ possible_board + [col],
+ diagonal_right_collisions + [row - col],
+ diagonal_left_collisions + [row + col],
+ boards,
+ n,
+ )
+
+
+def n_queen_solution(n: int) -> None:
+ boards: list[list[str]] = []
+ depth_first_search([], [], [], boards, n)
+
+ for board in boards:
+ for column in board:
+ print(column)
+ print("")
+
+ print(len(boards), "solusi ditemukan !")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ n_queen_solution(4)
diff --git a/backtracking/n_queens.py b/algorithm/backtracking/n_queens.py
similarity index 100%
rename from backtracking/n_queens.py
rename to algorithm/backtracking/n_queens.py
diff --git a/algorithm/backtracking/permutation.py b/algorithm/backtracking/permutation.py
new file mode 100644
index 00000000..b338761d
--- /dev/null
+++ b/algorithm/backtracking/permutation.py
@@ -0,0 +1,42 @@
+# Dalam masalah ini, kami ingin menentukan semua kemungkinan permutasi
+# dari urutan yang diberikan.
+# Kami menggunakan backtracking untuk memecahkan masalah ini.
+# Kompleksitas waktu: O(n! * n),
+# dimana n menyatakan panjang barisan yang diberikan.
+from __future__ import annotations
+
+
+def generate_all_permutaions(sequence: list[int | str]) -> None:
+ create_state_space_tree(sequence, [], 0, [0 for i in range(len(sequence))])
+
+
+def create_state_space_tree(
+ sequence: list[int | str],
+ current_sequence: list[int | str],
+ index: int,
+ index_used: list[int],
+) -> None:
+ """
+ Membuat pohon ruang untuk iterasi melalui setiap cabang menggunakan DFS.
+ Kita tahu bahwa setiap negara memiliki persis len (urutan) - anak-anak indeks.
+ Ini berakhir ketika mencapai akhir urutan yang diberikan.
+ """
+ if index == len(sequence):
+ print(current_sequence)
+ return
+
+ for i in range(len(sequence)):
+ if not index_used[i]:
+ current_sequence.append(sequence[i])
+ index_used[i] = True
+ create_state_space_tree(sequence, current_sequence, index + 1, index_used)
+ current_sequence.pop()
+ index_used[i] = False
+
+
+if __name__ == "__main__":
+ import doctest
+
+ # sequence: List[Union[int, str]] = [3, 1, 2,4]
+ # generate_permutation(sequence)
+ doctest.testmod()
diff --git a/backtracking/rat_in_maze.py b/algorithm/backtracking/rat_in_maze.py
similarity index 100%
rename from backtracking/rat_in_maze.py
rename to algorithm/backtracking/rat_in_maze.py
diff --git a/backtracking/subsequence.py b/algorithm/backtracking/subsequence.py
similarity index 63%
rename from backtracking/subsequence.py
rename to algorithm/backtracking/subsequence.py
index a40e9c96..58e3c7f4 100644
--- a/backtracking/subsequence.py
+++ b/algorithm/backtracking/subsequence.py
@@ -2,31 +2,18 @@
# dari urutan yang diberikan.
# Kami menggunakan backtracking untuk memecahkan masalah ini.
# Kompleksitas waktu: O(2^n),
-# di mana n menyatakan panjang barisan yang diberikan.
+# dimana n menyatakan panjang barisan yang diberikan.
+from __future__ import annotations
-from typing import Any, List
+from typing import Any
-def generate_subsequence(sequence: List[Any]) -> None:
- """
- >>> seq: List[Any] = [3, 1, 2, 4]
- >>> seq.clear()
- >>> seq.extend(["A", "B", "C"])
- >>> generate_subsequence(seq)
- []
- ['C']
- ['B']
- ['B', 'C']
- ['A']
- ['A', 'C']
- ['A', 'B']
- ['A', 'B', 'C']
- """
+def generate_all_subsequences(sequence: list[Any]) -> None:
create_state_space_tree(sequence, [], 0)
def create_state_space_tree(
- sequence: List[Any], current_subsequence: List[Any], index: int
+ sequence: list[Any], current_subsequence: list[Any], index: int
) -> None:
"""
membuat state_space_tree untuk beralih melalui setiap
@@ -49,9 +36,9 @@ def create_state_space_tree(
if __name__ == "__main__":
import doctest
- seq: List[Any] = [3, 1, 2, 4]
- generate_subsequence(seq)
+ seq: list[Any] = [3, 1, 2, 4]
+ generate_all_subsequences(seq)
seq.clear()
seq.extend(["A", "B", "C"])
- generate_subsequence(seq)
+ generate_all_subsequences(seq)
doctest.testmod()
diff --git a/backtracking/sudoku.py b/algorithm/backtracking/sudoku.py
similarity index 84%
rename from backtracking/sudoku.py
rename to algorithm/backtracking/sudoku.py
index 3d6db333..466a5605 100644
--- a/backtracking/sudoku.py
+++ b/algorithm/backtracking/sudoku.py
@@ -9,10 +9,9 @@
# Jika ya, kita Telah memecahkan teki">teka-teki. lain,
# kita mundur dan menempatkan nomor lain dalam sel itu dan ulangi proses ini.
+from __future__ import annotations
-from typing import List, Optional, Tuple
-
-Matrix = List[List[int]]
+Matrix = list[list[int]]
initial_grid: Matrix = [
[3, 0, 6, 5, 0, 8, 4, 0, 0],
@@ -40,13 +39,12 @@
def safe(grid: Matrix, row: int, col: int, num: int) -> bool:
- """
- Fungsi ini memeriksa kisi untuk melihat apakah setiap baris,
- kolom, dan subgrid 3x3 berisi digit 'n'.
- Ini mengembalikan False
- jika tidak 'aman' (digit duplikat ditemukan)
- pengembalian lain Benar jika 'aman'
- """
+ # Fungsi ini memeriksa kisi untuk melihat apakah setiap baris,
+ # kolom, dan subgrid 3x3 berisi digit 'n'.
+ # Ini mengembalikan False
+ # jika tidak 'aman' (digit duplikat ditemukan)
+ # pengembalian lain Benar jika 'aman'
+
for i in range(9):
if grid[row][i] == num or grid[i][col] == num:
return False
@@ -59,11 +57,9 @@ def safe(grid: Matrix, row: int, col: int, num: int) -> bool:
return True
-def find_empty_location(grid: Matrix) -> Optional[Tuple[int, int]]:
- """
- Fungsi ini menemukan lokasi kosong sehingga
- kita dapat menetapkan nomor untuk baris dan kolom tertentu.
- """
+def find_empty_location(grid: Matrix) -> tuple[int, int] | None:
+ # Fungsi ini menemukan lokasi kosong sehingga
+ # kita dapat menetapkan nomor untuk baris dan kolom tertentu.
for i in range(9):
for j in range(9):
if grid[i][j] == 0:
@@ -72,7 +68,7 @@ def find_empty_location(grid: Matrix) -> Optional[Tuple[int, int]]:
return None
-def sudoku(grid: Matrix) -> Optional[Matrix]:
+def sudoku(grid: Matrix) -> Matrix | None:
"""
Mengambil grid yang terisi sebagian
dan mencoba untuk menetapkan nilai ke semua lokasi
@@ -110,9 +106,7 @@ def sudoku(grid: Matrix) -> Optional[Matrix]:
def show_solution(grid: Matrix) -> None:
- """
- tampilkan solusi Sudoku
- """
+ # tampilkan solusi Sudoku dari ukuran 9x9
for row in grid:
for cell in row:
print(cell, end=" ")
diff --git a/algorithm/boolean_algebra/README.md b/algorithm/boolean_algebra/README.md
new file mode 100644
index 00000000..57d36c58
--- /dev/null
+++ b/algorithm/boolean_algebra/README.md
@@ -0,0 +1,3 @@
+## Boolean Algebra
+
+Materi Selanjutnya: [Divide and Conquer](../divide_and_conquer)
\ No newline at end of file
diff --git a/boolean_algebra/quinc_mc_cluskey.py b/algorithm/boolean_algebra/quinc_mc_cluskey.py
similarity index 84%
rename from boolean_algebra/quinc_mc_cluskey.py
rename to algorithm/boolean_algebra/quinc_mc_cluskey.py
index 41c43afd..494ba0fb 100644
--- a/boolean_algebra/quinc_mc_cluskey.py
+++ b/algorithm/boolean_algebra/quinc_mc_cluskey.py
@@ -4,7 +4,9 @@
# dikembangkan oleh W.V. Quine dan Edward J.McCluskey.
# https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm
-from typing import List
+from __future__ import annotations
+
+from typing import Sequence
def compare_string(string1: str, string2: str) -> str:
@@ -29,13 +31,13 @@ def compare_string(string1: str, string2: str) -> str:
return "".join(l1)
-def check(binary: List[str]) -> List[str]:
+def check(binary: list[str]) -> list[str]:
"""
>>> check(['0.00.01.5'])
['0.00.01.5']
"""
pi = []
- while 1:
+ while True:
check1 = ["$"] * len(binary)
temp = []
for i in range(len(binary)):
@@ -55,19 +57,18 @@ def check(binary: List[str]) -> List[str]:
binary = list(set(temp))
-def decimal_to_binary(no_of_variable: int, minterms: List[float]) -> List[str]:
+def decimal_to_binary(no_of_variable: int, minterms: Sequence[float]) -> list[str]:
"""
>>> decimal_to_binary(3,[1.5])
['0.00.01.5']
"""
temp = []
- s = ""
- for m in minterms:
+ for minterm in minterms:
+ string = ""
for _ in range(no_of_variable):
- s = str(m % 2) + s
- m //= 2
- temp.append(s)
- s = ""
+ string = str(minterm % 2) + string
+ minterm //= 2
+ temp.append(string)
return temp
@@ -78,19 +79,16 @@ def is_for_table(string1: str, string2: str, count: int) -> bool:
>>> is_for_table('01_','001',1)
False
"""
- l1 = list(string1)
- l2 = list(string2)
+ list1 = list(string1)
+ list2 = list(string2)
count_n = 0
- for i in range(len(l1)):
- if l1[i] != l2[i]:
+ for i in range(len(list1)):
+ if list1[i] != list2[i]:
count_n += 1
- if count_n == count:
- return True
- else:
- return False
+ return count_n == count
-def selection(chart: List[List[int]], prime_implicants: List[str]) -> List[str]:
+def selection(chart: list[list[int]], prime_implicants: list[str]) -> list[str]:
"""
>>> selection([[1]], ['0.00.01.5'])
['0.00.01.5']
@@ -113,7 +111,7 @@ def selection(chart: List[List[int]], prime_implicants: List[str]) -> List[str]:
for k in range(len(chart)):
chart[k][j] = 0
temp.append(prime_implicants[i])
- while 1:
+ while True:
max_n = 0
rem = -1
count_n = 0
@@ -134,8 +132,8 @@ def selection(chart: List[List[int]], prime_implicants: List[str]) -> List[str]:
def prime_implicant_chart(
- prime_implicants: List[str], binary: List[str]
-) -> List[List[int]]:
+ prime_implicants: list[str], binary: list[str]
+) -> list[list[int]]:
"""
>>> prime_implicant_chart(['0.00.01.5'], ['0.00.01.5'])
[[1]]
@@ -160,7 +158,7 @@ def prime_implicant_chart(
# ]
# binary = decimal_to_binary(no_of_variable, minterms)
-# prime_implicants = check(binary)
+# prime_implicaants = check(binary)
# print("Prime Implicant adalah:")
# print(prime_implicants)
# chart = prime_implicant_chart(prime_implicants, binary)
diff --git a/algorithm/divide_and_conquer/README.md b/algorithm/divide_and_conquer/README.md
new file mode 100644
index 00000000..70fb8e61
--- /dev/null
+++ b/algorithm/divide_and_conquer/README.md
@@ -0,0 +1,3 @@
+## Divide and Conquer
+
+Materi Selanjutnya: [Fuzzy Logic](../fuzzy_logic)
\ No newline at end of file
diff --git a/divide_and_conquer/closest_pair_of_points.py b/algorithm/divide_and_conquer/closest_pair_of_points.py
similarity index 97%
rename from divide_and_conquer/closest_pair_of_points.py
rename to algorithm/divide_and_conquer/closest_pair_of_points.py
index 39837d8e..534304d0 100644
--- a/divide_and_conquer/closest_pair_of_points.py
+++ b/algorithm/divide_and_conquer/closest_pair_of_points.py
@@ -9,9 +9,6 @@
# time complexity: O(n * log n)
-from typing import List
-
-
def euclidan_distance_sqr(point1, point2):
"""
>>> euclidan_distance_sqr([1, 2], [2, 4])
@@ -20,7 +17,7 @@ def euclidan_distance_sqr(point1, point2):
return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2
-def column_based_sort(array, column) -> List[tuple]:
+def column_based_sort(array, column) -> list[tuple]:
"""
>>> column_based_sort([(5, 1), (4, 2), (3, 0)], 1)
[(3, 0), (5, 1), (4, 2)]
@@ -63,7 +60,6 @@ def dis_between_closest_in_strip(points, point_count, min_dis=float("inf")):
def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, point_count):
-
"""
>>> points = [(1, 2), (3, 4)]
>>> points2 = [(5,6), (7,8)]
diff --git a/divide_and_conquer/convex_hull.py b/algorithm/divide_and_conquer/convex_hull.py
similarity index 95%
rename from divide_and_conquer/convex_hull.py
rename to algorithm/divide_and_conquer/convex_hull.py
index caa8142d..2ed49267 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/algorithm/divide_and_conquer/convex_hull.py
@@ -8,7 +8,7 @@
# 1. Algoritma brute-force yang berjalan di O(n^3)
# 2. Algoritma bagi-dan-taklukkan yang berjalan di O(n log(n))
-from typing import Iterable, List, Set, Union
+from typing import Iterable
class Point:
@@ -79,8 +79,8 @@ def __hash__(self):
def _construct_points(
- list_of_tuples: Union[List[Point], List[List[float]], Iterable[List[float]]]
-) -> List[Point]:
+ list_of_tuples: list[Point] | list[list[float]] | Iterable[list[float]],
+) -> list[Point]:
"""
membangun daftar poin dari objek angka seperti array
@@ -93,7 +93,7 @@ def _construct_points(
Return
--------
- points: daftar di mana setiap item bertipe Point. Ini hanya berisi objek
+ points: daftar dimana setiap item bertipe Point. Ini hanya berisi objek
yang dapat diubah menjadi Point.
Contoh
@@ -110,7 +110,7 @@ def _construct_points(
[]
"""
- points: List[Point] = []
+ points: list[Point] = []
if list_of_tuples:
for p in list_of_tuples:
if isinstance(p, Point):
@@ -126,7 +126,7 @@ def _construct_points(
return points
-def _validate_input(points: Union[List[Point], List[List[float]]]) -> List[Point]:
+def _validate_input(points: list[Point] | list[list[float]]) -> list[Point]:
"""
memvalidasi instance input sebelum algoritma convex-hull menggunakannya
@@ -204,7 +204,7 @@ def _det(a: Point, b: Point, c: Point) -> float:
return det
-def convex_hull_bf(points: List[Point]) -> List[Point]:
+def convex_hull_bf(points: list[Point]) -> list[Point]:
"""
Membangun lambung cembung dari satu set poin
2D menggunakan algoritma brute force.
@@ -263,7 +263,7 @@ def convex_hull_bf(points: List[Point]) -> List[Point]:
return sorted(convex_set)
-def convex_hull_recursive(points: List[Point]) -> List[Point]:
+def convex_hull_recursive(points: list[Point]) -> list[Point]:
"""
Membangun lambung cembung dari satu set poin
2D menggunakan strategi membagi-dan-menaklukkan
@@ -311,7 +311,7 @@ def convex_hull_recursive(points: List[Point]) -> List[Point]:
def _construct_hull(
- points: List[Point], left: Point, right: Point, convex_set: Set[Point]
+ points: list[Point], left: Point, right: Point, convex_set: set[Point]
) -> None:
if points:
extreme_point = None
@@ -334,7 +334,7 @@ def _construct_hull(
_construct_hull(candidate_points, extreme_point, right, convex_set)
-def convex_hull_melkman(points: List[Point]) -> List[Point]:
+def convex_hull_melkman(points: list[Point]) -> list[Point]:
"""
Membangun lambung cembung dari satu set titik 2D menggunakan algoritma melkman.
Algoritma ini bekerja dengan menyisipkan
diff --git a/divide_and_conquer/heap_algorithm.py b/algorithm/divide_and_conquer/heap_algorithm.py
similarity index 100%
rename from divide_and_conquer/heap_algorithm.py
rename to algorithm/divide_and_conquer/heap_algorithm.py
diff --git a/divide_and_conquer/inversion.py b/algorithm/divide_and_conquer/inversion.py
similarity index 100%
rename from divide_and_conquer/inversion.py
rename to algorithm/divide_and_conquer/inversion.py
diff --git a/divide_and_conquer/kth_order_statistic.py b/algorithm/divide_and_conquer/kth_order_statistic.py
similarity index 100%
rename from divide_and_conquer/kth_order_statistic.py
rename to algorithm/divide_and_conquer/kth_order_statistic.py
diff --git a/divide_and_conquer/max_difference_pair.py b/algorithm/divide_and_conquer/max_difference_pair.py
similarity index 100%
rename from divide_and_conquer/max_difference_pair.py
rename to algorithm/divide_and_conquer/max_difference_pair.py
diff --git a/divide_and_conquer/max_subarray_sum.py b/algorithm/divide_and_conquer/max_subarray_sum.py
similarity index 100%
rename from divide_and_conquer/max_subarray_sum.py
rename to algorithm/divide_and_conquer/max_subarray_sum.py
diff --git a/algorithm/fuzzy_logic/README.md b/algorithm/fuzzy_logic/README.md
new file mode 100644
index 00000000..9f3da63b
--- /dev/null
+++ b/algorithm/fuzzy_logic/README.md
@@ -0,0 +1,3 @@
+## Fuzzy Logic
+
+Materi Selanjutnya: [Genetic Algo](../genetic_algo)
\ No newline at end of file
diff --git a/fuzzy_logic/fuzzy_operation.py b/algorithm/fuzzy_logic/fuzzy_operation.py
similarity index 97%
rename from fuzzy_logic/fuzzy_operation.py
rename to algorithm/fuzzy_logic/fuzzy_operation.py
index 5da3b0e0..8112bb29 100644
--- a/fuzzy_logic/fuzzy_operation.py
+++ b/algorithm/fuzzy_logic/fuzzy_operation.py
@@ -1,7 +1,11 @@
# list set operasi fuzzy
# https://en.wikipedia.org/wiki/Fuzzy_set_operations
import numpy as np
-import skfuzzy as fuzz
+
+try:
+ import skfuzzy as fuzz
+except ImportError:
+ fuzz = None
if __name__ == "__main__":
# buat universe dengan meggunakan linspace()
diff --git a/algorithm/genetic_algo/README.md b/algorithm/genetic_algo/README.md
new file mode 100644
index 00000000..a1a1ecdb
--- /dev/null
+++ b/algorithm/genetic_algo/README.md
@@ -0,0 +1,3 @@
+## Genetic Algo
+
+Materi Selanjutnya: [Manipulasi Bit](../manipulasi_bit)
\ No newline at end of file
diff --git a/genetic_algo/basic_string.py b/algorithm/genetic_algo/basic_string.py
similarity index 100%
rename from genetic_algo/basic_string.py
rename to algorithm/genetic_algo/basic_string.py
diff --git a/algorithm/manipulasi_bit/README.md b/algorithm/manipulasi_bit/README.md
new file mode 100644
index 00000000..3a6864ac
--- /dev/null
+++ b/algorithm/manipulasi_bit/README.md
@@ -0,0 +1,13 @@
+## Manipulasi Bit
+
+manipulasi bit adalah tindakan manipulasi bit atau potongan data ain secaara algoritmik yang lebih pendek dari sebuah kata. manipulasi bit adalah suatu yang memiliki kompleksitas waktu yang konstan. manipulasi bit juga dalah proses penerapan operasi logis pada urutan bit untuk mencapai hasil yang diperlukan. tugas pemograman komputer yang memerlukan manipulasi bit meliputi:
+
+- kontrol perangkat tingkat rendah
+- deteksi kesalahan dan algoritma koreksi
+- kompresi data
+- algoritma enkripsi
+- optimaasi
+
+untuk sebagian besar tugs lainnya, bahasa pemograman modern memungkinkan pemrogram untuk bekerja secara langsung dengan abstraksi alih-alih bit yang mewakili abstraksi tersebut. manipulasi bit dapat meniadakan atau mengurangi kebutuhan untuk mengulang struktur data dan dapat mempercepat pengkodean karena manipulasi bit diproses secara paralel.
+
+Materi Selanjutnya: [Matrix](../matrix)
\ No newline at end of file
diff --git a/manipulasi_bit/binary_and_operator.py b/algorithm/manipulasi_bit/binary_and_operator.py
similarity index 100%
rename from manipulasi_bit/binary_and_operator.py
rename to algorithm/manipulasi_bit/binary_and_operator.py
diff --git a/manipulasi_bit/binary_count_trailing_zero.py b/algorithm/manipulasi_bit/binary_count_trailing_zero.py
similarity index 100%
rename from manipulasi_bit/binary_count_trailing_zero.py
rename to algorithm/manipulasi_bit/binary_count_trailing_zero.py
diff --git a/manipulasi_bit/binary_or_operator.py b/algorithm/manipulasi_bit/binary_or_operator.py
similarity index 100%
rename from manipulasi_bit/binary_or_operator.py
rename to algorithm/manipulasi_bit/binary_or_operator.py
diff --git a/manipulasi_bit/binary_setbits.py b/algorithm/manipulasi_bit/binary_setbits.py
similarity index 100%
rename from manipulasi_bit/binary_setbits.py
rename to algorithm/manipulasi_bit/binary_setbits.py
diff --git a/manipulasi_bit/binary_shift.py b/algorithm/manipulasi_bit/binary_shift.py
similarity index 100%
rename from manipulasi_bit/binary_shift.py
rename to algorithm/manipulasi_bit/binary_shift.py
diff --git a/manipulasi_bit/binary_two_complement.py b/algorithm/manipulasi_bit/binary_two_complement.py
similarity index 100%
rename from manipulasi_bit/binary_two_complement.py
rename to algorithm/manipulasi_bit/binary_two_complement.py
diff --git a/manipulasi_bit/binary_xor_operator.py b/algorithm/manipulasi_bit/binary_xor_operator.py
similarity index 100%
rename from manipulasi_bit/binary_xor_operator.py
rename to algorithm/manipulasi_bit/binary_xor_operator.py
diff --git a/manipulasi_bit/count_one_of_bit.py b/algorithm/manipulasi_bit/count_one_of_bit.py
similarity index 100%
rename from manipulasi_bit/count_one_of_bit.py
rename to algorithm/manipulasi_bit/count_one_of_bit.py
diff --git a/manipulasi_bit/reverse_bit.py b/algorithm/manipulasi_bit/reverse_bit.py
similarity index 100%
rename from manipulasi_bit/reverse_bit.py
rename to algorithm/manipulasi_bit/reverse_bit.py
diff --git a/algorithm/matrix/README.md b/algorithm/matrix/README.md
new file mode 100644
index 00000000..c21734ab
--- /dev/null
+++ b/algorithm/matrix/README.md
@@ -0,0 +1,3 @@
+## Matrix
+
+Materi Selanjutnya: [Networking Flow](../networking_flow)
\ No newline at end of file
diff --git a/matrix/inverse_matrix.py b/algorithm/matrix/inverse_matrix.py
similarity index 100%
rename from matrix/inverse_matrix.py
rename to algorithm/matrix/inverse_matrix.py
diff --git a/matrix/matrix_class.py b/algorithm/matrix/matrix_class.py
similarity index 96%
rename from matrix/matrix_class.py
rename to algorithm/matrix/matrix_class.py
index 1cf8a39f..368b4aba 100644
--- a/matrix/matrix_class.py
+++ b/algorithm/matrix/matrix_class.py
@@ -4,7 +4,7 @@
class Matrix:
"""
Objek matriks yang dihasilkan dari array 2D
- di mana setiap elemen adalah array yang mewakili
+ dimana setiap elemen adalah array yang mewakili
berturut-turut.
Baris dapat berisi tipe int atau float.
Operasi umum dan informasi tersedia.
@@ -120,9 +120,11 @@ def cofactors(self):
return Matrix(
[
[
- self.minors().rows[row][column]
- if (row + column) % 2 == 0
- else self.minors().rows[row][column] * -1
+ (
+ self.minors().rows[row][column]
+ if (row + column) % 2 == 0
+ else self.minors().rows[row][column] * -1
+ )
for column in range(self.minors().num_columns)
]
for row in range(self.minors().num_rows)
diff --git a/algorithm/matrix/matrix_operation.py b/algorithm/matrix/matrix_operation.py
new file mode 100644
index 00000000..b542ec0e
--- /dev/null
+++ b/algorithm/matrix/matrix_operation.py
@@ -0,0 +1,158 @@
+# mencari hasil dari 2dimensional matriks
+
+from __future__ import annotations
+
+
+def tambah(*matrix_s: list[list]) -> list[list]:
+ """
+ >>> tambah([[1,2], [3,4]], [[2,3], [4,5]])
+ [[3, 5], [7, 9]]
+ """
+ if all(_check_not_integer(m) for m in matrix_s):
+ for i in matrix_s[1:]:
+ _verify_matrix_size(matrix_s[0], i)
+ return [[sum(t) for t in zip(*m)] for m in zip(*matrix_s)]
+
+ raise TypeError("masukkan tipe berupa list tidak integer")
+
+
+def kurang(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
+ """
+ >>> kurang([[1,2],[3,4]],[[2,3],[4,5]])
+ [[-1, -1], [-1, -1]]
+ """
+ if (
+ _check_not_integer(matrix_a)
+ and _check_not_integer(matrix_b)
+ and _verify_matrix_size(matrix_a, matrix_b)
+ ):
+ return [[i - j for i, j in zip(*m)] for m in zip(matrix_a, matrix_b)]
+
+ raise TypeError("masukkan tipe berupa 2 list tidak integer")
+
+
+def perkalian_scalar(matrix: list[list], n: int | float) -> list[list]:
+ """
+ >>> perkalian_scalar([[1,2],[3,4]],5)
+ [[5, 10], [15, 20]]
+ """
+ return [[x * n for x in row] for row in matrix]
+
+
+def perkalian(matrix_a: list[list], matrix_b: list[list]) -> list[list]:
+ """
+ >>> perkalian([[1,2],[3,4]],[[5,5],[7,5]])
+ [[19, 15], [43, 35]]
+ >>> perkalian([[1,2.5],[3,4.5]],[[5,5],[7,5]])
+ [[22.5, 17.5], [46.5, 37.5]]
+ >>> perkalian([[1, 2, 3]], [[2], [3], [4]])
+ [[20]]
+ """
+ if _check_not_integer(matrix_a) and _check_not_integer(matrix_b):
+ rows, cols = _verify_matrix_size(matrix_a, matrix_b)
+
+ if cols[0] != rows[1]:
+ raise ValueError(
+ f"tidak bisa mengalikan dimensi matrix ({rows[0], cols[0]})"
+ f" dan ({rows[1]}, {cols[1]})"
+ )
+
+ return [
+ [sum(m * n for m, n in zip(i, j)) for j in zip(*matrix_b)] for i in matrix_a
+ ]
+
+
+def identity(n: int) -> list[list]:
+ """
+ >>> identity(3)
+ [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+ """
+ n = int(n)
+ return [[int(row == column) for column in range(n)] for row in range(n)]
+
+
+def transpose(matrix: list[list], return_map: bool = True) -> list[list] | map[list]:
+ """
+ >>> transpose([[1,2],[3,4]]) # doctest: +ELLIPSIS
+