bilangan kembar

Latihan membuat instruksi untuk tugas pemrograman, diadaptasi dari instruksi bilangan kembar pada gambar.

Implementasi instruksinya menggunakan bahasa pemrograman Rust.

instruksi bilangan kembar

(sumber)

Ringkasan Tujuan

Pada latihan ini, kita akan membuat program untuk menghitung jumlah bilangan kembar dalam suatu rentang bilangan bulat. Bilangan kembar adalah bilangan yang seluruh digitnya sama, misalnya: 11, 222, 4444, dan 7.

Tujuan Pembelajaran

Setelah menyelesaikan latihan ini, Anda diharapkan mampu:

1. Menjelaskan apa yang dimaksud dengan bilangan kembar.

2. Membuat program sederhana untuk menghitung jumlah bilangan kembar dalam rentang tertentu.

3. Memahami dua pendekatan penyelesaian: menggunakan teks (string) dan menggunakan operasi angka (aritmetika).

4. Membandingkan kelebihan dan kekurangan kedua pendekatan tersebut.

Prasyarat

Sebelum memulai, pastikan Anda sudah memahami:

• Cara membaca input dan menuliskannya ke variabel.

• Struktur perulangan for dalam Rust.

• Konsep konversi angka ke teks (string) dan operasi dasar bilangan (%, /).

Langkah-langkah Tugas

1. Program akan membaca dua bilangan bulat, a dan b.

2. Program menghitung berapa banyak bilangan kembar di antara a hingga b (inklusif).

3. Gunakan dua pendekatan berbeda:

   • Pendekatan Teks: ubah bilangan ke string, lalu cek apakah semua karakter sama.

   • Pendekatan Angka: cek setiap digit dengan operasi modulus (%) dan pembagian (/).

4. Tampilkan hasil berupa jumlah bilangan kembar yang ditemukan.

Perbandingan Pendekatan

Pendekatan Teks

• Lebih intuitif untuk pemula karena bekerja dengan string (teks).

• Kodenya lebih mudah dibaca: angka → string → periksa huruf.

• Ada sedikit biaya tambahan karena harus melakukan konversi angka ke string.

Pendekatan Angka

• Lebih efisien karena langsung bekerja dengan angka tanpa konversi.

• Cocok untuk performa tinggi.

• Lebih sulit bagi pemula karena melibatkan logika matematika (%, /) untuk memeriksa digit satu per satu.

Kode masukan sebagai Teks

use std::io;

fn main() {
    // Membaca input (dua bilangan a dan b) dalam satu baris
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Gagal membaca input");

    // Pisahkan berdasarkan spasi, lalu ambil dua angka pertama
    let mut parts = input.split_whitespace();

    let a: i32 = parts.next().unwrap().parse().unwrap();
    let b: i32 = parts.next().unwrap().parse().unwrap();

    let mut count = 0;

    // Mengecek setiap bilangan dari a sampai b
    for num in a..=b {
        let s = num.to_string(); // Ubah angka ke string
        let mut chars = s.chars(); // Ambil iterator karakter

        let first_char = chars.next().unwrap(); // Simpan karakter pertama
        let mut is_twin = true; // Anggap dulu kembar

        // Periksa semua karakter berikutnya
        for c in chars {
            if c != first_char {
                is_twin = false; // Kalau ada yang beda, bukan kembar
                break; // Tidak perlu cek lebih lanjut
            }
        }

        if is_twin {
            count += 1;
        }
    }

    // Cetak hasil jumlah bilangan kembar
    println!("{}", count);
}

Berikut versi dipersingkat untuk yang sudah memiliki pemahaman lebih lanjut.

use std::io;

fn main() {
    // Membaca input (dua bilangan a dan b)
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Gagal membaca input");

    // Memisahkan input menjadi dua bilangan bulat
    let parts: Vec<i32> = input
        .split_whitespace()
        .map(|x| x.parse::<i32>().unwrap())
        .collect();

    let a = parts[0];
    let b = parts[1];

    let mut count = 0;

    // Mengecek setiap bilangan dari a hingga b
    for num in a..=b {
        let s = num.to_string(); // Ubah ke string
        let first_char = s.chars().next().unwrap(); // Ambil karakter pertama

        // all() = fungsi Rust untuk memeriksa apakah semua elemen memenuhi syarat
        if s.chars().all(|c| c == first_char) {
            count += 1;
        }
    }

    // Cetak hasil jumlah bilangan kembar
    println!("{}", count);
}

Kode masukan sebagai Angka

use std::io;

fn main() {
    // Membaca input (dua bilangan a dan b)
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Gagal membaca input");

    // Memisahkan input menjadi dua bilangan bulat
    let parts: Vec<i32> = input
        .split_whitespace()
        .map(|x| x.parse::<i32>().unwrap())
        .collect();

    let a = parts[0];
    let b = parts[1];

    let mut count = 0;

    // Mengecek setiap bilangan dari a hingga b
    for mut num in a..=b {
        let last_digit = num % 10; // Ambil digit terakhir
        let mut is_twin = true;    // Anggap dulu kembar

        while num > 0 {
            if num % 10 != last_digit {
                is_twin = false; // Jika ada digit berbeda, bukan kembar
                break;
            }
            num /= 10; // Buang digit terakhir
        }

        if is_twin {
            count += 1;
        }
    }

    // Cetak hasil jumlah bilangan kembar
    println!("{}", count);
}

Penjelasan Singkat Kode

• to_string() → mengubah angka menjadi string.

• chars() → memecah string menjadi karakter-karakter.

• all(|c| c == first_char) → fungsi Rust untuk memeriksa apakah semua karakter sama.

• num % 10 → mengambil digit terakhir dari sebuah angka.

• num / 10 → membuang digit terakhir dari sebuah angka.

Pertanyaan Refleksi

1. Apa keuntungan menggunakan pendekatan teks dibandingkan pendekatan angka?

2. Jika rentang bilangan sangat besar (misalnya hingga 1 miliar), pendekatan mana yang lebih efisien? Mengapa?

3. Bagaimana cara memodifikasi program agar tidak hanya menghitung, tetapi juga mencetak bilangan kembar yang ditemukan?

4. Menurut Anda, misalnya sebagai pemula, pendekatan mana yang lebih mudah dipahami?