Belajar Algoritm - Pre-Requisites Skill & Setup Environment

#Pendahuluan

Selamat datang di series Belajar Algoritm! Series ini akan membawa kalian memahami algoritma — fondasi utama pemrograman komputer — dari definisi, analisis kompleksitas, hingga teknik desain yang dipakai di coding interview, optimasi sistem, dan aplikasi AI modern. Total ada 28 episode yang tersusun dalam enam fase, dari fondasi analisis hingga graph algorithms, randomized, dan problem classification.

Sebelum menulis kode algoritma pertama, ada skill dasar dan perangkat yang wajib kalian siapkan. Mengapa prasyarat ini penting? Karena algoritma bukan tentang menghafal sintaks — ia tentang berpikir logis terhadap masalah. Tanpa fondasi rekursi, manipulasi array, dan pemahaman kompleksitas, kalian akan kesulitan memahami mengapa sebuah algoritma lebih baik dari yang lain.

Episode 0 ini adalah pijakan kalian: kita akan memastikan skill dasar terpenuhi, menyiapkan environment coding, dan memverifikasi bahwa kalian siap mengikuti 27 episode ke depan.

#Skill Dasar yang Wajib Dimiliki

#Dasar Pemrograman

Kalian harus nyaman dengan setidaknya satu bahasa umum — Python, JavaScript, Java, atau C++. Yang terpenting bukan syntax-nya, melainkan kemampuan menulis fungsi yang menerima input, memproses data, dan mengembalikan output. Pastikan kalian bisa:

• Menulis fungsi dengan parameter dan return value.
• Menggunakan loop (for, while) dan conditional (if/else).
• Mengelola array/list dan object/map.

#Rekursi Dasar

Rekursi adalah fondasi banyak algoritma — dari binary search hingga divide & conquer. Kalian harus memahami konsep base case dan recursive case:

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

factorial(5) akan memanggil factorial(4), yang memanggil factorial(3), dan seterusnya sampai base case n <= 1. Tanpa pemahaman ini, divide & conquer dan dynamic programming akan terasa seperti sihir.

#Manipulasi Array

Sebagian besar algoritma bekerja dengan array. Kalian wajib bisa:

• Mengakses elemen berdasarkan indeks.
• Iterasi forward dan backward.
• Menyisipkan/menghapus elemen (dan memahami kompleksitas operasinya).

#Menghitung Big-O Secara Manual

Ini adalah skill paling kritis sebelum masuk ke analisis algoritma. Kalian harus bisa menentukan waktu eksekusi sebuah fungsi berdasarkan ukuran input n:

def count_pairs(arr):
    count = 0
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] + arr[j] == 0:
                count += 1
    return count

Nested loop dengan iterasi Independen → O(n²). Kita akan memperdalam ini di episode 2, tetapi kalian harus bisa mengidentifikasi pola dasarnya sekarang.

#Perangkat Software yang Disiapkan

#Bahasa Prototipe

Untuk series ini, Python direkomendasikan sebagai bahasa prototipe utama karena sintaksnya ringkas dan mudah dibaca. Namun kalian boleh menggunakan bahasa lain yang nyaman. Yang penting adalah konsistensi — jangan ganti-ganti bahasa di tengah series.

python3 --version

Jika belum terinstall, gunakan package manager sesuai distro:

sudo apt install python3          # Debian/Ubuntu
sudo dnf install python3          # RHEL/Fedora

#Profiler untuk Verifikasi

Kita akan mengukur waktu aktual algoritma untuk memverifikasi analisis teoritis. Python sudah punya built-in timeit:

import timeit
 
def linear_search(arr, target):
    for x in arr:
        if x == target:
            return True
    return False
 
#ukur waktu
n = 10000
arr = list(range(n))
timeit.timeit(lambda: linear_search(arr, n - 1), number=100)

#Visualisasi Langkah

Untuk memahami algoritma secara visual, gunakan pen & paper terlebih dahulu — gambar array, lingkari elemen yang berubah, dan catat setiap langkah. Setelah konsepnya jelas, barulah implementasikan dalam kode. Tools seperti VisuAlgo (visualgo.net) berguna untuk verifikasi, tetapi pemahaman manual lebih dalam.

#Verifikasi Environment

Sebelum lanjut ke episode 1, jalankan verifikasi menyeluruh:

python3 --version
python3 -c "print('Algoritma ready')"

Checklist akhir:

• Python 3.x terinstall dan berfungsi.
• Kalian bisa menulis fungsi dengan return value.
• Kalian bisa menulis rekursi dengan base case.
• Kalian bisa menghitung Big-O dari loop sederhana (O(n), O(n²), O(log n)).

#Ringkasan Prasyarat

Rangkuman yang sudah kalian siapkan di episode 0:

• Skill: dasar pemrograman, rekursi, manipulasi array, menghitung Big-O manual.
• Tool: Python 3.x terinstall, timeit untuk profiling, pen & paper untuk visualisasi.
• Verifikasi: fungsi sederhana berjalan, Big-O bisa diidentifikasi.

Jika ada yang belum terpenuhi, berhenti dulu dan lengkapi sebelum melanjutkan. Perjalanan 27 episode ke depan akan jauh lebih lancar dengan pijakan yang kuat ini.

#Penutup

Inti yang harus dibawa pulang:

• Algoritma membutuhkan fondasi pemrograman, rekursi, dan analisis kompleksitas sebelum bisa dipelajari secara mendalam.
• Siapkan environment coding dengan Python atau bahasa favorit kalian.
• Latihan Big-O manual adalah kunci — verifier dengan pengukuran waktu aktual.
• Jika ada skill yang belum kuat, perkuat dulu sebelum lanjut.

Di episode 1 selanjutnya kita akan membahas apa itu algoritma dan korektivitas — definisi formal, properti algoritma, loop invariant, postcondition, dan mengapa membuktikan algoritma benar harus dilakukan sebelum mengoptimasi. Pastikan environment kalian sudah siap, karena perjalanan Belajar Algoritm baru saja dimulai!