Belajar Math - Arithmetic & Aljabar Dasar
Operator precedence, pecahan, persentase, akar kuadrat, persamaan linear, dan pertidaksamaan adalah fondasi untuk pricing logic, diskon, bunga, dan grading algorithms. Di episode ini kalian memperkuat aritmatik dan aljabar dasar dengan verifikasi Python.
#Pendahuluan
Setelah di episode 2 kita menguasai number systems — biner, oktal, heksadesimal, dan bitwise operators — pada episode ini kita kembali ke dasar yang sering dianggap "terlalu sederhana" untuk dipelajari: arithmetic dan aljabar. Padahal, kesalahan aritmatik dalam kode production — hangusnya angka desimal, salah posisi operator precedence, atau perhitungan persentase yang salah — adalah sumber bug yang sangat umum dan sulit dideteksi.
Mengapa harus mempelajari ini lagi? Karena programmer sering melewati dasar ini terlalu cepat. Memahami operator precedence secara eksplisit, menangani pecahan dengan benar, dan menulis persamaan linear dari masalah bisnis adalah keterampilan yang langsung berguna setiap hari — dari pricing logic hingga scoring algorithms.
#Operator Precedence
Urutan operasi dalam matematika mengikuti aturan baku: PEMDAS/BODMAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction). Dalam kode, precedence bisa berbeda dari yang kalian kira:
# Tanpa parentheses — hasilnya mungkin mengejutkan
result1 = 2 + 3 * 4 # 14, bukan 20
result2 = (2 + 3) * 4 # 20 — paksa dulu penjumlahan
# Eksponensial di Python
result3 = 2 ** 3 ** 2 # 512 (2^(3^2)), bukan 64 ((2^3)^2)
result4 = (2 ** 3) ** 2 # 64 — eksponensial kanan-ke-kiri
print(f"2 + 3 * 4 = {result1}")
print(f"(2 + 3) * 4 = {result2}")
print(f"2 ** 3 ** 2 = {result3}")
print(f"(2 ** 3) ** 2 = {result4}")Tip
Ketika ragu, gunakan parentheses untuk memperjelas. Code yang jelas lebih berharga dari kode yang "pendek tapi membingungkan." Jika kalian harus berpikir lebih dari 2 detik untuk memahami precedence, tambahkan parentheses.
#Pecahan dan Desimal
#Konversi Pecahan ke Desimal
Banyak masalah real-world melibatkan pecahan — tidak selalu bilangan bulat. Memahami bagaimana pecahan berubah menjadi desimal (dan sebaliknya) membantu menghindari pembulatan yang salah:
from fractions import Fraction
# Pecahan biasa
f = Fraction(3, 8)
print(f"3/8 = {float(f)}") # 0.375
print(f"3/8 = {f.numerator}/{f.denominator}") # 3/8
# Konversi desimal ke pecahan
f2 = Fraction(0.125)
print(f"0.125 = {f2}") # 1/8
# Operasi pecahan — presisi penuh
result = Fraction(1, 3) + Fraction(1, 6)
print(f"1/3 + 1/6 = {result}") # 1/2
print(f"Desimal: {float(result)}") # 0.5#Pembulatan dan Presisi
Pembulatan desimal adalah sumber bug umum. Python punya beberapa strategi pembulatan:
import math
# Pembulatan banker (Python default) — bulat ke genap
print(f"round(2.5) = {round(2.5)}") # 2
print(f"round(3.5) = {round(3.5)}") # 4
# Pembulatan ke atas/bawah
print(f"math.ceil(2.1) = {math.ceil(2.1)}") # 3
print(f"math.floor(2.9) = {math.floor(2.9)}") # 2
# Pembulatan ke N desimal
print(f"round(3.14159, 2) = {round(3.14159, 2)}") # 3.14#Persentase
Persentase adalah salah satu konsep yang paling sering dipakai dalam kode bisnis — diskon, markup, pajak, komisi, interest rates. Kuncinya: persentase hanyalah pecahan dengan penyebut 100.
#Rumus Dasar
def hitung_diskon(harga: float, diskon_persen: float) -> float:
"""Menghitung harga setelah diskon."""
return harga * (1 - diskon_persen / 100)
def hitung_pajak(harga: float, pajak_persen: float) -> float:
"""Menghitung harga termasuk pajak."""
return harga * (1 + pajak_persen / 100)
def hitung_markup(harga_modal: float, markup_persen: float) -> float:
"""Menghitung harga jual dengan markup."""
return harga_modal * (1 + markup_persen / 100)
# Contoh penggunaan
sepatu = 500000
harga_diskon = hitung_diskon(sepatu, 20) # diskon 20%
harga_pajak = hitung_pajak(harga_diskon, 11) # pajak 11%
print(f"Harga awal: Rp {sepatu:,.0f}")
print(f"Setelah diskon: Rp {harga_diskon:,.0f}")
print(f"Setelah pajak: Rp {harga_pajak:,.0f}")#Kesalahan Umum: Persentase dari Hasil Sebelumnya
Kesalahan paling umum dalam pricing: menerapkan diskon berturut-turut dari harga yang berbeda basis.
harga = 1000000
# SALAH: diskon 10% lalu 20% dari harga awal
salah = harga * 0.9 * 0.8 # = 720000 (benar)
# KESALAHAN UMUM: mengira total diskon = 30%
salah_pemahaman = harga * 0.7 # = 700000 (SALAH!)
print(f"Diskon 10% lalu 20%: Rp {salah:,.0f}") # Rp 720,000
print(f"Jika total diskon 30%: Rp {salah_pemahaman:,.0f}") # Rp 700,000
print(f"Selisih: Rp {salah - salah_pemahaman:,.0f}") # Rp 20,000
print("Diskon berturut-turut TIDAK sama dengan jumlah persentase!")#Akar Kuadrat dan Eksponensial
#Akar Kuadrat
Akar kuadrat adalah kebalikan dari eksponensial pangkat 2. Dalam kode, akar kuadrat muncul di jarak Euclidean, standar deviasi, dan normalisasi vektor:
import math
# Akar kuadrat dasar
print(f"√144 = {math.sqrt(144)}") # 12.0
print(f"√2 = {math.sqrt(2):.6f}") # 1.414214
# Akar kuadrat untuk jarak Euclidean
def jarak(x1, y1, x2, y2):
return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(f"Jarak (0,0) ke (3,4) = {jarak(0, 0, 3, 4)}") # 5.0
# Eksponensial
print(f"e^1 = {math.exp(1):.4f}") # 2.7183
print(f"2^10 = {2**10}") # 1024
print(f"10^3 = {10**3}") # 1000#Persamaan Linear
Persamaan linear ax + b = c adalah model matematika paling dasar untuk hubungan linier — dari pricing model hingga konversi satuan. Menyelesaikan persamaan linear secara manual membantu kalian memahami apa yang dilakukan NumPy saat menyelesaikan sistem persamaan di episode 18.
#Satu Variabel
# ax + b = c → x = (c - b) / a
def selesaikan_persamaan(a: float, b: float, c: float) -> float:
if a == 0:
raise ValueError("Koefisien a tidak boleh nol")
return (c - b) / a
# Contoh: 3x + 7 = 22
x = selesaikan_persamaan(3, 7, 22)
print(f"3x + 7 = 22 → x = {x}") # x = 5.0
# Verifikasi
print(f"Verifikasi: 3({x}) + 7 = {3*x + 7}") # 22.0#Dua Variabel
Persamaan linear dua variabel a₁x + b₁y = c₁ bisa diselesaikan dengan substitution atau elimination:
def selesaikan_2var(a1, b1, c1, a2, b2, c2):
"""Menyelesaikan: a1*x + b1*y = c1 dan a2*x + b2*y = c2"""
det = a1 * b2 - a2 * b1
if det == 0:
raise ValueError("Sistem tidak memiliki solusi unik")
x = (c1 * b2 - c2 * b1) / det
y = (a1 * c2 - a2 * c1) / det
return x, y
# Contoh: 2x + 3y = 8 dan x - y = -1
x, y = selesaikan_2var(2, 3, 8, 1, -1, -1)
print(f"x = {x}, y = {y}") # x = 1.0, y = 2.0
# Verifikasi
print(f"2({x}) + 3({y}) = {2*x + 3*y}") # 8.0
print(f"{x} - {y} = {x - y}") # -1.0Kita akan mempelajari metode umum (Gaussian elimination) untuk sistem persamaan linear berukuran besar di episode 18.
#Pertidaksamaan
Pertidaksamaan adalah persamaan dengan tanda "lebih besar" atau "lebih kecil" — penting untuk batasan, constraint, dan validasi input:
def validasi_bmi(berat: float, tinggi_cm: float) -> str:
"""Hitung BMI dan kategorikan."""
tinggi_m = tinggi_cm / 100
bmi = berat / tinggi_m**2
if bmi < 18.5:
return f"BMI {bmi:.1f}: Kurus"
elif bmi < 25:
return f"BMI {bmi:.1f}: Normal"
elif bmi < 30:
return f"BMI {bmi:.1f}: Gemuk"
else:
return f"BMI {bmi:.1f}: Obesitas"
print(validasi_bmi(70, 175)) # BMI 22.9: Normal
print(validasi_bmi(90, 165)) # BMI 33.1: Obesitas#Aplikasi: Grading Algorithm
Mari kita gabungkan konsep — aritmatik, persentase, dan pertidaksamaan — dalam fungsi grading yang realistis:
def hitung_nilai_akhir(tugas: float, quiz: float, uts: float, uas: float) -> dict:
"""Menghitung nilai akhir dengan bobot: tugas 20%, quiz 10%, UTS 30%, UAS 40%."""
bobot = {"tugas": 0.20, "quiz": 0.10, "uts": 0.30, "uas": 0.40}
nilai = {"tugas": tugas, "quiz": quiz, "uts": uts, "uas": uas}
# Validasi input
for nama, val in nilai.items():
if not (0 <= val <= 100):
raise ValueError(f"Nilai {nama} harus antara 0-100, diperoleh {val}")
akhir = sum(val * bobot[nama] for nama, val in nilai.items())
# Tentukan huruf
if akhir >= 85:
huruf = "A"
elif akher >= 70:
huruf = "B"
elif akher >= 55:
huruf = "C"
elif akher >= 40:
huruf = "D"
else:
huruf = "E"
return {"nilai_akhir": round(akhir, 2), "huruf": huruf}
# Contoh
hasil = hitung_nilai_akhir(tugas=80, quiz=90, uts=75, uas=85)
print(f"Nilai akhir: {hasil['nilai_akhir']}, Huruf: {hasil['huruf']}")Note
Perhatikan bagaimana setiap baris kode di atas menggunakan konsep matematika: persentase (bobot), pertidaksamaan (validasi range), dan penjumlahan berat (weighted sum). Ini adalah pola yang akan kalian lihat berulang di episode-episode selanjutnya.
#Penutup
Inti yang harus dibawa pulang:
- Operator precedence di Python mengikuti PEMDAS — gunakan parentheses jika ragu.
- Pecahan (
Fraction) memberikan presisi penuh; hindari float untuk perhitungan keuangan yang sensitif. - Persentase hanyalah pecahan penyebut 100; diskon berturut-turut tidak sama dengan jumlah persentase.
- Akar kuadrat muncul di jarak Euclidean dan normalisasi; eksponensial muncul di growth models.
- Persamaan linear adalah fondasi untuk menyelesaikan constraint — dari pricing hingga grading algorithms.
- Pertidaksamaan digunakan untuk validasi input dan batasan.
Di episode 4 selanjutnya kita akan mempelajari fungsi, grafik, dan asas-alas visual — bagaimana y = f(x) mewakili input-output, jenis-jenis grafik (linear, kuadrat, eksponensial, logaritma), notasi sigma dan pi, serta hubungan dengan Big-O notation di coding. Fondasi aritmatik dan aljabar yang baru kalian perkuat akan menjadi bahan bakar untuk memahami grafik!