진법(radix) 표 만들기 예제 with Go

컴퓨터 프로그래밍에서 꼭 알아두어야 할 주요 진법은 당연히 10진법, 2진법, 8진법, 16진법이다.
다음은  0 에서 15 까지의 정수를 10진법, 2진법, 8진법, 16진법의 표로 만들어 보여주는 Go 언어 소스 코드이다. 진법 변환에 필요한 함수

        convertAtoI(string, radix)
        convertItoA(int64, radix)

를 Go 언어 코드로 자체 작성하여 사용하였다.

1. /*
2.  *  Filename: makeRadixTable.go
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Execute: go run makeRadixTable.go
6.  *
7.  *  or
8.  *
9.  *  Compile: go build makeRadixTable.go
10.  *  Execute: ./makeRadixTable
11.  *
12.  *      Date:  2012/06/25
13.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
14.  */
16. package main
18. import (
19.     "fmt"
20.     "os"
21. )   
23. type _TOKEN struct {
24.     a string
25.     b string
26. }
28. func println(s string) {
29.     fmt.Printf("%s\n", s)
30. }
32. func print(s string) {
33.     fmt.Printf("%s", s)
34. }
36. func printUsage() {
37.     println("Usage: makeRadixTable")
38.     println("Show the radix table with 10-, 2-, 8-, 16-radices.")
39. }
41. func convertItoA(num int64, radix int) (ret string) {
42.     var BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
43.     var tmp string
44.     var arr string
45.     var q, r int64
46.     var i, n int
47.     var isNegative bool = false
49.     if num < 0 {
50.         isNegative = true
51.         num = -num
52.     }
54.     arr = ""
55.     q = num
56.     r = 0
58.     for q >= int64(radix) {
59.         r = q % int64(radix)
60.         q = q / int64(radix)
61.         tmp = BASE36[r:r+1]
62.         arr += tmp
63.     }
64.     tmp = BASE36[q:q+1]
65.     arr += tmp
66.     if isNegative {
67.         arr += "-"
68.     }
70.     n = len(arr)
71.     for i = 0; i < n; i++ {
72.         ret += arr[n - i - 1:n-i]
73.     }
74.     return ret
75. }
77. func convertAtoI(str string, radix int) (ret int64) { 
78.     var isNegative bool = false
79.     var len int = len(str)
80.     var c byte
81.     var i int
82.     var val int64
84.     c = str[0]
85.     if c == '-' {
86.         isNegative = true
87.     } else if c >= '0' && c <= '9' {
88.         ret = int64(c) - int64('0');
89.     } else if c >= 'A' && c <= 'Z' {
90.         ret = int64(c - 'A') + 10
91.     } else if c >= 'a' && c <= 'z' {
92.         ret = int64(c - 'a') + 10;
93.     }
94.     if ret >= int64(radix) {
95.         println("        Invalid character!")
96.         return ret
97.     }
99.     for i = 1; i < len; i++ {
100.         c = str[i]
101.         ret *= int64(radix)
102.         if c >= '0' && c <= '9' {
103.             val = int64(c - '0')
104.         } else if c >= 'A' && c <= 'Z' {
105.             val = int64(c - 'A') + 10
106.         } else if c >= 'a' && c <= 'z' {
107.             val = int64(c - 'a') + 10
108.         }
109.         if val >= int64(radix) {
110.             println("        Invalid character!")
111.             return ret
112.         }
113.         ret += val
114.     }
116.     if isNegative {
117.         ret = -ret
118.     }
120.     return ret
121. }
123. func makeTable() {
124.     var sbuf, abuf, tbuf string
125.     var i int
127.     for i = 0; i < 4; i++ {
128.         print("+-------")
129.     }
130.     print("+")
131.     println("")
133.     print("|  Dec")
134.     print("\t|   Bin")
135.     print("\t|  Oct")
136.     print("\t|  Hex  |")
137.     println("")
139.     for i = 0; i < 4; i++ {
140.         print("+-------")
141.     }
142.     print("+")
143.     println("")
145.     for i = 0; i < 16; i++ {
146.         sbuf = fmt.Sprintf("|   %2d", i)
147.         abuf = convertItoA(int64(i), 2)
148.         tbuf = fmt.Sprintf("\t|  %4s", abuf)
149.         sbuf += tbuf
151.         abuf = convertItoA(int64(i), 8)
152.         tbuf = fmt.Sprintf("\t|   %2s", abuf)
153.         sbuf += tbuf
155.         abuf = convertItoA(int64(i), 16)
156.         tbuf = fmt.Sprintf("\t|    %-2s |", abuf)
157.         sbuf += tbuf
158.         println(sbuf)
159.     }
161.     for i = 0; i < 4; i++ {
162.         print("+-------");
163.     }
164.     print("+")
165.     println("")
166. }
168. func main() {
169.     if len(os.Args) > 1 &&  os.Args[1] == "-h" {
170.         printUsage()
171.         os.Exit(1)
172.     }
173.     makeTable()
174. }
     

실행> go run akeRadixTable.go

컴파일> go build makeRadixTable.go

실행> ./makeRadixTable

+-------+-------+-------+-------+
|  Dec  |   Bin |  Oct  |  Hex  |
+-------+-------+-------+-------+
|    0  |     0 |    0  |    0  |
|    1  |     1 |    1  |    1  |
|    2  |    10 |    2  |    2  |
|    3  |    11 |    3  |    3  |
|    4  |   100 |    4  |    4  |
|    5  |   101 |    5  |    5  |
|    6  |   110 |    6  |    6  |
|    7  |   111 |    7  |    7  |
|    8  |  1000 |   10  |    8  |
|    9  |  1001 |   11  |    9  |
|   10  |  1010 |   12  |    A  |
|   11  |  1011 |   13  |    B  |
|   12  |  1100 |   14  |    C  |
|   13  |  1101 |   15  |    D  |
|   14  |  1110 |   16  |    E  |
|   15  |  1111 |   17  |    F  |
+-------+-------+-------+-------+