Membuat Aplikasi Pengubah Angka ke Kata dengan Go

30 October 2022

Kali ini kita akan membuat aplikasi yang mengubah angka menjadi kata Bahasa Indonesia. Misalkan angka 1235 akan diubah menjadi Seribu Dua Ratus Tiga Puluh Lima.

Membuat Proyek Baru

Buat direktori baru untuk proyek ini sesuka kalian. Kemudian jalankan perintah berikut di dalam direktori tersebut:

go mod init daunkoder/angka-ke-kata

Kemudian buat berkas baru bernama main.go. Di berkas inilah kita akan menuliskan kode.

Meminta Masukan dari Pengguna

Langkah pertama adalah meminta masukan dari pengguna. Kemudian masukkan tersebut kita ubah menjadi angka menggunakan strconv.Atoi. Jika penggubahan tidak berhasil maka program keluar. Sedangkan jika penggubahan berhasil maka aplikasi tetap berjalan.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    fmt.Println("Masukkan angka yang akan diubah")

    var teks string
    fmt.Scanln(&teks)

    angka, err := strconv.Atoi(teks)
    if err != nil {
        fmt.Println("Maaf, yang anda masukkan bukan angka")
        return
    }
    fmt.Println(angka)
}

Untuk menjalankan aplikasi, jalankan perintah berikut pada direktori tadi:

go run .

Kita coba masukkan angka, hasilnya seperti ini:

Masukkan angka yang akan diubah
12
12

Kita coba masukkan bukan angka, hasilnya seperti ini:

Masukkan angka yang akan diubah
aku
Maaf, yang anda masukkan bukan angka

Angka 0-11

Untuk mengubah angka 0-11 ke kata kita hanya perlu menggunakan array saja.

Pertama kita perlu membuat fungsi baru dengan nama angkaKeKata. Kata dari angka 0-11 kita masukkan ke array dan kata akan diambil dari array tersebut berdasarkan angka. Kode untuk fungsi tersebut seperti ini:

func angkaKeKata(angka int) string {
    if angka <= 11 {
        kata := []string{
            "Nol",
            "Satu",
            "Dua",
            "Tiga",
            "Empat",
            "Lima",
            "Enam",
            "Tujuh",
            "Delapan",
            "Sembilan",
            "Sepuluh",
            "Sebelas"}
        return kata[angka]
    }
    return "Tidak diketahui"
}

Ubah kode di bawah pada fungsi main.

fmt.Println(angka)

menjadi seperti berikut:

fmt.Println(angkaKeKata(angka))

Jalankan aplikasi dan masukkan angka 7. Keluarannya seperti ini:

Masukkan angka yang akan diubah
7
Tujuh

Angka Belasan (12-19)

Angka belasan bisa dipecah menjadi 2 bagian yaitu puluhan dan satuan. Misalkan 19, 1 adalah puluhan dan 9 adalah satuan.

Puluhannya jelas 1 sehingga bisa kita abaikan. Satuan bisa kita cari dengan mengurangi angka dengan 10. (19 - 10 = 9).

Pertama kita menganalisis format kata dari angka belasan.

Angka	Satuan	Kata
12	2	Dua Belas
13	3	Tiga Belas
14	4	Empat Belas

Formatnya adalah angka dari kata + “Belas”.

Untuk mengubah angka belasan ke kata maka tambahkan cabang else if baru seperti berikut pada akhir fungsi angkaKeKata.

} else if angka <= 19 {
    satuan := angka - 10
    return angkaKeKata(satuan) + " Belas"
}
return "Tidak diketahui"

Kita coba jalankan aplikasi dan memasukkan angka 16. Keluarannya seperti ini:

Masukkan angka yang akan diubah
16
Enam Belas

Angka Puluhan (20-99)

Angka puluhan bisa dipecah menjadi 2 bagian yaitu puluhan dan satuan. Misalkan angka 49, 4 adalah puluhan dan 9 adalah satuan.

