Script Programming(스크립트 프로그래밍)

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

        convertAtoI(string, radix)
        convertItoA(number, radix)

를 Ruby 코드로 자체 작성하여 사용하였다.
(아래의 소스는 JRuby로 실행시켜도 된다.)

1. #  Filename: makeRadixTable.rb
2. #            Show the radix table with 10-, 2-, 8-, 16-radices.
3. #
4. #  Execute: ruby makeRadixTable.rb
5. #
6. #      Date:  2008/03/28
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
11. def println(s=nil)
12.     if s == nil
13.         print("\n")
14.     else
15.         print("%s\n" % s)
16.     end
17. end
19. def printUsage()
20.     println("Usage: ruby makeRadixTable.rb")
21.     println("Show the radix table with 10-, 2-, 8-, 16-radices.")
22. end
24. def convertItoA(num, radix)
25.     isNegative = false
26.     if num < 0
27.         isNegative = true
28.         num = -num
29.     end
31.     arr = ""
32.     q = num
33.     r = 0
35.     while q >= radix
36.         r = q % radix
37.         q = q / radix
38.         arr = arr + BASE36[r..r]
39.     end
40.     arr = arr + BASE36[q..q]
42.     if isNegative
43.         arr = arr + "-"
44.     end
46.     n = arr.length
47.     ret = ""
48.     for i in 0...n
49.         ret = ret + arr[(n - i - 1)..(n - i - 1)]
50.     end
52.     return ret
53. end
55. def convertAtoI(srcStr, radix)
56.     isNegative = false
57.     ret = 0
58.     len = srcStr.length
59.     val = 0
60.     c = srcStr[0..0]
62.     if c == '-'
63.         isNegative = true
64.     elsif c >= '0' and c <= '9'
65.         ret = c[0] - '0'[0]
66.     elsif c >= 'A' and c <= 'Z'
67.         ret = (c[0] - 'A'[0]) + 10
68.     elsif c >= 'a' and c <= 'z'
69.         ret = (c[0] - 'a'[0]) + 10
70.     end
71.     if ret >= radix
72.         println("        Invalid character!")
73.         return ret
74.     end
76.     for i in 1...len
77.         c = srcStr[i..i]
78.         ret = ret * radix
79.         if c >= '0' and c <= '9'
80.             val = c[0] - '0'[0]
81.         elsif c >= 'A' and c <= 'Z'
82.             val = (c[0] - 'A'[0]) + 10
83.         elsif c >= 'a' and c <= 'z'
84.             val = (c[0] - 'a'[0]) + 10
85.         end
87.         if val >= radix
88.             println("        Invalid character!")
89.             return ret
90.         end
91.         ret = ret + val
92.     end
94.     return ret
95. end
97. def makeTable()
98.     sbuf = ""
99.     abuf = ""
100.     tbuf = ""
102.     for i in 0...4
103.         sbuf += "+-------"
104.     end
105.     sbuf += "+"
106.     println(sbuf)
108.     sbuf = "|  Dec"
109.     sbuf += "\t|   Bin"
110.     sbuf += "\t|  Oct"
111.     sbuf += "\t|  Hex  |"
112.     println(sbuf)
114.     sbuf = ""
115.     for i in 0...4
116.         sbuf += "+-------"
117.     end
118.     sbuf += "+"
119.     println(sbuf)
121.     for i in 0...16
122.         sbuf = "|   %2d" % i
123.         abuf = convertItoA(i, 2)
124.         tbuf = "\t|  %4s" % abuf
125.         sbuf += tbuf
127.         abuf = convertItoA(i, 8)
128.         tbuf = "\t|   %2s" % abuf
129.         sbuf += tbuf
131.         abuf = convertItoA(i, 16)
132.         tbuf = "\t|    %-2s |" % abuf
133.         sbuf += tbuf
134.         println(sbuf)
135.     end
137.     sbuf = ""
138.     for i in 0...4
139.         sbuf += "+-------"
140.     end
141.     sbuf += "+"
142.     println(sbuf)
143. end
146. if ARGV.length > 0 and "-h" == ARGV[0]
147.     printUsage()
148.     exit(1)
149. end
151. makeTable()

실행> ruby makeRadixTable.rb

+-------+-------+-------+-------+
|  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  |
+-------+-------+-------+-------+

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

        convertAtoI(string, radix)
        convertItoA(number, radix)

를 Python 코드로 자체 작성하여 사용하였다.

(아래의 소스는 Jython이나 IronPython에서도 수정없이 그대로 실행된다.)

1. #  Filename: makeRadixTable.py
2. #            Show the radix table with 10-, 2-, 8-, 16-radices.
3. #
4. #  Execute: python makeRadixTable.py
5. #
6. #      Date:  2008/03/28
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. import sys
11. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
13. def println(s=None):
14.     if s == None:
15.         print
16.     else:
17.         print(s)
19. def printUsage():
20.     println("Usage: python makeRadixTable.py")
21.     println("Show the radix table with 10-, 2-, 8-, 16-radices.")
23. def convertItoA(num, radix):
24.     isNegative = False
25.     if num < 0:
26.         isNegative = True
27.         num = -num
29.     arr = ""
30.     q = num
31.     r = 0
33.     while q >= radix:
34.         r = q % radix
35.         q = q / radix
36.         arr += BASE36[r]
38.     arr += BASE36[q]
39.     if isNegative:
40.         arr += "-"
42.     n = len(arr)
43.     ret = ""
44.     for i in range(0, n):
45.         ret += arr[n - i - 1]
47.     return ret
49. def convertAtoI(srcStr, radix):
50.     isNegative = False
51.     ret = 0
52.     m = len(srcStr)
53.     val = 0
54.     c = srcStr[0]
56.     if c == '-':
57.         isNegative = True
58.     elif c >= '0' and c <= '9':
59.         ret = ord(c) - ord('0')
60.     elif c >= 'A' and c <= 'Z':
61.         ret = (ord(c) - ord('A')) + 10
62.     elif c >= 'a' and c <= 'z':
63.         ret = (ord(c) - ord('a')) + 10
65.     if ret >= radix:
66.         println("        Invalid character!")
67.         return ret
69.     for i in range(1, m):
70.         c = srcStr[i]
71.         ret *= radix
72.         if c >= '0' and c <= '9':
73.             val = ord(c) - ord('0')
74.         elif c >= 'A' and c <= 'Z':
75.             val = (ord(c) - ord('A')) + 10
76.         elif c >= 'a' and c <= 'z':
77.             val = (ord(c) - ord('a')) + 10
79.         if val >= radix:
80.             println("        Invalid character!")
81.             return ret
83.         ret += val
84.     return ret
86. def makeTable():
87.     sbuf = ""
88.     abuf = ""
89.     tbuf = ""
91.     for i in range(0, 4):
92.         sbuf += "+-------"
94.     sbuf += "+"
95.     println(sbuf)
97.     sbuf = "|  Dec"
98.     sbuf += "\t|   Bin"
99.     sbuf += "\t|  Oct"
100.     sbuf += "\t|  Hex  |"
101.     println(sbuf)
103.     sbuf = ""
104.     for i in range(0, 4):
105.         sbuf += "+-------"
106.     sbuf += "+"
107.     println(sbuf)
109.     for i in range(0, 16):
110.         sbuf = "|   %2d" % i
111.         abuf = convertItoA(i, 2)
112.         tbuf = "\t|  %4s" % abuf
113.         sbuf += tbuf
115.         abuf = convertItoA(i, 8)
116.         tbuf = "\t|   %2s" % abuf
117.         sbuf += tbuf
119.         abuf = convertItoA(i, 16)
120.         tbuf = "\t|    %-2s |" % abuf
121.         sbuf += tbuf
122.         println(sbuf)
124.     sbuf = ""
125.     for i in range(0, 4):
126.         sbuf += "+-------"
127.     sbuf += "+"
128.     println(sbuf)
130. if len(sys.argv) > 1 and "-h" == sys.argv[1]:
131.     printUsage()
132.     sys.exit(1)
134. makeTable()

