#include <stdio.h>

/* ① Definisi fungsi di ATAS main() */
/* Compiler sudah tahu fungsi ini saat membaca main() */

int kuadrat(int x) {
    return x * x;
}

float rataRata(int a, int b, int c) {
    return (float)(a + b + c) / 3;
}

void cetakHasil(int n, int hasil) {
    printf("Kuadrat %d = %d\n", n, hasil);
}

/* ② main() dipanggil TERAKHIR — semua fungsi sudah dikenal */
int main() {
    int n = 7;
    int k = kuadrat(n);         // ✓ compiler sudah kenal kuadrat()
    cetakHasil(n, k);            // ✓ compiler sudah kenal cetakHasil()

    float avg = rataRata(80, 90, 70);
    printf("Rata-rata = %.1f\n", avg);
    return 0;
}
/* Output:
   Kuadrat 7 = 49
   Rata-rata = 80.0   */

#include <stdio.h>
#include <math.h>

/* ============================================
   PROTOTIPE — semua fungsi dideklarasikan di atas
   Sintaks: tipe_return nama_fungsi(tipe param, ...);
   ============================================ */
int    kuadrat(int x);
float  luasLingkaran(float r);
void   cetakHeader(char *judul);
int    faktorial(int n);

/* ============================================
   main() — bisa langsung gunakan semua fungsi
   ============================================ */
int main() {
    cetakHeader("KALKULATOR SEDERHANA");

    printf("Kuadrat 8    = %d\n",   kuadrat(8));
    printf("Luas r=7     = %.2f\n", luasLingkaran(7));
    printf("Faktorial 5  = %d\n",   faktorial(5));
    return 0;
}

/* ============================================
   DEFINISI LENGKAP — bisa ditulis di mana saja
   (bahkan di file .c terpisah)
   ============================================ */
int kuadrat(int x) {
    return x * x;
}

float luasLingkaran(float r) {
    return 3.14159 * r * r;
}

void cetakHeader(char *judul) {
    printf("===== %s =====\n", judul);
}

int faktorial(int n) {
    if (n <= 1) return 1;
    return n * faktorial(n - 1);
}
/* Output:
   ===== KALKULATOR SEDERHANA =====
   Kuadrat 8    = 64
   Luas r=7     = 153.94
   Faktorial 5  = 120                */

#include <stdio.h>

/* Fibonacci: fib(n) = fib(n-1) + fib(n-2) */
/* Base case: fib(0)=0, fib(1)=1           */
int fibonacci(int n) {
    if (n == 0) return 0;   // base case 1
    if (n == 1) return 1;   // base case 2
    return fibonacci(n-1) + fibonacci(n-2); // recursive
}

/* Pangkat: pangkat(base, exp) = base * pangkat(base, exp-1) */
int pangkat(int base, int exp) {
    if (exp == 0) return 1;             // base case: x^0 = 1
    return base * pangkat(base, exp-1); // recursive
}

int main() {
    printf("Fibonacci ke-8 = %d\n", fibonacci(8)); // 21

    printf("Deret Fibonacci: ");
    for(int i=0; i<10; i++)
        printf("%d ", fibonacci(i)); // 0 1 1 2 3 5 8 13 21 34
    printf("\n");

    printf("2^10 = %d\n", pangkat(2, 10)); // 1024
    return 0;
}

#include <stdio.h>

int hitungan = 0;  /* ← GLOBAL: diakses semua fungsi */

void demoLokal() {
    int x = 10;   /* ← LOKAL: hanya ada di dalam demoLokal() */
    x++;
    printf("Lokal x = %d\n", x);
    /* x dihapus dari memori saat fungsi ini selesai */
}

void demoStatis() {
    static int count = 0;  /* ← STATIS: inisialisasi hanya sekali! */
    count++;
    printf("Static count = %d\n", count);
    /* count TIDAK dihapus saat fungsi selesai */
}

void tambahHitungan() {
    hitungan++;   /* akses variabel global */
}

int main() {
    demoLokal();   // x = 11
    demoLokal();   // x = 11 lagi! x selalu dimulai dari 10

    printf("---\n");
    demoStatis(); // count = 1
    demoStatis(); // count = 2  ← nilai dipertahankan!
    demoStatis(); // count = 3

    printf("---\n");
    tambahHitungan();
    tambahHitungan();
    printf("Global hitungan = %d\n", hitungan); // 2
    return 0;
}
/* Output:
   Lokal x = 11
   Lokal x = 11
   ---
   Static count = 1
   Static count = 2
   Static count = 3
   ---
   Global hitungan = 2   */