Puluhan bisa dicari dari hasil bagi angka dengan 10. Sedangkan satuan bisa dicari dari sisa bagi angka dengan 10. (49 / 10 = 4 sisa 9)

Ingat pada Go, hasil pembagian antara integer akan dibulatkan ke bawah. 3/2 = 1 (1.5 dibulatkan ke bawah). 7/4 = 1 (1.75 dibulatkan ke bawah)

Kita analisa dahulu format kata dari angka puluhan.

Angka	Puluhan	Satuan	Kata
20	2	0	Dua Puluh
30	3	0	Tiga Puluh
40	4	0	Empat Puluh
49	4	9	Empat Puluh Sembilan

Formatnya adalah kata dari puluhan + “Puluh”. Jika satuan lebih dari 0, maka formatnya ditambah dengan kata dari satuan.

Untuk mengubah angka puluhan ke kata maka tambahkan cabang else if baru seperti berikut pada akhir fungsi angkaKeKata:

} else if angka <= 99 {
    puluhan := angka / 10
    satuan := angka % 10
    hasil := angkaKeKata(puluhan) + " Puluh"
    if satuan > 0 {
        hasil += " " + angkaKeKata(satuan)
    }
    return hasil
}
return "Tidak diketahui"

Kita jalankan aplikasi dan memasukkan angka 78. Keluarannya seperti ini:

Masukkan angka yang akan diubah
78
Tujuh Puluh Delapan

Angka Ratusan (100-999)

Kita bisa memecah angka ratusan menjadi 2 bagian yaitu ratusan dan sisa. Misalkan 231, 2 adalah ratusan dan 31 adalah sisa.

Ratusan bisa kita cari dengan membagi angka dengan 100. Sisa bisa diperoleh dengan mencari sisa bagi angka dengan 100. (231 / 100 = 2 sisa 31).

Kita coba analisa format kata dari angka-angka ratusan.

Angka	Ratusan	Sisa	Kata
100	1	0	Seratus
200	2	0	Dua Ratus
300	3	0	Tiga Ratus
231	2	31	Dua Ratus Tiga Puluh Satu
131	1	31	Seratus Tiga Puluh Satu

Saat ratusannya adalah 1 maka formatnya “Seratus”. Sedangkan jika ratusannya lebih dari 1, maka formatnya adalah angka kata + “Ratus”. Saat sisanya lebih dari 0, maka formatnya ditambah dengan kata dari sisa.

Untuk mengubah angka ratusan ke kata, tambahkan cabang else if baru seperti berikut ke akhir fungsi angkaKeKata

} else if angka <= 999 {
    ratusan := angka / 100
    sisa := angka % 100
    var hasil string
    if ratusan == 1 {
        hasil = "Seratus"
    } else {
        hasil = angkaKeKata(ratusan) + " Ratus"
    }
    if sisa > 0 {
        hasil += " " + angkaKeKata(sisa)
    }
    return hasil
}
return "Tidak diketahui"

Jalankan aplikasi dan masukkan 399. Hasilnya adalah:

Masukkan angka yang akan diubah
399
Tiga Ratus Sembilan Puluh Sembilan

Angka Ribuan (1000-999.999)

Kita bisa memecah angka ribuan menjadi 2 bagian yaitu ribuan dan sisa. Misalkan angka 2341, 2 adalah ribuan dan 341 adalah sisa.

Ribuan bisa dicari dengan membagi angka dengan 1000. Sedangkan sisa bisa diperoleh dengan mencari sisa bagi (modulus) angka dengan 1000. (2341 / 1000 = 2 sisa 341)

Kita coba analisa format kata dari angka-angka ribuan.

Angka	Ribuan	Sisa	Kata
1000	1	0	Seribu
2000	2	0	Dua Ribu
3000	3	0	Tiga Ribu
2341	2	341	Dua Ribu Tiga Ratus Empat Puluh Satu
1231	1	231	Seribu Dua Ratus Tiga Puluh Satu