실행> python makeRadixTable.py

+-------+-------+-------+-------+
|  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  |
+-------+-------+-------+-------+

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

         Integer.parseInt(String, int radix);
         Long.toString(long, int radix);

가 이미 있지만, 여기에 준하는 함수

        convertAtoI(String, radix)
        convertItoA(long, radix)

를 Groovy 코드로 자체 작성하여 사용하였다.

1. /*
2.  *  Filename: makeRadixTable.groovy
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Execute: groovy makeRadixTable.groovy
6.  *
7.  *      Date:  2008/03/28
8.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9.  */
11. def printUsage() {
12.     println("Usage: groovy makeRadixTable.groovy")
13.     println("Show the radix table with 10-, 2-, 8-, 16-radices.")
14. }
16. def convertItoA(long num, int radix) {
17.     String BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
18.     long q, r
19.     boolean isNegative = false
20.     if (num < 0) {
21.         isNegative = true
22.         num = -num
23.     }
25.     def arr = ""
26.     q = num
27.     r = 0
29.     while (q >= radix) {
30.         r = q % radix
31.         q = q / radix
32.         arr += BASE36[(int) r]
33.      }
34.      arr += BASE36[(int) q]
36.      if (isNegative) {
37.          arr += "-"
38.      }
40.      int n = arr.length()
41.      def ret = ""
42.      for (i = 0; i < n; i++) {
43.          ret += arr[n - i - 1]
44.      }
45.      return ret
46. }
48. def convertAtoI(String srcStr, int radix) {
49.     String BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
50.     boolean isNegative = false
51.     long ret = 0L
52.     int len = srcStr.length()
53.     String c
54.     int i
55.     long val = 0L
57.     c = srcStr[0]
58.     if (c == '-') {
59.         isNegative = true
60.     }
61.     else if (c >= '0' && c <= '9') {
62.         ret = (long) (c.charAt(0) - '0'.charAt(0))
63.     }
64.     else if (c >= 'A' && c <= 'Z') {
65.         ret = (long) (c.charAt(0) - 'A'.charAt(0)) + 10L
66.     }
67.     else if (c >= 'a' && c <= 'z') {
68.         ret = (long) (c.charAt(0) - 'a'.charAt(0)) + 10L
69.     }
70.     if (ret >= (long) radix) {
71.         println("        Invalid character!")
72.         return ret
73.     }
75.     for (i = 1; i < len; i++) {
76.         c = srcStr[i]
77.         ret *= radix
78.         if (c >= '0' && c <= '9') {
79.             val = (long) (c.charAt(0) - '0'.charAt(0))
80.         }
81.         else if (c >= 'A' && c <= 'Z') {
82.             val = (long) (c.charAt(0) - 'A'.charAt(0)) + 10L
83.         }
84.         else if (c >= 'a' && c <= 'z') {
85.             val = (long) (c.charAt(0) - 'a'.charAt(0)) + 10L
86.         }
87.         if (val >= (long) radix) {
88.             println("        Invalid character!")
89.             return ret
90.         }
91.         ret += val
92.     }
93.     return ret
94. }
96. def makeTable() {
97.     String sbuf = ""
98.     String abuf = ""
99.     String tbuf = ""
100.     int i, j
101.     char c;
103.     for (i = 0; i < 4; i++) {
104.         print("+-------")
105.     }
106.     print("+")
107.     println("")
109.     print("|  Dec")
110.     print("\t|   Bin")
111.     print("\t|  Oct")
112.     print("\t|  Hex  |")
113.     println("")
115.     for (i = 0; i < 4; i++) {
116.         print("+-------")
117.     }
118.     print("+")
119.     println("")
121.     for (i = 0; i < 16; i++) {
122.         sbuf = String.format("|   %2d", i)
123.         abuf = convertItoA((long) i, 2)
124.         tbuf = String.format("\t|  %4s", abuf)
125.         sbuf += tbuf
127.         abuf = convertItoA((long) i, 8)
128.         tbuf = String.format("\t|   %2s", abuf)
129.         sbuf += tbuf
131.         abuf = convertItoA((long) i, 16)
132.         tbuf = String.format("\t|    %-2s |", abuf)
133.         sbuf += tbuf
134.         println(sbuf)
135.     }
137.     for (i = 0; i < 4; i++) {
138.         print("+-------")
139.     }
140.     print("+")
141.     println("")
142. }
144. if (args.length > 0 && "-h".equals(args[0])) {
145.     printUsage()
146.     System.exit(1);
147. }
149. makeTable()

실행> groovy makeRadixTable.groovy

+-------+-------+-------+-------+
|  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  |
+-------+-------+-------+-------+

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

         Integer.parseInt(String, int radix);
         Long.toString(long, int radix);

가 이미 있지만, 여기에 준하는 메소드

        convertAtoI(String, radix)
        convertItoA(long, radix)

를 자체 작성하여 사용하였다.

