Description

Fungsi FPB Iteratif
Menggunakan loop untuk membagi bilangan hingga ditemukan pembagi terbesar yang memenuhi syarat.

Fungsi FPB Rekursif
Menggunakan algoritma Euclidean untuk menghitung FPB secara rekursif.

Fungsi KPK
Menggunakan hasil FPB untuk menghitung KPK dengan rumus:
KPK(a,b)=a×b / FPB(a,b)

Benchmark Efisiensi
Membandingkan waktu eksekusi kedua metode menggunakan modul time.

-

Kesimpulan

1. Efisiensi Algoritma
   Algoritma rekursif menggunakan algoritma Euclidean lebih efisien (O(log(min(a, b)))) dibandingkan metode iteratif (O(n)).
2. Perbandingan Waktu Eksekusi
   Berdasarkan benchmark, metode rekursif memiliki waktu eksekusi yang lebih cepat dibandingkan iteratif untuk input besar.
3. Relevansi Dunia Nyata
   Program ini cocok untuk berbagai aplikasi praktis, seperti pengelolaan data atau analisis angka dalam sistem teknik.
   
   
   Source Code :

import matplotlib.pyplot as plt

import time

# Algoritma FPB Iteratif

def fpb_iterative(a, b):

    while b != 0:

        a, b = b, a % b

    return a

# Algoritma FPB Rekursif

def fpb_recursive(a, b):

    if b == 0:

        return a

    return fpb_recursive(b, a % b)

# Menghitung KPK berdasarkan FPB

def kpk(a, b, fpb_func):

    return (a * b) // fpb_func(a, b)

# Fungsi benchmarking dengan berbagai ukuran input

def benchmark():

    sizes = [10, 100, 1000, 10000, 50000, 100000]  # Ukuran input

    iter_times = []

    recur_times = []

    for size in sizes:

        a, b = size, size // 2  # Bilangan besar untuk pengujian

        # Benchmark iteratif

        start_time = time.time()

        fpb_iter = fpb_iterative(a, b)

        kpk_iter = kpk(a, b, fpb_iterative)

        iter_times.append(time.time() - start_time)

        # Benchmark rekursif

        start_time = time.time()

        fpb_recur = fpb_recursive(a, b)

        kpk_recur = kpk(a, b, fpb_recursive)

        recur_times.append(time.time() - start_time)

    # Visualisasi hasil

    plt.plot(sizes, iter_times, label="Iterative", marker="o")

    plt.plot(sizes, recur_times, label="Recursive", marker="o")

    plt.xlabel("Input Size")

    plt.ylabel("Execution Time (seconds)")

    plt.title("Performance Benchmark: Iterative vs Recursive")

    plt.legend()

    plt.grid(True)

    plt.show()

if __name__ == "__main__":

    print("=== Kalkulator KPK dan FPB ===")

    x = int(input("Masukkan bilangan pertama: "))

    y = int(input("Masukkan bilangan kedua: "))

    print("\n=== Perhitungan ===")

    print("FPB Iteratif:", fpb_iterative(x, y))

    print("FPB Rekursif:", fpb_recursive(x, y))

    print("KPK Iteratif:", kpk(x, y, fpb_iterative))

    print("KPK Rekursif:", kpk(x, y, fpb_recursive))

    print("\n=== Benchmark ===")

    benchmark()