Saat ribuannya 1, maka formatnya adalah “Seribu”. Sedangkan ketika ribuannya lebih dari 1, maka formatnya adalah angka dari ribuan + “Ribu”. Jika sisa lebih dari 0, maka formatnya ditambah dengan kata dari sisa.

Untuk mengubah angka ribuan ke kata maka tambahkan cabang else if seperti di bawah ke akhir fungsi angkaKeKata.

} else if angka <= 999_999 {
    ribuan := angka / 1000
    sisa := angka % 1000
    var hasil string
    if ribuan == 1 {
        hasil = "Seribu"
    } else {
        hasil = angkaKeKata(ribuan) + " Ribu"
    }
    if sisa > 0 {
        hasil += " " + angkaKeKata(sisa)
    }
    return hasil
}
return "Tidak diketahui"

Jalankan aplikasi dan masukkan 4568. Keluarannya:

Masukkan angka yang akan diubah
4568
Empat Ribu Lima Ratus Enam Puluh Delapan

Merefractor Kode

Sekarang kode untuk fungsi angkaKeKata yang kita buat menjadi seperti ini:

func angkaKeKata(angka int) string {
	if angka <= 11 {
		kata := []string{
			"Nol",
			"Satu",
			"Dua",
			"Tiga",
			"Empat",
			"Lima",
			"Enam",
			"Tujuh",
			"Delapan",
			"Sembilan",
			"Sepuluh",
			"Sebelas"}
		return kata[angka]
	} else if angka <= 19 {
		satuan := angka - 10
		return angkaKeKata(satuan) + " Belas"
	} else if angka <= 99 {
		puluhan := angka / 10
		satuan := angka % 10
		hasil := angkaKeKata(puluhan) + " Puluh"
		if satuan > 0 {
			hasil += " " + angkaKeKata(satuan)
		}
		return hasil
	} else if angka <= 999 {
		ratusan := angka / 100
		sisa := angka % 100
		var hasil string
		if ratusan == 1 {
			hasil = "Seratus"
		} else {
			hasil = angkaKeKata(ratusan) + " Ratus"
		}
		if sisa > 0 {
			hasil += " " + angkaKeKata(sisa)
		}
		return hasil
	} else if angka <= 999_999 {
		ribuan := angka / 1000
		sisa := angka % 1000
		var hasil string
		if ribuan == 1 {
			hasil = "Seribu"
		} else {
			hasil = angkaKeKata(ribuan) + " Ribu"
		}
		if sisa > 0 {
			hasil += " " + angkaKeKata(sisa)
		}
		return hasil
	}
	return "Tidak diketahui"
}

Jika kita perhatikan dengan seksama maka kode untuk ratusan dan ribuan akan terlihat mirip. Yang berbeda hanyalah nama variabel ratusan dan ribuan, Seratus dengan Seribu, Ratus dengan Ribu, dan angka 100 dengan angka 1000. Kita bisa pindahkan kode untuk ratusan dan ribuan ke fungsi baru dan menggunakannya kembali di fungsi angkaKeKata.

Kita beri nama fungsi tersebut angkaKelipatanKeKata. Variabel ratusan dan ribuan kita ubah menjadi kelipatan. Angka 100 dan 1000 kita gantikan dengan argumen dari fungsi dengan nama faktor. Seratus dan Seribu kita gantikan dengan argumen bernama kataKelipatan1. Ratus dan Ribu kita gantikan dengan argumen suffiks.

Kode fungsi tersebut seperti ini:

func angkaKelipatanKeKata(
	angka int,
	faktor int,
	kataKelipatan1 string,
	suffiks string) string {
    kelipatan := angka / faktor
    sisa := angka % faktor
    var hasil string
    if kelipatan == 1 {
        hasil = kataKelipatan1
    } else {
        hasil = angkaKeKata(kelipatan) + " " + suffiks
    }
    if sisa > 0 {
        hasil += " " + angkaKeKata(sisa)
    }
    return hasil
}