1. /*
2.  *  Filename: MakeRadixTableApp.java
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Compile: javac -d . MakeRadixTableApp.java
6.  *  Execute: java MakeRadixTableApp
7.  *
8.  *      Date:  2008/03/27
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. public class MakeRadixTableApp {
14.     static void println(String s) {
15.         System.out.println(s);
16.     }
18.     static void print(String s) {
19.         System.out.print(s);
20.     }
22.     static void printUsage() {
23.         println("Usage: java MakeRadixTableApp");
24.         println("Show the radix table with 10-, 2-, 8-, 16-radices.");
26.     }
28.     static String BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
30.     public static String convertItoA(long num, int radix) {
31.         long q, r;
32.         boolean isNegative = false;
33.         if (num < 0L) {
34.             isNegative = true;
35.             num = -num;
36.         }
38.         String arr = "";
39.         q = num;
40.         r = 0L;
42.         while (q >= (long) radix) {
43.             r = q % (long) radix;
44.             q = q / (long) radix;
45.             arr += BASE36.charAt((int) r);
46.         }
47.         arr += BASE36.charAt((int) q);
49.         if (isNegative) {
50.              arr += "-";
51.         }
53.         int n = arr.length();
54.         String ret = "";
55.         for (int i = 0; i < n; i++) {
56.             ret += arr.charAt(n - i - 1);
57.         }
58.         return ret;
59.     }
61.     public static long convertAtoI(String srcStr, int radix) {
62.         boolean isNegative = false;
63.         long ret = 0L;
64.         int len = srcStr.length();
65.         char c;
66.         int i;
67.         long val = 0L;
69.         c = srcStr.charAt(0);
70.         if (c == '-') {
71.            isNegative = true;
72.         }
73.         else if (c >= '0' && c <= '9') {
74.             ret = (long) (c - '0');
75.         }
76.         else if (c >= 'A' && c <= 'Z') {
77.             ret = (long) (c - 'A') + 10L;
78.         }
79.         else if (c >= 'a' && c <= 'z') {
80.             ret = (long) (c - 'a') + 10L;
81.         }
82.         if (ret >= (long) radix) {
83.             println("        Invalid character!");
84.             return ret;
85.         }
87.         for (i = 1; i < len; i++) {
88.             c = srcStr.charAt(i);
89.             ret *= radix;
90.             if (c >= '0' && c <= '9') {
91.                 val = (long) (c - '0');
92.             }
93.             else if (c >= 'A' && c <= 'Z') {
94.                 val = (long) (c - 'A') + 10L;
95.             }
96.             else if (c >= 'a' && c <= 'z') {
97.                 val = (long) (c - 'a') + 10L;
98.             }
99.             if (val >= (long) radix) {
100.                 println("        Invalid character!");
101.                 return ret;
102.             }
103.             ret += val;
104.         }
105.         return ret;
106.     }
108.     public static void makeTable() {
109.         String sbuf = "";
110.         String abuf = "";
111.         String tbuf = "";
112.         int i, j;
113.         char c;
115.         for (i = 0; i < 4; i++) {
116.             print("+-------");
117.         }
118.         print("+");
119.         println("");
121.         print("|  Dec");
122.         print("\t|   Bin");
123.         print("\t|  Oct");
124.         print("\t|  Hex  |");
125.         println("");
127.         for (i = 0; i < 4; i++) {
128.             print("+-------");
129.         }
130.         print("+");
131.         println("");
133.         for (i = 0; i < 16; i++) {
134.             sbuf = String.format("|   %2d", i);
135.             abuf = convertItoA((long) i, 2);
136.             tbuf = String.format("\t|  %4s", abuf);
137.             sbuf += tbuf;
138.             abuf = convertItoA((long) i, 8);
139.             tbuf = String.format("\t|   %2s", abuf);
140.             sbuf += tbuf;
141.             abuf = convertItoA((long) i, 16);
142.             tbuf = String.format("\t|    %-2s |", abuf);
143.             sbuf += tbuf;
144.             println(sbuf);
145.         }
147.         for (i = 0; i < 4; i++) {
148.             print("+-------");
149.         }
150.         print("+");
151.         println("");
152.     }
154.     public static void main(String[] args) {
155.         if (args.length > 0 && "-h".equals(args[0])) {
156.             printUsage();
157.             System.exit(1);
158.         }
159.         makeTable();
160.     }
161. }

컴파일> javac -d . MakeRadixTableApp.java

실행> java MakeRadixTableApp

+-------+-------+-------+-------+
|  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  |
+-------+-------+-------+-------+

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 C++ 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환을 하는 핵심 함수 convertAtoI()와 convertItoA()의 소스가 자체 제작되어 포함되어 있다. 이를 이용하는 부분은 157~158째 줄에 있는

         val = convertAtoI(s, srcRdx);
         convertItoA((char *) ret, val, destRdx);

이다. 지원되는 진법은 2진법에서 36진법 까지이다.

1. /*
2.  *  Filename: convertRadixCPP.cpp
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Compile: cl /EHsc convertRadixCPP.cpp
6.  *  Execute: convertRadixCPP
7.  *
8.  *      Date:  2008/03/25
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. #include <iostream>
13. #include <string>
14. #include <cmath>
16. using namespace std;
18. #define MAX_BUF 300
20. enum { FALSE, TRUE };
22. struct _TOKEN {
23.     char a[81];
24.     char b[81];
25. };
27. void println(char s[]) {
28.     cout << s << endl;
29. }
31. void print(char s[]) {
32.     cout << s;
33. }
35. void printUsage() {
36.     println("Usage: convertRadixCPP");
37.     println("Convert radix in a interactive mode, where the maximum radix is 36.");
38. }
40. void printAbout() {
41.     println("    About: Convert radix in a interactive mode.");
42. }
44. void printMainMenu() {
45.     println("  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it");
46. }
48. void printMainPrompt() {
49.     print("  Prompt> ");
50. }
52. void printSubMenu(int srcRadix, int destRadix) {
53.     char sbuf[MAX_BUF];
54.     sprintf(sbuf, "    Convert Radix_%d to Radix_%d", srcRadix, destRadix);
55.     println(sbuf);
56.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
57. }
59. void printSubPrompt() {
60.     print("    Input Value>> ");
61. }
63. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
65. void convertItoA(char *pstr, long num, int radix) {
66.    char tmp[2];
67.    char ret[MAX_BUF];
68.    char arr[MAX_BUF];
69.    long q, r;
70.    int i, n;
71.    int isNegative = FALSE;
73.    if (num < 0L) {
74.       isNegative = TRUE;
75.       num = -num;
76.    }
78.    arr[0] = '\0';
79.    q = num;
80.    r = 0L;
82.    while (q >= (long) radix) {
83.       r = q % (long) radix;
84.       q = q / (long) radix;
85.       tmp[0] = BASE36[r];
86.       tmp[1] = '\0';
87.       strcat(arr, tmp);
88.    }
90.    tmp[0] = BASE36[q];
91.    tmp[1] = '\0';
92.    strcat(arr, tmp);
93.    if (isNegative) {
94.       strcat(arr, "-");
95.    }
96.     n = strlen(arr);
97.     for (i = 0; i < n; i++) {
98.         ret[i] = arr[n - i - 1];
99.     }
100.     ret[n] = '\0';
101.     strcpy(pstr, (char *) ret);
102. }
104. long convertAtoI(const char *pstr, int radix) {
105.     char tmp[2];
106.     long ret = 0L;
107.     char arr[MAX_BUF];
108.     long q, r;
109.     int isNegative = FALSE;
110.     int len = strlen(pstr);
111.     char c;
112.     int i;
113.     long val;
115.     c = pstr[0];
116.     if (c == '-') {
117.         isNegative = TRUE;
118.     }
119.     else if (c >= '0' && c <= '9') {
120.         ret = (long) (c - '0');
121.     }
122.     else if (c >= 'A' && c <= 'Z') {
123.         ret = (long) (c - 'A') + 10L;
124.     }
125.     else if (c >= 'a' && c <= 'z') {
126.         ret = (long) (c - 'a') + 10L;
127.     }
128.     if (ret >= (long) radix) {
129.         println("        Invalid character!");
130.         return ret;
131.     }
133.     for (i = 1; i < len; i++) {
134.         c = pstr[i];
135.         ret *= radix;
136.         if (c >= '0' && c <= '9') {
137.             val = (long) (c - '0');
138.         }
139.         else if (c >= 'A' && c <= 'Z') {
140.             val = (long) (c - 'A') + 10L;
141.         }
142.         else if (c >= 'a' && c <= 'z') {
143.             val = (long) (c - 'a') + 10L;
144.         }
145.         if (val >= (long) radix) {
146.             println("        Invalid character!");
147.             return ret;
148.         }
149.         ret += val;
150.     }
151.     return ret;
152. }
154. void convertRadix(char *pstr, char s[],  int srcRdx, int destRdx) {
155.     long val;
156.     char ret[MAX_BUF];
157.     val = convertAtoI(s, srcRdx);
158.     convertItoA((char *) ret, val, destRdx);
159.     strcpy(pstr, ret);
160. }
162. void readLine(char *pdata) {
163.     scanf("%s", pdata);
164. }
166. void readTwo(struct _TOKEN *ptoken) {
167.     scanf("%s", ptoken->a);
168.     scanf("%s", ptoken->b);
169. }
171. void tokenize(struct _TOKEN *ptoken, const char *line, char c) {
172.     int len = strlen(line);
173.     int i;
174.     int from, to;
176.     i = 0;
177.     while (line[i] != c) {
178.         i++;
179.     }
180.     from = i;
181.     while (line[i] == c) {
182.         i++;
183.     }
185.     to = i;
186.     strncpy(ptoken->a, line, to - from);
187.     ptoken->a[to - from] = '\0';
188.     while (line[i] != c) {
189.         i++;
190.     }
192.     from = i;
193.     while (line[i] == c) {
194.         i++;
195.     }
197.     to = i;
198.     strncpy(ptoken->b, line, to - from);
199.     ptoken->b[to - from] = '\0';
200. }
202. void doConvert(int srcRadix, int destRadix) {
203.     char sbuf[MAX_BUF];
204.     char line[MAX_BUF];
205.     char cmd[MAX_BUF];
206.     char srcStr[MAX_BUF], destStr[MAX_BUF];
207.     long tmp;
208.     println("");
209.     printSubMenu(srcRadix, destRadix);
210.     do {
211.         printSubPrompt();
212.         readLine((char *)cmd);
213.         while (strlen(cmd) <= 0) {
214.             readLine((char *)cmd);
215.         }
216.         if (strcmp("main()", cmd) == 0) {
217.             return;
218.         }
219.         else if (strcmp("exit()", cmd) == 0 || strcmp("quit()", cmd) == 0) {
220.             exit(0);
221.         }
222.         tmp = convertAtoI(cmd, srcRadix);
223.         strcpy(srcStr, cmd);
224.         convertRadix(destStr, srcStr, srcRadix, destRadix);
225.         sprintf(sbuf, "        ( %s )_%d   --->   ( %s )_%d", srcStr, srcRadix, destStr, destRadix);
226.         println(sbuf);
227.         println("");
228.     } while (TRUE);
229. }
231. void doStart() {
232.     char line[MAX_BUF];
233.     char cmd[MAX_BUF];
234.     int srcRadix = 10, destRadix = 10;
235.     char srcStr[MAX_BUF], destStr[MAX_BUF];
236.     struct _TOKEN st;
237.     int onlyOnce = TRUE;
239.     do {
240.         println("");
241.         if (onlyOnce) {
242.             println("  The supported maximum radix is 36.");
243.             onlyOnce = FALSE;
244.         }
245.         printMainMenu();
246.         printMainPrompt();
248.         readLine((char *)cmd);
249.         while (strlen(cmd) <= 0) {
250.             readLine((char *)cmd);
251.         }
253.         if (strstr("qQxX", cmd) != NULL && strlen(cmd) == 1) {
254.             exit(0);
255.         }
256.         else if (strstr("aA", cmd) != NULL && strlen(cmd) == 1) {
257.             printAbout();
258.         }
259.         else if (strstr("sS", cmd) != NULL && strlen(cmd) == 1) {
260.             print("  Input the source and target radices (say, 16 2): ");
261.             readTwo((struct _TOKEN *) &st);
262.             srcRadix = convertAtoI(st.a, 10);
263.             destRadix = convertAtoI(st.b, 10);
264.             doConvert(srcRadix, destRadix);
265.         }
266.     } while (TRUE);
267. }
269. void main(int argc, char *argv[]) {
270.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
271.         printUsage();
272.         exit(1);
273.     }
274.     doStart();
275. }

컴파일> cl /EHsc convertRadixCPP.cpp

실행> convertRadixCPP

  The supported maximum radix is 36.
  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 4 2

    Convert Radix_4 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 321
        ( 321 )_4   --->   ( 111001 )_2

    Input Value>> main()

  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 2 4

    Convert Radix_2 to Radix_4
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 111001
        ( 111001 )_2   --->   ( 321 )_4

    Input Value>> quit()






이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 C 소스 코드이다.
(Ch를 이용하면 컴파일 하지 않고 소스를 그대로 실행시킬 수 있다.)
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환을 하는 핵심 함수 convertAtoI()와 convertItoA()의 소스가 자체 제작되어 포함되어 있다. 이를 이용하는 부분은 153~154째 줄에 있는

         val = convertAtoI(s, srcRdx);
         convertItoA((char *) ret, val, destRdx);

이다. 지원되는 진법은 2진법에서 36진법 까지이다.

1. /*
2.  *  Filename: convertRadix.c
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Compile: cl convertRadix.c
6.  *  Execute: convertRadix
7.  *
8.  *      Date:  2008/03/25
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  */
12. #include <stdio.h>
13. #include <string.h>
14. #include <math.h>
16. #define MAX_BUF 300
18. enum { FALSE, TRUE };
20. struct _TOKEN {
21.     char a[81];
22.     char b[81];
23. };
25. void println(char s[]) {
26.     printf("%s\n", s);
27. }
29. void print(char s[]) {
30.     printf("%s", s);
31. }
33. void printUsage() {
34.     println("Usage: convertRadix");
35.     println("Convert radix in a interactive mode, where the maximum radix is 36.");
36. }
38. void printAbout() {
39.     println("    About: Convert radix in a interactive mode.");
40. }
42. void printMainMenu() {
43.     println("  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it");
44. }
46. void printMainPrompt() {
47.     print("  Prompt> ");
48. }
50. void printSubMenu(int srcRadix, int destRadix) {
51.     char sbuf[MAX_BUF];
52.     sprintf(sbuf, "    Convert Radix_%d to Radix_%d", srcRadix, destRadix);
53.     println(sbuf);
54.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
55. }
57. void printSubPrompt() {
58.     print("    Input Value>> ");
59. }
61. char BASE36[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
63. void convertItoA(char *pstr, long num, int radix) {
64.     char tmp[2];
65.     char ret[MAX_BUF];
66.     char arr[MAX_BUF];
67.     long q, r;
68.     int i, n;
69.     int isNegative = FALSE;
70.     if (num < 0L) {
71.         isNegative = TRUE;
72.         num = -num;
73.     }
74.     arr[0] = '\0';
75.     q = num;
76.     r = 0L;
78.     while (q >= (long) radix) {
79.         r = q % (long) radix;
80.         q = q / (long) radix;
81.         tmp[0] = BASE36[r];
82.         tmp[1] = '\0';
83.         strcat(arr, tmp);
84.     }
85.     tmp[0] = BASE36[q];
86.     tmp[1] = '\0';
87.     strcat(arr, tmp);
88.     if (isNegative) {
89.         strcat(arr, "-");
90.     }
92.     n = strlen(arr);
93.     for (i = 0; i < n; i++) {
94.         ret[i] = arr[n - i - 1];
95.     }
96.     ret[n] = '\0';
97.     strcpy(pstr, (char *) ret);
98. }
100. long convertAtoI(const char *pstr, int radix) {
101.     long ret = 0L;
102.     char arr[MAX_BUF];
103.     long q, r;
104.     int isNegative = FALSE;
105.     int len = strlen(pstr);
106.     char c;
107.     int i;
108.     long val;
110.     c = pstr[0];
111.     if (c == '-') {
112.         isNegative = TRUE;
113.     }
114.     else if (c >= '0' && c <= '9') {
115.         ret = (long) (c - '0');
116.     }
117.     else if (c >= 'A' && c <= 'Z') {
118.         ret = (long) (c - 'A') + 10L;
119.     }
120.     else if (c >= 'a' && c <= 'z') {
121.         ret = (long) (c - 'a') + 10L;
122.     }
123.     if (ret >= (long) radix) {
124.         println("        Invalid character!");
125.         return ret;
126.     }
128.     for (i = 1; i < len; i++) {
129.         c = pstr[i];
130.         ret *= radix;
131.         if (c >= '0' && c <= '9') {
132.             val = (long) (c - '0');
133.         }
134.         else if (c >= 'A' && c <= 'Z') {
135.             val = (long) (c - 'A') + 10L;
136.         }
137.         else if (c >= 'a' && c <= 'z') {
138.             val = (long) (c - 'a') + 10L;
139.         }
140.         if (val >= (long) radix) {
141.             println("        Invalid character!");
142.             return ret;
143.         }
144.         ret += val;
145.     }
147.     return ret;
148. }
150. void convertRadix(char *pstr, char s[],  int srcRdx, int destRdx) {
151.     long val;
152.     char ret[MAX_BUF];
153.     val = convertAtoI(s, srcRdx);
154.     convertItoA((char *) ret, val, destRdx);
155.     strcpy(pstr, ret);
156. }
158. void readLine(char *pdata) {
159.     scanf("%s", pdata);
160. }
162. void readTwo(struct _TOKEN *ptoken) {
163.     scanf("%s", ptoken->a);
164.     scanf("%s", ptoken->b);
165. }
167. void tokenize(struct _TOKEN *ptoken, const char *line, char c) {
168.     int len = strlen(line);
169.     int i;
170.     int from, to;
172.     i = 0;
173.     while (line[i] != c) {
174.         i++;
175.     }
176.     from = i;
177.     while (line[i] == c) {
178.         i++;
179.     }
180.     to = i;
181.     strncpy(ptoken->a, line, to - from);
182.     ptoken->a[to - from] = '\0';
183.     while (line[i] != c) {
184.         i++;
185.     }
186.     from = i;
187.     while (line[i] == c) {
188.         i++;
189.     }
190.     to = i;
191.     strncpy(ptoken->b, line, to - from);
192.     ptoken->b[to - from] = '\0';
193. }
195. void doConvert(int srcRadix, int destRadix) {
196.     char sbuf[MAX_BUF];
197.     char line[MAX_BUF];
198.     char cmd[MAX_BUF];
199.     char srcStr[MAX_BUF], destStr[MAX_BUF];
200.     long tmp;
202.     println("");
203.     printSubMenu(srcRadix, destRadix);
205.     do {
206.         printSubPrompt();
207.         readLine((char *)cmd);
208.         while (strlen(cmd) <= 0) {
209.             readLine((char *)cmd);
210.         }
212.         if (strcmp("main()", cmd) == 0) {
213.             return;
214.         }
215.         else if (strcmp("exit()", cmd) == 0 || strcmp("quit()", cmd) == 0) {
216.             exit(0);
217.         }
219.         tmp = convertAtoI(cmd, srcRadix);
220.         strcpy(srcStr, cmd);
221.         convertRadix(destStr, srcStr, srcRadix, destRadix);
222.         sprintf(sbuf, "        ( %s )_%d   --->   ( %s )_%d", srcStr, srcRadix, destStr, destRadix);
223.         println(sbuf);
224.         println("");
225.     } while (TRUE);
226. }
228. void doStart() {
229.     char line[MAX_BUF];
230.     char cmd[MAX_BUF];
231.     int srcRadix = 10, destRadix = 10;
232.     char srcStr[MAX_BUF], destStr[MAX_BUF];
233.     struct _TOKEN st;
234.     int onlyOnce = TRUE;
236.     do {
237.         println("");
238.         if (onlyOnce) {
239.             println("  The supported maximum radix is 36.");
240.             onlyOnce = FALSE;
241.         }
243.         printMainMenu();
244.         printMainPrompt();
246.         readLine((char *)cmd);
247.         while (strlen(cmd) <= 0) {
248.             readLine((char *)cmd);
249.         }
251.         if (strstr("qQxX", cmd) != NULL && strlen(cmd) == 1) {
252.             exit(0);
253.         }
254.         else if (strstr("aA", cmd) != NULL && strlen(cmd) == 1) {
255.             printAbout();
256.         }
257.         else if (strstr("sS", cmd) != NULL && strlen(cmd) == 1) {
258.             print("  Input the source and target radices (say, 16 2): ");
259.             readTwo((struct _TOKEN *) &st);
260.             srcRadix = convertAtoI(st.a, 10);
261.             destRadix = convertAtoI(st.b, 10);
262.             doConvert(srcRadix, destRadix);
263.         }
264.     } while (TRUE);
265. }
267. void main(int argc, char *argv[]) {
268.     if (argc > 1 && strcmp("-h", argv[1]) == 0) {
269.         printUsage();
270.         exit(1);
271.     }
272.     doStart();
273. }

컴파일> cl convertRadix.c

실행> convertRadix

  The supported maximum radix is 36.
  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 8 16

    Convert Radix_8 to Radix_16
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1234
        ( 1234 )_8   --->   ( 29C )_16

    Input Value>> main()

  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 16 8

    Convert Radix_16 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 29c
        ( 29c )_16   --->   ( 1234 )_8

    Input Value>> exit()

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Lua 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Lua 의 빌트인 함수 tonumber(string, radix)와 소스 코드에 자체 작성된 함수 itoa(number, radix)의 사용이다.

         val = tonumber(s, srcRdx)
         ret = itoa(val, destRdx)

지원되는 진법은 2진법에서 36진법 까지이다.

1. --  Filename: convertRadix.lua
2. --            Convert radix in a interactive mode.
3. --
4. --   Execute: lua convertRadix.lua
5. --
6. --      Date:  2008/03/26
7. --    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. function println(s)
10.     if s ~= nil then
11.         print(s)
12.     else
13.         print("")
14.     end
15. end
17. function printUsage()
18.     println("Usage: lua convertRadix.lua")
19.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
20. end
22. function printAbout()
23.     println("    About: Convert radix in a interactive mode.")
24. end
26. function printMainMenu()
27.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
28. end
30. function printMainPrompt()
31.     io.write("  Prompt> ")
32. end
34. function printSubMenu(srcRadix, destRadix)
35.     println("    Convert Radix_" .. srcRadix .. " to Radix_" .. destRadix)
36.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
37. end
39. function printSubPrompt()
40.     io.write("    Input Value>> ")
41. end
43. local BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
45. function itoa(num, radix)
46.    local isNegative = false
47.    if num < 0 then
48.       isNegative = true
49.       num = -num
50.    end
52.    local arr = {}
53.    local q, r = num, 0
54.    while q >= radix do
55.       r = math.fmod(q, radix)
56.       q = math.floor(q / radix)
57.       table.insert(arr, string.sub(BASE36, r+1, r+1))
58.    end
60.    table.insert(arr, string.sub(BASE36, q+1, q+1))
61.    if isNegative then
62.       table.insert(arr, "-")
63.    end
64.    local ret = ""
65.    for i = #arr, 1, -1 do
66.        ret = ret .. arr[i]
67.    end
68.    return ret
69. end
71. function convertRadix(s, srcRdx, destRdx)
72.     local val = tonumber(s, srcRdx)
73.     local ret = itoa(val, destRdx)
74.     return string.upper(ret)
75. end
77. function doConvert(srcRadix, destRadix)
78.     local line = ""
79.     local cmd = ""
80.     local srcStr = ""
81.     local destStr = ""
83.     printSubMenu(srcRadix, destRadix)
84.     while true do
85.         printSubPrompt()
86.         cmd = io.read()
87.         while string.len(cmd) < 1 do
88.             cmd = io.read()
89.         end
91.         if "main()" == cmd then
92.             return
93.         elseif "exit()" == cmd or "quit()" == cmd then
94.             os.exit(0)
95.         end
97.         local flagContinue = true
98.         if tonumber(cmd, srcRadix) == nil then
99.             flagContinue = false
100.         end
101.         if flagContinue then
102.             srcStr = cmd
103.             destStr = convertRadix(srcStr, srcRadix, destRadix)
104.             println("        ( " .. srcStr .. " )_" .. srcRadix .. "   --->   ( " .. destStr .. " )_" .. destRadix)
105.             println("")
106.         end
107.     end
108. end
110. function doStart()
111.     local line = ""
112.     local cmd = ""
113.     local srcRadix = 10
114.     local destRadix = 10
115.     local srcStr = ""
116.     local destStr = ""
117.     local onlyOnce = true
119.     while true do
120.         println()
121.         if onlyOnce then
122.             println("  The supported maximum radix is 36.")
123.             onlyOnce = false
124.         end
126.         printMainMenu()
127.         printMainPrompt()
128.         cmd = io.read()
129.         while string.len(cmd) < 1 do
130.             cmd = io.read()
131.         end
133.         if string.find("qQxX", cmd) ~= nil and string.len(cmd) == 1 then
134.             os.exit(0)
135.         elseif string.find("aA", cmd) ~= nil and string.len(cmd) == 1 then
136.             printAbout()
137.         elseif string.find("sS", cmd) ~= nil and string.len(cmd) == 1 then
138.             io.write("  Input the source and target radices (say, 16 2): ")
139.             line = io.read()
140.             while string.len(line) < 1 do
141.                 line = io.read()
142.             end
144.             st = {}
145.             for w in string.gmatch(line, "[0-9]*") do
146.                 if string.len(w) > 0 then
147.                     table.insert(st, w)
148.                 end
149.             end
151.             while #st < 2 do
152.                 io.write("  Input the source and target radices (say, 16 2): ")
153.                 line = io.read()
154.                while string.len(line) < 1 do
155.                     line = io.read()
156.                 end
158.                 st = {}
159.                 for w in string.gmatch(line, "%a+") do
160.                     if string.len(w) > 0 then
161.                         table.insert(st, w)
162.                     end
163.                 end
164.             end
166.             println("")
167.             srcRadix = tonumber(st[1])
168.             destRadix = tonumber(st[2])
169.             doConvert(srcRadix, destRadix)
170.         end
171.     end
172. end
174. -- Begin here
175. if #arg > 0 and "-h" == arg[1] then
176.     printUsage()
177.     os.exit(1)
178. end
180. doStart()

실행> lua convertRadix.lua

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 16 2

    Convert Radix_16 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 7F
        ( 7F )_16   --->   ( 1111111 )_2

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> S
  Input the source and target radices (say, 16 2): 2 16

    Convert Radix_2 to Radix_16
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1111111
        ( 1111111 )_2   --->   ( 7F )_16

    Input Value>> exit()






이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Ruby 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Ruby의 string 클래스의 빌트인(build-in) 함수 string.to_i(radix)와 소스 코드에 자체 작성된 함수 itoa(number, radix)의 사용이다.

         val = s.to_i(srcRdx)
         ret = itoa(val, destRdx)

지원되는 진법은 2진법에서 36진법 까지이다.
(JRuby로는 gets 때문에 실행되지 않는다.)

1. #  Filename: convertRadix.rb
2. #            Convert radix in a interactive mode.
3. #
4. #  Execute: ruby convertRadix.rb
5. #
6. #      Date:  2008/03/26
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. def println(s=nil)
10.     if s != nil
11.         print("%s\n" % s)
12.     else
13.         print("\n")
14.     end
15. end
17. def printUsage()
18.     println("Usage: ruby convertRadix.rb")
19.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
20. end
22. def printAbout()
23.     println("    About: Convert radix in a interactive mode.")
24. end
26. def printMainMenu()
27.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
28. end
30. def printMainPrompt()
31.     print("  Prompt> ")
32. end
34. def printSubMenu(srcRadix, destRadix)
35.     println("    Convert Radix_" + srcRadix.to_s + " to Radix_" + destRadix.to_s)
36.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
37. end
39. def printSubPrompt()
40.     print("    Input Value>> ")
41. end
43. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
45. def itoa(num, radix=10)
46.    isNegative = false
47.    if num < 0
48.       isNegative = true
49.       num = -num
50.    end
52.    arr = []
53.    q, r = num, 0
54.    while q >= radix
55.       val = q.divmod(radix)
56.       q, r = val[0], val[1]
57.       arr.push(BASE36.slice(r..r))
58.    end
60.    arr.push(BASE36.slice(q..q))
61.    if isNegative
62.       arr.push("-")
63.    end
64.    b = arr.reverse()
65.    return b.join
66. end
68. def convertRadix(s, srcRdx, destRdx)
69.     ret = ""
70.     begin
71.         val = s.to_i(srcRdx)
72.         ret = itoa(val, destRdx)
73. return ret.upcase
74.     rescue
75.         println("    Error: Cannot convert radix " + str(srcRdx))
76.         ret = "????"
77.     end
78. end
80. def doConvert(srcRadix, destRadix)
81.     line = ""
82.     cmd = ""
83.     srcStr = ""
84.     destStr = ""
86.     println("")
87.     printSubMenu(srcRadix, destRadix)
88.     begin
89.         while true
90.             printSubPrompt()
91.             cmd = gets
92.             while cmd.length < 2
93.                 cmd = gets
94.             end
95.             cmd = cmd[0...cmd.length-1]
96.             if "main()" == cmd
97.                 return
98.             elsif "exit()" == cmd or "quit()" == cmd
99.                 exit(0)
100.             end
102.             begin
103.                 cmd.to_i(srcRadix)
104.                 srcStr = cmd
105.                 destStr = convertRadix(srcStr, srcRadix, destRadix)
106.                 println("        ( " + srcStr + " )_" + srcRadix.to_s +  "   --->   ( " + destStr + " )_" + destRadix.to_s)
107.                 println("")
108.             rescue
109.                  nil
110.             end
111.         end
112.     rescue
113.         puts "    An error occurred: #{$!}"
114.         retry
115.     end
116. end
118. def doStart()
119.     line = ""
120.     cmd = ""
121.     srcRadix = 10
122.     destRadix = 10
123.     srcStr = ""
124.     destStr = ""
125.     onlyOnce = true
127.     begin
128.         while true
129.             println()
130.             if onlyOnce
131.                 println("  The supported maximum radix is 36.")
132.                 onlyOnce = false
133.             end
134.             printMainMenu()
135.             printMainPrompt()
137.             cmd = gets
138.             while cmd.length < 1
139.                 cmd = gets
140.             end
141.             cmd = cmd[0...cmd.length-1]
142.             if "qQxX".include?(cmd) and cmd.length == 1
143.                 exit(0)
144.             elsif "aA".include?(cmd) and cmd.length == 1
145.                 printAbout()
146.             elsif "sS".include?(cmd) and cmd.length == 1
147.                 print("  Input the source and target radices (say, 16 2): ")
148.                 line = gets
149.                 line = line[0...line.length-1]
150.                 st = line.split(" ")
151.                 while st.length < 2
152.                     print("  Input the source and target radices (say, 16 2): ")
153.                     line = gets
154.                     line = line[0...line.length-1]
155.                     st = line.split(" ")
156.                 end
158.                 srcRadix = st[0].to_i
159.                 destRadix = st[1].to_i
160.                 doConvert(srcRadix, destRadix)
161.             end
162.         end
163.     rescue
164.         puts "  An error occurred: #{$!}"
165.         retry
166.     end
167. end
169. # Begin here
170. if ARGV.length > 0 and "-h" == ARGV[0]
171.     printUsage()
172.     exit(1)
173. end
175. doStart()

실행> ruby convertRadix.rb

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 8 2

    Convert Radix_8 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 123
        ( 123 )_8   --->   ( 1010011 )_2

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 2 8

    Convert Radix_2 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1010011
        ( 1010011 )_2   --->   ( 123 )_8

    Input Value>> quit()





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Python 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Python의 빌트인 함수 int(string, radix)와 소스 코드에 자체 작성된 함수 itoa(number, radix)의 사용이다.

         val = int(s, srcRdx)
         ret = itoa(val, destRdx)

지원되는 진법은 2진법에서 36진법까지이다.
(Jython으로는 finally: 구문 때문에 실행이 안된다.)

1. #  Filename: convertRadix.py
2. #            Convert radix in a interactive mode.
3. #
4. #  Execute: python convertRadix.py
5. #
6. #      Date:  2008/03/25
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. import sys
11. def println(s=None):
12.     if s != None:
13.         print(s)
14.     else:
15.         print
17. def printUsage():
18.     println("Usage: python convertRadix.py")
19.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
21. def printAbout():
22.     println("    About: Convert radix in a interactive mode.")
24. def printMainMenu():
25.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
27. def printMainPrompt():
28.     print("  Prompt>"),
30. def printSubMenu(srcRadix, destRadix):
31.     println("    Convert Radix_" + str(srcRadix) + " to Radix_" + str(destRadix))
32.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
34. def printSubPrompt():
35.     print("    Input Value>>"),
37. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
39. def itoa(num, radix=10):
40.    isNegative = False
41.    if num < 0:
42.       isNegative = True
43.       num = -num
45.    arr = []
46.    q, r = num, 0
47.    while q >= radix:
48.       q, r = divmod(q, radix)
49.       arr.append(BASE36[r])
51.    arr.append(BASE36[q])
52.    if isNegative:
53.       arr.append("-")
55.    arr.reverse()
56.    return ''.join(arr)
58. def convertRadix(s, srcRdx, destRdx):
59.     ret = ""
60.     try:
61.         val = int(s, srcRdx)
62.         ret = itoa(val, destRdx)
63.         return ret.upper()
64.     except ValueError:
65.         println("    Error: Cannot convert radix " + str(srcRdx))
66.         ret = "????"
67.     finally:
68.         return ret.upper()
70. def doConvert(srcRadix, destRadix):
71.     line = ""
72.     cmd = ""
73.     srcStr = ""
74.     destStr = ""
75.     println("")
77.     printSubMenu(srcRadix, destRadix)
78.     try:
79.         while True:
80.             printSubPrompt()
81.             cmd = raw_input()
82.             while cmd == None:
83.                 cmd = raw_input()
85.             if "main()" == cmd:
86.                 return
87.             elif "exit()" == cmd or "quit()" == cmd:
88.                 sys.exit(0)
90.             try:
91.                 int(cmd, srcRadix)
92.                 srcStr = cmd
93.                 destStr = convertRadix(srcStr, srcRadix, destRadix)
94.                 println("        ( " + srcStr + " )_" + str(srcRadix) +  "   --->   ( " + destStr + " )_" + str(destRadix))
95.                 println("")
96.             except ValueError:
97.                  pass
98.     except RuntimeError:
99.         print sys.exc_value
101. def doStart():
102.     line = ""
103.     cmd = ""
104.     srcRadix = 10
105.     destRadix = 10
106.     srcStr = ""
107.     destStr = ""
108.     onlyOnce = True
110.     try:
111.         while True:
112.             println()
113.             if onlyOnce:
114.                 println("  The supported maximum radix is 36.")
115.                 onlyOnce = False
117.             printMainMenu()
118.             printMainPrompt()
119.             cmd = raw_input()
120.             while cmd == None:
121.                 cmd = raw_input()
123.             if "qQxX".find(cmd) >= 0 and len(cmd) == 1:
124.                 sys.exit(0)
125.             elif "aA".find(cmd) >= 0 and len(cmd) == 1:
126.                 printAbout()
127.             elif "sS".find(cmd) >= 0 and len(cmd) == 1:
128.                 line = raw_input("  Input the source and target radices (say, 16 2): ")
129.                 st = line.split(" ")
130.                 while len(st) < 2:
131.                     line = raw_input("  Input the source and target radices (say, 16 2): ")
132.                     st = line.split(" ")
134.                 srcRadix = int(st[0])
135.                 destRadix = int(st[1])
136.                 doConvert(srcRadix, destRadix)
137.     except RuntimeError:
138.         print sys.exc_value
141. # Begin here
142. if len(sys.argv) > 1 and "-h" == sys.argv[1]:
143.     printUsage()
144.     sys.exit(1)
146. doStart()

실행> python convertRadix.py

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 10 8

    Convert Radix_10 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 200
        ( 200 )_10   --->   ( 310 )_8

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> S
  Input the source and target radices (say, 16 2): 8 10

    Convert Radix_8 to Radix_10
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 2666
        ( 2666 )_8   --->   ( 1462 )_10

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> x




IronPython의 경우에는 구문

    print 스트링,

이 Python과 달리 끝에 빈칸을 곧 바로 추가하지 않고, 빈칸 출력을 유보하고 있다가 다음 print 문을 만날 때 이 빈칸을 먼저 출력한 후 주어진 스트링을 출력한다. raw_input()과 함께 쓰일 때는 이 빈칸 하나 때문에 신경이 쓰이기도 한다. 그래서 프롬프트를 출력하는 함수를

def printMainPrompt(): 
     print("  Prompt> "),

def printSubPrompt(): 
     print("    Input Value>> "),

로 수정해야 한다.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Groovy 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Integer 클래스와 Long 클래스의 정적 메소드

         Integer.parseInt(String, int);
         Long.toString(long, int);

울 이용하였으며, 지원되는 진법은 2진법에서 36진법 까지이다.

1. /*
2.  *  Filename: convertRadix.groovy
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Execute: groovy convertRadix.groovy
6.  *
7.  *      Date:  2008/03/25
8.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9.  */
11. import java.io.*
13. def printUsage() {
14.     println("Usage: groovy convertRadix.groovy")
15.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
16. }
18. def printAbout() {
19.     println("    About: Convert radix in a interactive mode.")
20. }
22. def printMainMenu() {
23.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
24. }
26. def printMainPrompt() {
27.     print("  Prompt> ")
28. }
30. def printSubMenu(int srcRadix, int destRadix) {
31.     println("    Convert Radix_" + srcRadix + " to Radix_" + destRadix)
32.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
33. }
35. def printSubPrompt() {
36.     print("    Input Value>> ")
37. }
39. String convertRadix(String s,  int srcRdx, int destRdx) {
40.     long val
41.     String ret = ""
42.     try {
43.         val = Integer.parseInt(s, srcRdx)
44.         ret = Long.toString(val, destRdx)
45.         return ret.toUpperCase()
46.     }
47.     catch (NumberFormatException nfx) {
48.         println("    Error: " + nfx.getMessage() + " cantains some invalid character.")
49.         ret = "????"
50.     }
51.     finally {
52.       return ret.toUpperCase()
53.     }
54. }
56. def doConvert(BufferedReader r, int srcRadix, int destRadix) {
57.     def line
58.     def cmd
59.     def srcStr = "", destStr = ""
61.     println()
62.     printSubMenu(srcRadix, destRadix)
63.     try {
64.         while (true) {
65.             printSubPrompt()
66.             while ((cmd = r.readLine()) == null) {
67.             }
68.             if ("main()".equals(cmd)) {
69.                 return
70.             }
71.             else if ("exit()".equals(cmd) || "quit()".equals(cmd)) {
72.                 System.exit(0)
73.             }
75.             try {
76.                 Integer.parseInt(cmd, srcRadix)
77.                 srcStr = cmd
78.                 destStr = convertRadix(srcStr, srcRadix, destRadix)
79.                 println("        ( " + srcStr + " )_" + srcRadix +  "   --->   ( " + destStr + " )_" + destRadix)
80.                 println()
81.             }
82.             catch (NumberFormatException nfx) {
83.             }
84.         }
85.     }
86.     catch (IOException ex) {
87.         ex.printStackTrace()
88.     }
89. }
91. def doStart() {
92.     def line
93.     def cmd
94.     def srcRadix = 10, destRadix = 10
95.     def srcStr = "", destStr = ""
96.     boolean onlyOnce = true
98.     BufferedReader r = new BufferedReader(new InputStreamReader(System.in))
99.     try {
100.         while (true) {
101.             println()
102.             if (onlyOnce) {
103.                 println("  The supported maximum radix is 36.")
104.                 onlyOnce = false
105.             }
106.             printMainMenu()
107.             printMainPrompt()
108.             while ((cmd = r.readLine()) == null) {
109.             }
110.             if ("qQxX".contains(cmd) && cmd.length() == 1) {
111.                 System.exit(0)
112.             }
113.             else if ("aA".contains(cmd) && cmd.length() == 1) {
114.                 printAbout()
115.             }
116.             else if ("sS".contains(cmd) && cmd.length() == 1) {
117.                 print("  Input the source and target radices (say, 16 2): ")
118.                 line = r.readLine()
119.                 StringTokenizer st = new StringTokenizer(line, " ,\t")
120.                 while (st.countTokens() < 2) {
121.                     print("  Input the source and target radices (say, 16 2): ")
122.                     line = r.readLine()
123.                     st = new StringTokenizer(line, " ,\t");
124.                 }
125.                 srcRadix = Integer.parseInt(st.nextToken())
126.                 destRadix = Integer.parseInt(st.nextToken())
127.                 doConvert(r, srcRadix, destRadix)
128.             }
129.         }
130.     }
131.     catch (IOException ex) {
132.         ex.printStackTrace()
133.     }
134. }
136. // Begin here
137. if (args.length > 0 && "-h".equals(args[0])) {
138.     printUsage()
139.     System.exit(1)
140. }
142. doStart()

실행> groovy convertRadix.groovy

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 16 2

    Convert Radix_16 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1FF
        ( 1FF )_16   --->   ( 111111111 )_2

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> S
  Input the source and target radices (say, 16 2): 2 8

    Convert Radix_2 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1011001
        ( 1011001 )_2   --->   ( 131 )_8

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> x





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.