#include <stdio.h>

int nilai = 100;   /* variabel GLOBAL */

void contohShadow() {
    int nilai = 50;   /* variabel LOKAL — menutupi yang global! */
    printf("Di dalam fungsi: nilai = %d\n", nilai);
    // Ini mencetak 50 (lokal), bukan 100 (global)
}

int main() {
    printf("Di main (sebelum): nilai = %d\n", nilai); // 100
    contohShadow();
    printf("Di main (sesudah): nilai = %d\n", nilai); // 100 — global tidak berubah!
    return 0;
}

#include <stdio.h>

void cobaUbah(int x) {   // x adalah SALINAN dari a
    x = x * 10;
    printf("Di dalam fungsi: x = %d\n", x); // 50
    // perubahan pada x tidak memengaruhi variabel luar
}

int main() {
    int a = 5;
    printf("Sebelum: a = %d\n", a);   // 5
    cobaUbah(a);                         // kirim nilai 5, bukan variabel a
    printf("Sesudah: a = %d\n", a);   // 5 — tidak berubah!
    return 0;
}

#include <stdio.h>

/* Parameter bertipe pointer: int *px */
/* Artinya: px menyimpan ALAMAT variabel int */
void ubahNilai(int *px) {
    *px = *px * 10;   // *px: akses nilai di alamat yang ditunjuk px
    printf("Di dalam: *px = %d\n", *px); // 50
}

/* Fungsi swap klasik — hanya bisa dengan by reference */
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a = 5;
    printf("Sebelum: a = %d\n", a);   // 5
    ubahNilai(&a);                       // kirim ALAMAT a, bukan nilainya
    printf("Sesudah: a = %d\n", a);   // 50 — berubah!

    printf("---\n");
    int x = 10, y = 20;
    printf("Sebelum swap: x=%d y=%d\n", x, y); // 10 20
    swap(&x, &y);
    printf("Sesudah swap: x=%d y=%d\n", x, y); // 20 10
    return 0;
}

#include <stdio.h>

/* Parameter array: int arr[] atau int *arr — sama saja */
/* Ukuran N dikirim terpisah karena fungsi tidak tahu ukuran array */
void isiArray(int arr[], int n) {
    for(int i=0; i<n; i++)
        arr[i] = i * 10;   // mengubah array ASLI
}

int jumlahArray(int arr[], int n) {
    int total = 0;
    for(int i=0; i<n; i++)
        total += arr[i];
    return total;
}

void cetakArray(int arr[], int n) {
    for(int i=0; i<n; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int data[5];          // array belum terisi
    isiArray(data, 5);   // isi array melalui fungsi
    cetakArray(data, 5); // 0 10 20 30 40

    printf("Jumlah = %d\n", jumlahArray(data, 5)); // 100
    return 0;
}

#include <stdio.h>
#include <math.h>

/* ===== PROTOTIPE (Forward Declaration) ===== */
int    faktorial(int n);
float  rataRata(int arr[], int n);
void   statistik(int arr[], int n, int *maks, int *min);
void   cetakMenu();

/* ===== PROGRAM UTAMA ===== */
int main() {
    /* Uji faktorial rekursif */
    printf("5! = %d\n", faktorial(5));

    /* Uji array + by reference */
    int data[] = {45, 82, 17, 93, 60};
    int n = 5, maks, min;

    printf("Rata-rata: %.1f\n", rataRata(data, n));

    statistik(data, n, &maks, &min); // by reference
    printf("Maks=%d  Min=%d\n", maks, min);
    return 0;
}

/* ===== DEFINISI FUNGSI ===== */
int faktorial(int n) {         // REKURSIF
    if (n <= 1) return 1;
    return n * faktorial(n-1);
}

float rataRata(int arr[], int n) {  // array by ref implisit
    int total = 0;
    for(int i=0; i<n; i++) total += arr[i];
    return (float)total / n;
}

void statistik(int arr[], int n,
               int *maks, int *min) { // by reference
    *maks = *min = arr[0];
    for(int i=1; i<n; i++) {
        if(arr[i] > *maks) *maks = arr[i];
        if(arr[i] < *min)  *min  = arr[i];
    }
}
/* Output:
   5! = 120
   Rata-rata: 59.4
   Maks=93  Min=17   */