Ternyata kita bisa menggunakan fungsi tersebut untuk puluhan, ratusan dan ribuan. Fungsi angkaKeKata menjadi seperti ini:

func angkaKeKata(angka int) string {
	if angka <= 11 {
		kata := []string{
			"Nol",
			"Satu",
			"Dua",
			"Tiga",
			"Empat",
			"Lima",
			"Enam",
			"Tujuh",
			"Delapan",
			"Sembilan",
			"Sepuluh",
			"Sebelas"}
		return kata[angka]
	} else if angka <= 19 {
		satuan := angka - 10
		return angkaKeKata(satuan) + " Belas"
	} else if angka <= 99 {
		return angkaKelipatanKeKata(angka, 10, "Sepuluh", "Puluh")
	} else if angka <= 999 {
		return angkaKelipatanKeKata(angka, 100, "Seratus", "Ratus")
	} else if angka <= 999_999 {
		return angkaKelipatanKeKata(angka, 1000, "Seribu", "Ribu")
	}
	return "Tidak diketahui"
}

Kode sekarang terlihat rapi.

Angka Jutaan (1.000.000 - 999.999.999)

Untuk mengubah angka jutaan ke kata, kita menggunakan fungsi yang baru saja kita buat dengan faktor 1.000.000 dan suffiks Juta. Tambahkan cabang else-if berikut ke akhir fungsi angkaKeKata.

Penting! 1.000.000 dibaca Satu Juta

} else if angka <= 999_999_999 {
    return angkaKelipatanKeKata(angka, 1_000_000, "Satu Juta", "Juta")
}
return "Tidak diketahui"

Angka Milyaran (1.000.000.000 - 999.999.999.999)

Untuk mengubah angka milyaran ke kata, kita menggunakan fungsi yang baru saja kita buat dengan faktor 1.000.000.000 dan suffiks Milyar.Tambahkan cabang else-if berikut ke akhir fungsi angkaKeKata

Penting! 1.000.000.000 dibaca Satu Milyar

} else if angka <= 999_999_999_999 {
	return angkaKelipatanKeKata(angka, 1_000_000_000, "Satu Milyar", "Milyar")
}
return "Tidak diketahui"

Angka Triliunan (1.000.000.000.000 - 999.999.999.999.999)

Untuk mengubah angka triliunan ke kata, kita menggunakan fungsi yang baru saja kita buat dengan faktor 1.000.000.000.000 dan suffiks Triliun.Tambahkan cabang else-if berikut ke akhir fungsi angkaKeKata.

Penting! 1.000.000.000.000 dibaca Satu Triliun

} else if angka <= 999_999_999_999_999 {
	return angkaKelipatanKeKata(angka, 1_000_000_000_000, "Satu Triliun", "Triliun")
}
return "Tidak diketahui"

Merefractor Kode

Sekarang kode untuk fungsi angkaKeKata menjadi seperti ini:

func angkaKeKata(angka int) string {
    if angka <= 11 {
        kata := []string{
            "Nol",
            "Satu",
            "Dua",
            "Tiga",
            "Empat",
            "Lima",
            "Enam",
            "Tujuh",
            "Delapan",
            "Sembilan",
            "Sepuluh",
            "Sebelas"}
        return kata[angka]
    } else if angka <= 19 {
        satuan := angka - 10
        return angkaKeKata(satuan) + " Belas"
    } else if angka <= 99 {
        return angkaKelipatanKeKata(angka, 10, "Sepuluh", "Puluh")
    } else if angka <= 999 {
        return angkaKelipatanKeKata(angka, 100, "Seratus", "Ratus")
    } else if angka <= 999_999 {
        return angkaKelipatanKeKata(angka, 1000, "Seribu", "Ribu")
	} else if angka <= 999_999_999 {
		return angkaKelipatanKeKata(angka, 1_000_000, "Satu Juta", "Juta")
	} else if angka <= 999_999_999_999 {
		return angkaKelipatanKeKata(angka, 1_000_000_000, "Satu Milyar", "Milyar")
	} else if angka <= 999_999_999_999_999 {
		return angkaKelipatanKeKata(angka, 1_000_000_000_000, "Satu Triliun", "Triliun")
	}
    return "Tidak diketahui"
}

