jumlah angka

Latihan membuat instruksi untuk tugas pemrograman, diadaptasi dari instruksi jumlah angka pada gambar.

Implementasi instruksinya menggunakan bahasa pemrograman Rust.

(sumber)

Ringkasan Tujuan

Siswa diminta membuat program dalam bahasa Rust yang menghitung jumlah dari digit-digit suatu bilangan bulat. Input berupa satu angka utuh, output berupa jumlah semua digit angka tersebut.

Contoh:

• Input: 1234

• Output: 10

• Penjelasan: 1 + 2 + 3 + 4 = 10

Tujuan Pembelajaran

Setelah menyelesaikan tugas ini, kamu akan dapat:

1. Membaca input dari stdin dalam Rust.

2. Memutuskan apakah input diperlakukan sebagai angka atau teks.

3. Menggunakan loop untuk mengakses tiap digit dari angka.

4. Menambahkan semua digit untuk mendapatkan hasil.

5. Menjelaskan dengan singkat perbedaan pendekatan input sebagai teks vs angka.

Prasyarat

• Mengerti operasi aritmatika dasar (% dan /).

• Mengerti tipe data dasar di Rust (i32, String).

• Tahu cara iterasi pada string (chars()).

• Bisa menambahkan komentar singkat pada kode.

Langkah-langkah Tugas

1. Baca input: Ambil angka dari stdin.

2. Pilih pendekatan:

   • Sebagai angka: gunakan % 10 untuk ambil digit terakhir, lalu / 10 untuk mengurangi.

   • Sebagai teks: ubah ke String, lalu iterasi setiap char, parse kembali menjadi angka.

3. Lakukan penjumlahan: tambahkan semua digit.

4. Cetak hasil akhir.

5. Tambahkan komentar singkat pada kode untuk menjelaskan alurnya.

Perbandingan Pendekatan

Input sebagai Angka

• Kelebihan:

  • Langsung bekerja dengan operasi matematika.

  • Tidak perlu parsing string tambahan.

• Kekurangan:

  • Perlu hati-hati dengan bilangan negatif.

  • Angka terlalu besar bisa melewati batas tipe integer.

Input sebagai Teks

• Kelebihan:

  • Lebih fleksibel (bisa menangani input besar sekali).

  • Mudah untuk tampilkan proses (1 + 2 + 3).

• Kekurangan:

  • Perlu parsing tiap karakter menjadi digit.

  • Butuh sedikit lebih banyak kode.

Contoh Input / Output

Input:

1234

Output:

10

Penjelasan:

1 + 2 + 3 + 4 = 10

Contoh Program (Rust) — versi Input sebagai Teks

// jumlah_angka.rs
// Program untuk menghitung jumlah digit dari sebuah bilangan bulat.
// Input dibaca sebagai teks agar mudah dipecah menjadi karakter per digit.

use std::io;

fn main() {
    // Buat string kosong untuk menampung input
    let mut input = String::new();

    // Baca input dari stdin
    io::stdin()
        .read_line(&mut input)
        .expect("Gagal membaca input");

    // Hapus spasi/enter di akhir input
    let input = input.trim();

    // Siapkan variabel untuk menampung hasil jumlah digit
    let mut total: i32 = 0;

    // Iterasi setiap karakter dalam input
    for ch in input.chars() {
        // Pastikan karakter adalah digit
        if let Some(digit) = ch.to_digit(10) {
            // Konversi digit ke i32 dan tambahkan ke total
            total += digit as i32;
        } else {
            // Jika ada karakter bukan digit, beri pesan error
            eprintln!("Input hanya boleh berupa angka");
            return;
        }
    }

    // Cetak hasil akhir
    println!("{}", total);
}

Penjelasan Singkat Kode

• read_line → baca input dari keyboard.

• trim() → hapus whitespace di awal/akhir.

• chars() → akses setiap karakter.

• to_digit(10) → ubah char menjadi angka berbasis 10.

• total += digit → akumulasi jumlah digit.

• Jika ada karakter bukan angka, program akan berhenti dengan pesan error.

Pertanyaan Refleksi

1. Apa perbedaan hasil jika input 1005? (Pastikan hasil 6).

2. Bagaimana cara memodifikasi program untuk juga mencetak proses, misalnya 1 + 0 + 0 + 5 = 6?

3. Menurutmu, pendekatan mana yang lebih aman untuk angka yang sangat besar (misalnya 30 digit)? Mengapa?

Versi Pembanding: Input sebagai Angka

Alur Logika

1. Baca sebuah bilangan bulat dari input.

2. Siapkan variabel total untuk menyimpan jumlah digit.

3. Selama angka masih lebih besar dari 0:

   • Ambil digit terakhir dengan operasi % 10.

   • Tambahkan digit ke total.

   • Hilangkan digit terakhir dengan operasi / 10.

4. Cetak total.

Contoh Program (Rust) — versi Input sebagai Angka

// jumlah_angka_num.rs
// Program alternatif untuk menghitung jumlah digit dengan cara matematis.
// Input diperlakukan sebagai bilangan bulat, bukan string.

use std::io;

fn main() {
    // Variabel untuk menampung input mentah
    let mut input = String::new();

    // Baca input dari stdin
    io::stdin()
        .read_line(&mut input)
        .expect("Gagal membaca input");

    // Hapus spasi/enter dan parse menjadi bilangan bulat
    let mut number: i64 = match input.trim().parse() {
        Ok(num) => num,
        Err(_) => {
            eprintln!("Input harus berupa bilangan bulat positif");
            return;
        }
    };

    // Pastikan angka positif
    if number < 0 {
        eprintln!("Input harus bilangan positif");
        return;
    }

    // Variabel penampung hasil
    let mut total: i64 = 0;

    // Loop: ambil digit terakhir lalu buang
    while number > 0 {
        let digit = number % 10; // ambil digit terakhir
        total += digit;          // tambahkan ke total
        number /= 10;            // buang digit terakhir
    }

    // Cetak hasil
    println!("{}", total);
}

Penjelasan Singkat Kode

• parse::<i64>() → langsung konversi string ke bilangan bulat.

• while number > 0 → jalankan loop sampai semua digit habis.

• % 10 → ambil digit terakhir.

• / 10 → kurangi angka dengan menghapus digit terakhir.

• total → akumulasi jumlah digit.

Contoh Eksekusi

Input:

1234

Output:

10

Langkah di balik layar:

• 1234 % 10 = 4 → total = 4 → number = 123

• 123 % 10 = 3 → total = 7 → number = 12

• 12 % 10 = 2 → total = 9 → number = 1

• 1 % 10 = 1 → total = 10 → number = 0

Perbandingan Dua Pendekatan

Pendekatan Kelebihan Kekurangan

Sebagai teks (string)

• Bisa menangani angka sangat besar (puluhan digit).

• Mudah diproses per karakter.

• Harus parsing tiap char ke digit.

• Perlu cek validitas digit.

Sebagai angka (math)

• Kode lebih dekat ke logika matematis.

• Tidak perlu parsing karakter.

• Bisa error jika angka terlalu besar (overflow).

• Harus tangani bilangan negatif.

Pertanyaan Refleksi

1. Jika input 98765, bagaimana perbedaan proses antara pendekatan teks dan angka?

2. Menurutmu, kapan lebih tepat menggunakan pendekatan teks? Kapan lebih baik pakai pendekatan angka?

3. Bagaimana jika input berupa angka 30 digit (misalnya nomor kartu kredit)? Pendekatan mana yang lebih aman?