Kita bisa mengubah if-else menjadi switch-case agar lebih ringkas. Kode untuk fungsi ini menjadi seperti ini:

func angkaKeKata(angka int) string {
	switch {
	case angka <= 11:
		kata := []string{
			"Nol",
			"Satu",
			"Dua",
			"Tiga",
			"Empat",
			"Lima",
			"Enam",
			"Tujuh",
			"Delapan",
			"Sembilan",
			"Sepuluh",
			"Sebelas"}
		return kata[angka]
	case angka <= 19:
		satuan := angka - 10
		return angkaKeKata(satuan) + " Belas"
	case angka <= 99:
		return angkaKelipatanKeKata(angka, 10, "Sepuluh", "Puluh")
	case angka <= 999:
		return angkaKelipatanKeKata(angka, 100, "Seratus", "Ratus")
	case angka <= 999_999:
		return angkaKelipatanKeKata(angka, 1000, "Seribu", "Ribu")
	case angka <= 999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000, "Satu Juta", "Juta")
	case angka <= 999_999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000_000, "Satu Milyar", "Milyar")
	case angka <= 999_999_999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000_000_000, "Satu Triliun", "Triliun")
	default:
		return "Tidak diketahui"
	}
}

Kode Akhir

Kode akhir dari proyek ini seperti berikut:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	fmt.Println("Masukkan angka yang akan diubah")

	var teks string
	fmt.Scanln(&teks)

	angka, err := strconv.Atoi(teks)
	if err != nil {
		fmt.Println("Maaf, yang anda masukkan bukan angka")
		return
	}
	fmt.Println(angkaKeKata(angka))
}

func angkaKelipatanKeKata(
	angka int,
	faktor int,
	kataKelipatan1 string,
	suffiks string) string {
	kelipatan := angka / faktor
	sisa := angka % faktor
	var hasil string
	if kelipatan == 1 {
		hasil = kataKelipatan1
	} else {
		hasil = angkaKeKata(kelipatan) + " " + suffiks
	}
	if sisa > 0 {
		hasil += " " + angkaKeKata(sisa)
	}
	return hasil
}

func angkaKeKata(angka int) string {
	switch {
	case angka <= 11:
		kata := []string{
			"Nol",
			"Satu",
			"Dua",
			"Tiga",
			"Empat",
			"Lima",
			"Enam",
			"Tujuh",
			"Delapan",
			"Sembilan",
			"Sepuluh",
			"Sebelas"}
		return kata[angka]
	case angka <= 19:
		satuan := angka - 10
		return angkaKeKata(satuan) + " Belas"
	case angka <= 99:
		return angkaKelipatanKeKata(angka, 10, "Sepuluh", "Puluh")
	case angka <= 999:
		return angkaKelipatanKeKata(angka, 100, "Seratus", "Ratus")
	case angka <= 999_999:
		return angkaKelipatanKeKata(angka, 1000, "Seribu", "Ribu")
	case angka <= 999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000, "Satu Juta", "Juta")
	case angka <= 999_999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000_000, "Satu Milyar", "Milyar")
	case angka <= 999_999_999_999_999:
		return angkaKelipatanKeKata(angka, 1_000_000_000_000, "Satu Triliun", "Triliun")
	default:
		return "Tidak diketahui"
	}
}