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

컴퓨터 프로그래밍에서 꼭 알아두어야 할 주요 진법은 당연히 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  |
+-------+-------+-------+-------+

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Go 언어 소스 코드이다.
메뉴는 주메뉴 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()의 소스가 자체 제작되어 포함되어 있다. 이를 이용하는 부분은 152~153째 줄에 있는 

         val = convertAtoI(s, srcRdx) 
         ret = convertItoA(val, destRdx)

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

1. /*
2.  *  Filename: convertRadix.go
3.  *
4.  *            Convert radix in a interactive mode.
5.  *
6.  *  Execute: go run convertRadix.go
7.  *
8.  *  or
9.  *
10.  *  Compile: go build convertRadix.go
11.  *  Execute: ./convertRadix
12.  *
13.  *      Date:  2012/06/25
14.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
15.  */
17. package main
19. import (
20.     "fmt"
21.     "bufio"
22.     "os"
23.     "strings"
24. )   
26. type _TOKEN struct {
27.     a string
28.     b string
29. }
31. func println(s string) {
32.     fmt.Printf("%s\n", s)
33. }
35. func print(s string) { 
36.     fmt.Printf("%s", s)
37. }
39. func printUsage() {
40.     println("Usage: convertRadix")
41.     println("Convert radix in an interactive mode, where the maximum radix is 36.")
42. }
44. func printAbout() {
45.     println("    About: Convert radix in a interactive mode.")
46. }
48. func printMainMenu() {
49.     println("  Command: (S)etup radix, (A)bout, (Q)uit or E(x)it")
50. }
52. func printMainPrompt() {
53.     print("  Prompt> ")
54. }
56. func printSubMenu(srcRadix int, destRadix int) {
57.     var sbuf string
58.     fmt.Sprintf(sbuf, "    Convert Radix_%d to Radix_%d", srcRadix, destRadix);
59.     println(sbuf);
60.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit");
61. }
63. func printSubPrompt() {
64.     print("    Input Value>> ");
65. }
67. func convertItoA(num int64, radix int) (ret string) {
68.     var BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
69.     var tmp string
70.     var arr string
71.     var q, r int64
72.     var i, n int
73.     var isNegative bool = false
75.     if num < 0 {
76.         isNegative = true
77.         num = -num
78.     }
80.     arr = ""
81.     q = num
82.     r = 0
84.     for q >= int64(radix) {
85.         r = q % int64(radix)
86.         q = q / int64(radix)
87.         tmp = BASE36[r:r+1]
88.         arr += tmp
89.     }
91.     tmp = BASE36[q:q+1]
92.     arr += tmp
93.     if isNegative {
94.         arr += "-"
95.     }
97.     n = len(arr)
98.     for i = 0; i < n; i++ {
99.         ret += arr[n - i - 1:n-i]
100.     }
101.     return ret
102. }
104. func convertAtoI(str string, radix int) (ret int64) {
105.     var isNegative bool = false
106.     var len int = len(str)
107.     var c byte
108.     var i int
109.     var val int64
111.     c = str[0]
112.     if c == '-' {
113.         isNegative = true
114.     } else if c >= '0' && c <= '9' {
115.         ret = int64(c) - int64('0')
116.     } else if c >= 'A' && c <= 'Z' {
117.         ret = int64(c - 'A') + 10
118.     } else if c >= 'a' && c <= 'z' {
119.         ret = int64(c - 'a') + 10
120.     }
121.     if ret >= int64(radix) {
122.         println("        Invalid character!")
123.         return ret
124.     }
126.     for i = 1; i < len; i++ {
127.         c = str[i]
128.         ret *= int64(radix)
129.         if c >= '0' && c <= '9' {
130.             val = int64(c - '0')
131.         } else if c >= 'A' && c <= 'Z' {
132.             val = int64(c - 'A') + 10
133.         } else if c >= 'a' && c <= 'z' {
134.             val = int64(c - 'a') + 10
135.         }
136.         if val >= int64(radix) {
137.             println("        Invalid character!")
138.             return ret
139.         }
140.         ret += val
141.     }
143.     if isNegative {
144.         ret = -ret
145.     }
147.     return ret
148. }
150. func convertRadix(s string, srcRdx  int, destRdx int) (ret string) {
151.     var val int64
152.     val = convertAtoI(s, srcRdx)
153.     ret = convertItoA(val, destRdx)
154.     return ret
155. }
157. func readLine() (data string) {
158.     fmt.Scanf(data, "%s") //
159.     return data
160. }
162. func readTwo() (token _TOKEN) { 
163.     token.a = ""
164.     token.b = ""
165.     fmt.Scanf("%s %s", &token.a, &token.b)    // call twice, is It a bug?
166.     fmt.Scanf("%s %s", &token.a, &token.b)    // call twice, is It a bug?
167.     return token
168. }
170. func tokenize(ptoken _TOKEN, line string, c byte) {
171.     var i int
172.     var from, to int
174.     i = 0
175.     for line[i] != c {
176.         i += 1
177.     }
178.     from = i
179.     for line[i] == c {
180.         i += 1
181.     }
182.     to = i
183.     ptoken.a = line[0: to - from]
185.     for line[i] != c {
186.         i += 1
187.     }
188.     from = i
189.     for line[i] == c {
190.         i += 1
191.     }
192.     to = i
193.     ptoken.b = line[0: to - from]
194. }
196. func doConvert(srcRadix int,destRadix int) {
197.     var sbuf string
198.     var cmd string
199.     var srcStr string
200.     var destStr string
202.     println("")
203.     printSubMenu(srcRadix, destRadix)
205.     for {
206.         printSubPrompt()
207.         cmd = ""
208.         fmt.Scanf("%s", &cmd)        // call twice, is It a bug?
209.         for cmd == "" {
210.             fmt.Scanf("%s", &cmd)       // call twice, is It a bug?
211.         }
212.         if cmd == "main()" {
213.             return
214.         } else if cmd == "exit()" || cmd == "quit()" {
215.             os.Exit(0)
216.         } '
218.         srcStr = cmd
219.         destStr = convertRadix(srcStr, srcRadix, destRadix)
220.         sbuf = fmt.Sprintf("        ( %s )_%d   --->   ( %s )_%d", srcStr, srcRadix, destStr, destRadix);
221.         println(sbuf)
222.         println("")
223.     }
224. }
226. func doStart() { 
227.     var srcRadix int = 10
228.     var destRadix int = 10 
229.     var st _TOKEN
230.     var onlyOnce bool = true
232.     for {
233.         println("")
234.         if onlyOnce {
235.             println("  The supported maximum radix is 36.")
236.             onlyOnce = false
237.         }
239.         printMainMenu()
240.         printMainPrompt()
241.         var cmd string = ""
242.         fmt.Scanf("%s", &cmd)    // call twice, is It a bug?
243.         fmt.Scanf("%s", &cmd)    // call twice, is It a bug?
245.         if  len(cmd) == 1&& strings.IndexAny("qQxX", cmd) >= 0 {
246.             os.Exit(0)
247.         }  else if len(cmd) == 1&& strings.IndexAny("aA", cmd) >= 0 {
248.             printAbout()
249.         }  else if len(cmd) == 1&& strings.IndexAny("sS", cmd) >= 0 {
250.             print("  Input the source and target radices (say, 16 2): ") 
251.             st = readTwo()
252.             srcRadix = int(convertAtoI(st.a, 10))
253.             destRadix = int(convertAtoI(st.b, 10))
254.             doConvert(srcRadix, destRadix)
255.         }
256.     }
257. }
259. func waitCommand(str string) string {
260.         print(str)
261.         reader := bufio.NewReader(os.Stdin)
262.         input, _ := reader.ReadString('\n')
263.         if len(input) > 0 && input[len(input) -1] == '\n' {
264.             input = input[0:len(input) -1]
265.         }
266.         if len(input) > 0 && input[len(input) -1] == '\r' {
267.             input = input[0:len(input) -1]
268.         }
269.         return input
270. }
272. func main() {
273.     if len(os.Args) > 1 &&  os.Args[1] == "-h" {
274.         printUsage()
275.         return
276.     }
277.     doStart()
278. }

실행> go run convertRadix.go

또는

컴파일> go build convertRadix.go
실행> ./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()

다음은  이차방정식 x^2 - x - 1 = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 Go 애플리케이션 소스이다. 황금비율을 구하는 비례방정식은 1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1 = 0 이다.

See:  Golden ratio - Sajun.org

* Go 프로그램 소스는 (한글이 주석에만 포함되어 있더러도) UTF-8 인코딩으로 저장해야 한다.

1. /*
2.  *  Filename: testGoldenRatio.go
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Execute: go run testGoldenRatio.go
6.  *
7.  *   or
8.  *
9.  *   Compile: go build testGoldenRatio.go
10.  *   Execute: ./testGoldenRatio
11.  *
12.  *      Date:  2012/06/20
13.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
14.  */
16. package main
18. import (
19.     "fmt"
20.     "os"
21.     "math"
22. )
24. type PAIR struct {
25.     x1 float64
26.     x2 float64
27. }
29. func printUsing() {
30.     fmt.Printf("Using: testGoldenRatio [-h|-help]\n")
31.     fmt.Printf("This calculates the value of the golden ratio.\n")
32. }
34. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
35. func findQuadraticRoot(a float64, b float64, c float64) (zeros PAIR) {
36.     if a == 0.0 {
37.         fmt.Printf("Since the highest coefficient is zero, the given equation is not a quadratic equation.\n")
38.         return
39.     } else if b*b - 4*a*c < 0.0 {
40.         fmt.Printf("Since the discriminant %f is negative, the given equation has no real root.\b", b*b - 4*a*c)
41.         return
42.     }
44.     zeros.x1 = (-b + math.Sqrt(b*b - 4*a*c)) / (2.0 * a)
45.     zeros.x2 = (-b - math.Sqrt(b*b - 4*a*c)) / (2.0 * a)
46.     return
47. }
49. func main() {
50.     var x1, x2 float64
51.     if len(os.Args) > 1 && (os.Args[1] == "-h" || os.Args[1] == "-help") {
52.         printUsing()
53.         return
54.     }
56.    var  values = findQuadraticRoot(1.0, -1.0, -1.0)
57.     x1 = values.x1
58.     x2 = values.x2
60.     if x1 >= x2 {
61.         fmt.Printf("The bigger root is %f, \n", x1);
62.         fmt.Printf("and the less root is %f.\n", x2);
63.     } else {
64.         fmt.Printf("The bigger root is %f, \n", x2);
65.         fmt.Printf("and the less root is %f.\n", x1);
66.     }
67. }

컴파일> go build testGoldenRatio.go

실행> ./testGoldenRatio
The bigger root is 1.618034,
and the less root is -0.618034.


go run 명령을 이용하면 소스 코드를 직접 실행시킬 수 있다.

실행> go run testGoldenRatio.go
The bigger root is 1.618034,
and the less root is -0.618034.

아래의 소스 testBigInt.go 는 GMP 사용 예제 for C 의 testGMP.c 를 Go 언어 용으로 수정한 것이다.

Go 언어는 (C 언어와 달리) 긴 자리 정수 타입을 빌트인 패키지로 내장하고 있다. 긴 자리 정수 타입을 사용하기 위해서는 (소스 파일의 선두에) "math/big" 패키지를 미리 임포트(수입)해야 한다.

1. /*
2.  *  Filename: testBigInt.go
3.  *
4.  *   Compile: go build testBigInt.go
5.  *   Execute: ./testBigInt
6.  *
7.  *  or
8.  *
9.  *   Execute without compiling: go run testBigInt.go
10.  *
11.  *    Output: 2470450
12.  */
14. package main
16. import (
17.     "fmt"
18.     "math/big"
19. )   
21. func foo(param *big.Int, n int64) *big.Int{
22.     var i int64
23.     var r *big.Int = big.NewInt(1)
25.     r.Mul(param, big.NewInt(n))
26.     for i = 1; i < n; i++ { 
27.         r.Add(r, big.NewInt(i*7))
28.     }
29.     return r
30. }
32. func main() {
33.     var r *big.Int;
34.     /// var n *big.Int = big.NewInt(123456)
35.     var n *big.Int = big.NewInt(1)
36.     n.SetInt64(123456)
37.     r = foo(n, 20)
38.     fmt.Printf("%s\n", r)
39. }

실행> go run testBigInt,go
2470450


컴파일> go build testBigInt.go
실행> ./testBigInt
2470450

현재 시각을 컨솔에 보여주는 간단한 애플리케이션의 Go 언어 소스 코드이다.
UTC란 1970년 1월 1일 0시 0분 0초를 기준으로 하여 경과된 초 단위의 총 시간을 의미한다.
* UTC(Universal Time  Coordinated, 협정세계시, 協定世界時)

1. /*
2.  *  Filename: testCTime.go
3.  *
4.  *  Compile:  go build  testCTime.go
5.  *  Execute:  ./testCTime
6.  *
7.  *  Execute without compiling:  go run  testCTime.go
8.  *
9.  *  Date:  2012. 6. 18.
10.  */
12. package main
14. import (
15.     "fmt"
16.     "time"
17.     "math"
18. )
20. func main() {
21.     var weekNames []string = []string {  "일", "월", "화", "수", "목", "금", "토" };     // Hangul
22.     // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
23.     t1 := time.Now()
24.     fmt.Printf("UTC: %d초\n", t1.Unix())   // Hangul
25.     /// fmt.Printf("UTC: %dsec\n", t1.Unix())      // Engliish
27.     // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
28.     fmt.Printf("%d년 %d월 %d일 (%s요일) ", t1.Year(), t1.Month(), t1.Day(), weekNames[t1.Weekday()]);     // Hangul
29.     fmt.Printf("%d시 %d분 %d초\n", t1.Hour(), t1.Minute(), t1.Second());    // Hangul
30.     /// fmt.Printf("%04d-%02d-%02d (%s) ", t1.Year(), t1.Month(), t1.Day(), t1.Weekday());     // English
31.     /// fmt.Printf("%02d:%02d:%02d\n", t1.Hour(), t1.Minute(), t1.Second());     // English
33.     var y1 = t1.Year()
34.     var t2 = time.Date(y1,1,1,0,0,0, 0, t1.Location());
35.     var dAfter int = int(math.Floor(t1.Sub(t2).Hours()/24.0)) + 1
36.     fmt.Printf("올해 몇 번째 날: %d\n", dAfter);     // Hangul
37.     /// fmt.Printf("Today is the %d-th day in this year.\n", dAfter);     // English
38. }

컴파일> go build testCTime.go

실행> ./testCTime
UTC: 1339945637초
2012년 6월 18일 (월요일) 0시 7분 217초
올해 몇 번째 날: 170

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을 Go 언어로 구현해 보았다. 조립제법(synthetic division)은 일명 Horner의 방법이라고도 불리우는데, 이는
다항식 p(x)의 x = a 일 때의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

         p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
    * 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표 
    * 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수


아래의 소스파일은 go run 명령을 사용하면 컴파일 과정 없이 그대로 실행된다.
(실행 예:  go run testSyntheticDivision.go 1 2 3 4 5  )

1. /*
2.  *  Filename: testSyntheticDivision.go
3.  *
4.  *  Purpose:  Find the quotient and remainder when some polynomial is
5.  *            divided by a monic linear polynomial.
6.  *
7.  *  Execute:  go run testSyntheticDivision.go -2 1 3 3 1
8.  *
9.  *  or
10.  *
11.  *  Compile:  go build testSyntheticDivision.go
12.  *  Execute:  ./testSyntheticDivision -2 1 3 3 1
13.  */
15. package main
17. import (
18.     "fmt"
19.     "os"
20.     "strconv"
21.     "math"
22. )
24. func print(str string) {
25.     fmt.Printf("%s", str);
26. }
28. func println(str string) {
29.     fmt.Printf("%s\n", str);
30. }
32. // 사용법 표시
33. func printUsage() {
34.      /// println("사용법: testSyntheticDivision [수] [피제식의 계수들]");
35.      /// println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
36.      println("Usage: testSyntheticDivision [number] [coefficients of dividend]");
37.      println("Show the result of synthetic division.");
38. }
40. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
41. // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
42. func simplify(v float64, width int) string {
43.     var n int
44.     var slen int
45.     var t string = "                               ";
46.     var tmp string = "                               ";
47.     t = fmt.Sprintf("%g", v);
48.     n = len(t);
49.     if (n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0') {
50.         t = t[0:n-2]
51.     }
52.     slen = len(t);
53.     tmp =  t
54.     if (slen < width) {
55.         t = "               "
56.         t = t[0:width - slen]
57.         t = t + tmp
58.     }
59.     return t
60. }
62. // 다항식을 내림차순의 문자열로로 반환하는 함수
63. func toPolyString(c []float64, size int) string {
64.     var SIZE int = size;
65.     var i int;
66.     var t string = ""
67.     var tmp string
68.     var pc string = simplify(c[0], -1);
69.     var pci string
71.     if SIZE > 2 {
            if (len(pc) == 1 && pc[0] == '1') {
72.             t = fmt.Sprintf("x^%d", SIZE - 1);
73.         } else if (len(pc) == 2 && pc[0] == '-' && pc[1] == '1') {
74.             t = fmt.Sprintf("-x^%d", SIZE - 1);
75.         } else {
76.             t = fmt.Sprintf("%s x^%d", simplify(c[0], -1), SIZE - 1);
77.         }
78.     } else if SIZE == 2 {
79.         if (len(pc) == 1 && pc[0] == '1') {
80.             t = "x"
81.         } else if (len(pc) == 2 && pc[0] == '-' && pc[1] == '1') {
82.             t = "-x"
83.         } else {
84.             t = fmt.Sprintf("%s x", simplify(c[0], -1));
85.         }
86.     } else if SIZE == 1 {
87.         t = fmt.Sprintf("%s", simplify(c[0], -1));
88.     }
90.     for i = 1; i < SIZE; i++ {
91.         pci = simplify(c[i], -1);
92.         if SIZE - 1 - i > 1 {
93.             if c[i] > 0.0 {
94.                 if len(pci) == 1 && pci[0] == '1' {
95.                     tmp = fmt.Sprintf(" + x^%d", SIZE - 1 - i);
96.                     t += tmp
97.                 } else {
98.                     tmp = fmt.Sprintf(" + %s x^%d", simplify(c[i], -1), SIZE - 1 - i);
99.                     t += tmp
100.                 }
101.             } else if c[i] < 0.0 {
102.                 if len(pci) == 2 && pci[0] == '-' && pci[1] == '1' {
103.                     tmp = fmt.Sprintf(" - x^%d", SIZE - 1 - i);
104.                     t += tmp
105.                 } else {
106.                     tmp = fmt.Sprintf(" - %s x^%d", simplify(math.Abs(c[i]), -1), SIZE - 1 - i);
107.                     t += tmp
108.                 }
109.             }
110.         } else if SIZE - 1 - i == 1 {
111.             if c[i] > 0.0 {
112.                 if len(pci) == 1 && pci[0] == '1' {
113.                     t += " + x"
114.                 } else {
115.                     tmp = fmt.Sprintf(" + %s x", simplify(c[i], -1));
116.                     t += tmp
117.                 }
118.             } else if c[i] < 0.0 {
119.                 if len(pci) == 2 && pci[0] == '-' && pci[1] == '1' {
120.                     t += " - x"
121.                 } else {
122.                     tmp = fmt.Sprintf(" - %s x", simplify(math.Abs(c[i]), -1));
123.                     t += tmp
124.                 }
125.             }
126.         } else if SIZE - 1 - i == 0 {
127.             if c[i] > 0.0 {
128.                 tmp = fmt.Sprintf(" + %s", simplify(c[i], -1));
129.                 t += tmp
130.             } else if (c[i] < 0.0) {
131.                 tmp = fmt.Sprintf(" - %s", simplify(math.Abs(c[i]), -1));
132.                 t += tmp
133.             }
134.         }
135.     }
136.     return t
137. }
139. // 다향식 나눗셈 결과를
140. //     (피제식) = (제식)(몫) + (나마지)
141. // 형태로 출력
142. func printDivisionResult(a float64, c []float64, b []float64, size int) {
143.     var SIZE int = size;
144.     var i int
145.     var r float64
146.     var monic []float64 = []float64 { 1.0, 0.0 };
148.     print("  ");
149.     print(toPolyString(c, SIZE));
150.     println("");
151.     print("    = ( ");
152.     monic[1] = -a;
153.     print(toPolyString(  monic, 2 ));
154.     print(" )")
156.     var pTmpPoly []float64 = make([]float64, SIZE);
157.     for i = 0; i < SIZE - 1; i++ {
158.         pTmpPoly[i] = b[i];
159.     }
160.     print("( ");
161.     print(toPolyString(pTmpPoly, SIZE - 1));
162.     print(" )");
164.     r = b[SIZE - 1];
165.     if r > 0.0 {
166.         print(" + ");
167.         print(simplify(r, -1));
168.     } else if (r < 0.0) {
169.         print(" - ");
170.         print(simplify(math.Abs(r), -1));
171.     }
172.     println("");
173. }
175. // 조립제법 계산표 출력 함수
176. func printSyntheticTable(a float64, c []float64, s []float64, q []float64, size int) {
177.     var SIZE int = size;
178.     var i int
179.     print("       | ");
180.     print(simplify(c[0], 6));
181.     for i = 1; i < SIZE; i++ {
182.         print("  ");
183.         print(simplify(c[i], 6));
184.     }
185.     println("");
187.     print(simplify(a, 6));
188.     print(" | "); 
189.    print("        ");
190.     print(simplify(s[1], 6));
191.     for i = 2; i < SIZE; i++ {
192.         print("  ");
193.         print(simplify(s[i], 6));
194.     }
195.     println("");
197.     print("       |-");
198.     for i = 0; i < SIZE; i++ {
199.         print("--------");
200.     }
201.     println("");
203.     print("         ");
204.     print(simplify(q[0], 6));
205.     for i = 1; i < SIZE; i++ {
206.         print("  ");
207.         print(simplify(q[i], 6));
208.     }
209.     println("");
210. }
212. // Go 언어 프로그램의 실행 시작 지점
213. func main() {
214.     var i int
215.     var SIZE = len(os.Args) - 2
216.     var a float64
217.     var c []float64 = make([]float64, SIZE + 2)
218.     var s []float64 = make([]float64, SIZE + 2)
219.     var b []float64 = make([]float64, SIZE + 2)
221.     if len(os.Args) < 4 {
222.         printUsage()
223.         return
224.     }
226.     //////////////////////////////////////////////////////
227.     // 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
228.     // 제식은 x -  a
229.     a, _ = strconv.ParseFloat(os.Args[1], 64)
231.     for i = 0; i < SIZE; i++ {
232.         c[i], _ = strconv.ParseFloat(os.Args[i + 2], 64)
233.     }
235.     //////////////////////////////////////////////////////
236.     // 조립제법의 주요 부분
237.     s[0] = 0.0;
238.     b[0] = c[0];
239.     for i = 1; i < SIZE; i++ {
240.         s[i] = b[i-1]*a;
241.         b[i] = c[i] + s[i];
242.     }
244.     //////////////////////////////////////////////////////
245.     // 몫의 계수와 나머지를 출력한다.
246.     /// print("몫의 계수는 ");
247.     print("The coefficients of the quotient are ");
248.     for i = 0; i < SIZE - 2; i++ {
249.         print(simplify(b[i], -1));
250.         print(", ");
251.     }
253.     print(simplify(b[SIZE - 2], -1));
254.     // print(" 이고, 나머지는 ");
255.     print("\nand the remainder is ");
256.     print(simplify(b[SIZE - 1], -1));
257.     /// println(" 이다.");
258.     println(".");
259.     println("");
261.     //////////////////////////////////////////////////////
262.     // 조립제법 표를 출력한다.
263.     printSyntheticTable(a, c, s, b, SIZE);
264.     println("");
266.     //////////////////////////////////////////////////////
267.     // (피제식) = (제식) x (몫) + (나머지)
268.     printDivisionResult(a, c, b, SIZE);
269. }

실행> go run testSyntheticDivision.go 1 2 3 4 5
The coefficients of the quotient are 2, 5, 9
and the remainder is 14.

       |      2       3       4       5
     1 |              2       5       9
       |---------------------------------
              2       5       9      14

  2 x^3 + 3 x^2 + 4 x + 5
    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

또는

컴파일> go build testSyntheticDivision.go

실행> ./testSyntheticDivision 1 2 3 4 5
The coefficients of the quotient are 2, 5, 9
and the remainder is 14.

       |      2       3       4       5
     1 |              2       5       9
       |---------------------------------
              2       5       9      14

  2 x^3 + 3 x^2 + 4 x + 5
    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

다음은 C 언어로 작성된 소스파일 testForFor.c(참조: 80컬럼 컨솔에 19단표 출력하기 예제 for C and Ch)를 Go 언어용으로 고친 것이다.
(* 한글이 있는 Go 소스파일은 UTF8 인코딩으로 저장해야 한다.)

1. /*
2.  *  Filename: testForFor.go
3.  *
4.  *  Compile:  go build  testForFor.go
5.  *  Execute:  testForFor
6.  *
7.  *  Execute without compiling:  go run  testForFor.go
8.  *
9.  *  Date:  2012. 6. 16.
10.  */
12. package main
14. import (
15.     "fmt"
16. )
18. // dan으로 전달된 (구구단의) 한 단의 출력할 내용을
19. // 스트링으로 만들어 반환하는 함수
20. func getDan(dan int32) [19]string {
21.     var sa string
22.     var sb string
23.     var sval string
24.     var j int32
25.     var t [19] string;
27.     for j = 0; j < 19; j++ {
28.         sa = fmt.Sprintf("%d", dan);
29.         if len(sa) < 2 {
30.             sa = fmt.Sprintf(" %d", dan);
31.         }
32.         sb = fmt.Sprintf("%d", j + 1);
33.         if len(sb) < 2 {
34.             sb = fmt.Sprintf(" %d", j + 1);
35.         }
36.         sval = fmt.Sprintf("%d", dan*(j + 1));
37.         if len(sval) < 2 {
38.             sval = fmt.Sprintf("  %d", dan*(j + 1));
39.         } else if len(sval) < 3  {
40.             sval = fmt.Sprintf(" %d", dan*(j + 1));
41.         }
42.         t[j] =  sa + " x " + sb + " = " + sval
43.     }
44.     return t
45. }
47. // 19단표를 모두 80컬럼 컨솔에 출력한다.
48. func printAllNineteenDan() {
49.     var d [] int32 = [] int32 {  2, 7, 11, 16 };      // 각 줄단위 블럭의 첫단
50.     var counter [] int32 = [] int32 { 5, 4, 5, 4 };  // 각 줄단위 블럭에 속한 단의 개수
51.     var lines[19] string;
52.     var v [19]string;
53.     var i int32
54.     var j int32
55.     var k int32
56.     var arr [18][19]string;
58.     for i = 2; i < 20; i++ {
59.         v = getDan(i)
60.         for j = 0; j < 19; j++ {
61.             arr[i - 2][j] = v[j]
62.         }
63.     } 
65.     for k = 0; k < 4; k++ {
66.         // 80 바이트 길이의 한 줄씩 완성
67.         for i = 0; i < 19; i++ {
68.             lines[i] = arr[d[k]-2][i]
69.             for j = 1; j < counter[k]; j++ {
70.                 lines[i] += "   " + arr[d[k]-2+j][i]
71.             }
72.         }
73.         // 80 바이트 길이의 한 줄씩 출력
74.         for i = 0; i < 19; i++ {
75.             fmt.Printf("%s\n", lines[i]);
76.         }
77.         fmt.Printf("\n");
78.     }
79.     fmt.Printf("\n");
80. }
82. // Go 언어의 main 함수 : 실행 시작 지점
83. func main() {
84.     printAllNineteenDan();    // 객체에 속하는 메소드 printDan()을 호출한다.
85. }

실행> go run testForFor.go 
 
또는

컴파일> go build testForFor.go
실행> ./testForFor

 2 x  1 =   2    3 x  1 =   3    4 x  1 =   4    5 x  1 =   5    6 x  1 =   6
 2 x  2 =   4    3 x  2 =   6    4 x  2 =   8    5 x  2 =  10    6 x  2 =  12
 2 x  3 =   6    3 x  3 =   9    4 x  3 =  12    5 x  3 =  15    6 x  3 =  18
 2 x  4 =   8    3 x  4 =  12    4 x  4 =  16    5 x  4 =  20    6 x  4 =  24
 2 x  5 =  10    3 x  5 =  15    4 x  5 =  20    5 x  5 =  25    6 x  5 =  30
 2 x  6 =  12    3 x  6 =  18    4 x  6 =  24    5 x  6 =  30    6 x  6 =  36
 2 x  7 =  14    3 x  7 =  21    4 x  7 =  28    5 x  7 =  35    6 x  7 =  42
 2 x  8 =  16    3 x  8 =  24    4 x  8 =  32    5 x  8 =  40    6 x  8 =  48
 2 x  9 =  18    3 x  9 =  27    4 x  9 =  36    5 x  9 =  45    6 x  9 =  54
 2 x 10 =  20    3 x 10 =  30    4 x 10 =  40    5 x 10 =  50    6 x 10 =  60
 2 x 11 =  22    3 x 11 =  33    4 x 11 =  44    5 x 11 =  55    6 x 11 =  66
 2 x 12 =  24    3 x 12 =  36    4 x 12 =  48    5 x 12 =  60    6 x 12 =  72
 2 x 13 =  26    3 x 13 =  39    4 x 13 =  52    5 x 13 =  65    6 x 13 =  78
 2 x 14 =  28    3 x 14 =  42    4 x 14 =  56    5 x 14 =  70    6 x 14 =  84
 2 x 15 =  30    3 x 15 =  45    4 x 15 =  60    5 x 15 =  75    6 x 15 =  90
 2 x 16 =  32    3 x 16 =  48    4 x 16 =  64    5 x 16 =  80    6 x 16 =  96
 2 x 17 =  34    3 x 17 =  51    4 x 17 =  68    5 x 17 =  85    6 x 17 = 102
 2 x 18 =  36    3 x 18 =  54    4 x 18 =  72    5 x 18 =  90    6 x 18 = 108
 2 x 19 =  38    3 x 19 =  57    4 x 19 =  76    5 x 19 =  95    6 x 19 = 114

 7 x  1 =   7    8 x  1 =   8    9 x  1 =   9   10 x  1 =  10
 7 x  2 =  14    8 x  2 =  16    9 x  2 =  18   10 x  2 =  20
 7 x  3 =  21    8 x  3 =  24    9 x  3 =  27   10 x  3 =  30
 7 x  4 =  28    8 x  4 =  32    9 x  4 =  36   10 x  4 =  40
 7 x  5 =  35    8 x  5 =  40    9 x  5 =  45   10 x  5 =  50
 7 x  6 =  42    8 x  6 =  48    9 x  6 =  54   10 x  6 =  60
 7 x  7 =  49    8 x  7 =  56    9 x  7 =  63   10 x  7 =  70
 7 x  8 =  56    8 x  8 =  64    9 x  8 =  72   10 x  8 =  80
 7 x  9 =  63    8 x  9 =  72    9 x  9 =  81   10 x  9 =  90
 7 x 10 =  70    8 x 10 =  80    9 x 10 =  90   10 x 10 = 100
 7 x 11 =  77    8 x 11 =  88    9 x 11 =  99   10 x 11 = 110
 7 x 12 =  84    8 x 12 =  96    9 x 12 = 108   10 x 12 = 120
 7 x 13 =  91    8 x 13 = 104    9 x 13 = 117   10 x 13 = 130
 7 x 14 =  98    8 x 14 = 112    9 x 14 = 126   10 x 14 = 140
 7 x 15 = 105    8 x 15 = 120    9 x 15 = 135   10 x 15 = 150
 7 x 16 = 112    8 x 16 = 128    9 x 16 = 144   10 x 16 = 160
 7 x 17 = 119    8 x 17 = 136    9 x 17 = 153   10 x 17 = 170
 7 x 18 = 126    8 x 18 = 144    9 x 18 = 162   10 x 18 = 180
 7 x 19 = 133    8 x 19 = 152    9 x 19 = 171   10 x 19 = 190

11 x  1 =  11   12 x  1 =  12   13 x  1 =  13   14 x  1 =  14   15 x  1 =  15
11 x  2 =  22   12 x  2 =  24   13 x  2 =  26   14 x  2 =  28   15 x  2 =  30
11 x  3 =  33   12 x  3 =  36   13 x  3 =  39   14 x  3 =  42   15 x  3 =  45
11 x  4 =  44   12 x  4 =  48   13 x  4 =  52   14 x  4 =  56   15 x  4 =  60
11 x  5 =  55   12 x  5 =  60   13 x  5 =  65   14 x  5 =  70   15 x  5 =  75
11 x  6 =  66   12 x  6 =  72   13 x  6 =  78   14 x  6 =  84   15 x  6 =  90
11 x  7 =  77   12 x  7 =  84   13 x  7 =  91   14 x  7 =  98   15 x  7 = 105
11 x  8 =  88   12 x  8 =  96   13 x  8 = 104   14 x  8 = 112   15 x  8 = 120
11 x  9 =  99   12 x  9 = 108   13 x  9 = 117   14 x  9 = 126   15 x  9 = 135
11 x 10 = 110   12 x 10 = 120   13 x 10 = 130   14 x 10 = 140   15 x 10 = 150
11 x 11 = 121   12 x 11 = 132   13 x 11 = 143   14 x 11 = 154   15 x 11 = 165
11 x 12 = 132   12 x 12 = 144   13 x 12 = 156   14 x 12 = 168   15 x 12 = 180
11 x 13 = 143   12 x 13 = 156   13 x 13 = 169   14 x 13 = 182   15 x 13 = 195
11 x 14 = 154   12 x 14 = 168   13 x 14 = 182   14 x 14 = 196   15 x 14 = 210
11 x 15 = 165   12 x 15 = 180   13 x 15 = 195   14 x 15 = 210   15 x 15 = 225
11 x 16 = 176   12 x 16 = 192   13 x 16 = 208   14 x 16 = 224   15 x 16 = 240
11 x 17 = 187   12 x 17 = 204   13 x 17 = 221   14 x 17 = 238   15 x 17 = 255
11 x 18 = 198   12 x 18 = 216   13 x 18 = 234   14 x 18 = 252   15 x 18 = 270
11 x 19 = 209   12 x 19 = 228   13 x 19 = 247   14 x 19 = 266   15 x 19 = 285

16 x  1 =  16   17 x  1 =  17   18 x  1 =  18   19 x  1 =  19
16 x  2 =  32   17 x  2 =  34   18 x  2 =  36   19 x  2 =  38
16 x  3 =  48   17 x  3 =  51   18 x  3 =  54   19 x  3 =  57
16 x  4 =  64   17 x  4 =  68   18 x  4 =  72   19 x  4 =  76
16 x  5 =  80   17 x  5 =  85   18 x  5 =  90   19 x  5 =  95
16 x  6 =  96   17 x  6 = 102   18 x  6 = 108   19 x  6 = 114
16 x  7 = 112   17 x  7 = 119   18 x  7 = 126   19 x  7 = 133
16 x  8 = 128   17 x  8 = 136   18 x  8 = 144   19 x  8 = 152
16 x  9 = 144   17 x  9 = 153   18 x  9 = 162   19 x  9 = 171
16 x 10 = 160   17 x 10 = 170   18 x 10 = 180   19 x 10 = 190
16 x 11 = 176   17 x 11 = 187   18 x 11 = 198   19 x 11 = 209
16 x 12 = 192   17 x 12 = 204   18 x 12 = 216   19 x 12 = 228
16 x 13 = 208   17 x 13 = 221   18 x 13 = 234   19 x 13 = 247
16 x 14 = 224   17 x 14 = 238   18 x 14 = 252   19 x 14 = 266
16 x 15 = 240   17 x 15 = 255   18 x 15 = 270   19 x 15 = 285
16 x 16 = 256   17 x 16 = 272   18 x 16 = 288   19 x 16 = 304
16 x 17 = 272   17 x 17 = 289   18 x 17 = 306   19 x 17 = 323
16 x 18 = 288   17 x 18 = 306   18 x 18 = 324   19 x 18 = 342
16 x 19 = 304   17 x 19 = 323   18 x 19 = 342   19 x 19 = 361

Go 언어에는 while 반복문이 없으므로 for 반복문을 (while 반복문 처럼) 쓰면 된다.

소스 파일명: testWhile.go

1. // Filename: testWhile.go
2. //
3. // Execute: go run testWhile.go 625 1000
4. // or
5. // Compile: go build testWhile.go
6. // Execute: ./testWhile 625 1000
8. package main
10. import (
11.     "fmt"
12.     "os"
13.     "strconv"
14. )
16. // 사용법 표시 함수
17. func printUsing() {
18.     fmt.Printf("Using: testWhile [integer1] [integer2]\n");
19.     fmt.Printf("This finds the greatest common divisor of the given two integers.\n");
20. }
22. // main 함수
23. func main() {
24.     var val1 int64
25.     var val2 int64
26.     var a int64
27.     var b int64
28.     var gcd int64
30.     if len(os.Args) != 3 {
31.         printUsing();
32.         return
33.     }
35.     // 명령행 인자의 스트링을 가져와서
36.     // 64비트 정수로 변환하여
37.     // 변수 val1과 val2에 저장한다.
38.     val1, _ = strconv.ParseInt(os.Args[1], 10, 64);
39.     val2, _ = strconv.ParseInt(os.Args[2], 10, 64);
41.     a = val1
42.     if a < 0 {
43.         a = -a
44.     }
46.     b = val2;
47.     if b < 0 {
48.         b = -b
49.     }
51.     if a < b { 
52.         a, b = b, a
53.     }
55.     if b == 0 {
56.         fmt.Printf("GCD(%d, %d) = %d\n", val1, val2, a);
57.         return
58.     }
60.     // -------------------------------------------
61.     // Euclidean 알고리즘의 시작 
62.     // *  Go 언어에는 while 반복문이 없으므로 for 문을 사용한다.
63.     for a != 0 {
64.         b, a = a, b % a
65.     }
67.     // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
68.     gcd = b
70.     // 최대공약수(GCD)를 출력한다.
71.     fmt.Printf("GCD(%d, %d) = %d\n", val1, val2, gcd);
72. }

실행:

Command> go run testWhile.go
Using: testWhile [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

Command> go run testWhile 200 -300
GCD(200, -300) = 100

Command>go run  testWhile 0 -300
GCD(0, -300) = 300

Command> go run testWhile 20 -125
GCD(20, -125) = 5

Command> go run testWhile 121 66
GCD(121, 66) = 11

Command> testWhile -111 -37
GCD(-111, -37) = 37


컴파일:

Command> go build testWhile.go


실행:

Command> testWhile
Using: testWhile [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

Command> testWhile 200 -300
GCD(200, -300) = 100

Command> testWhile 0 -300
GCD(0, -300) = 300

Command> testWhile 20 -125
GCD(20, -125) = 5

Command> testWhile 121 66
GCD(121, 66) = 11

Command> testWhile -111 -37
GCD(-111, -37) = 37

소스 파일명: testIf.go

1. // Filename: testIf.go
2. //
3. // Execute: go run testIf.go -1.5
4. // or
5. // Compile: go build testIf.go
6. // Execute: ./testIf -1.5
8. package main
10. import (
11.     "fmt"
12.     "os"
13.     "strconv"
14. )
16. // 사용법 표시 함수
17. func printUsing() {
18.     fmt.Printf("Using: testIf [number]\n");
19.     fmt.Printf("This determines whether the number is positive or not.\n");
20. }
22. // main 함수
23. func main() {
24.     var val = 0.0
25.     if (len(os.Args) != 2) {
26.         printUsing();
27.         return
28.     }
30.     // 명령행 인자의 스트링을 가져와서
31.     // 배정밀도 부동소수점수로 변환하여
32.     // 변수 val에 저장한다.
33.     val, _ = strconv.ParseFloat(os.Args[1], 64);
35.     // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
36.     // 판단하는 if...else... 조건문
37.     if val > 0.0 {
38.         fmt.Printf("%g is a positive number.\n", val);
39.     } else if val < 0.0 {
40.         fmt.Printf("%g is a negative number.\n", val);
41.     } else  {
42.         fmt.Printf("%g is zero.\n", val);
43.     }
44. }

실행> go run testIf.go
Using: testIf [number]
This determines whether the number is positive or not.

실행> go run testIf.go 1.234
1.234 is a positive number.

실행> go run testIf.go -1.234
-1.234 is a negative number.

실행> go run testIf.go 0
0 is zero.

또는

컴파일> go build testIf.go

실행> testIf
Using: testIf [number]
This determines whether the number is positive or not.

실행> testIf 1.234
1.234 is a positive number.

실행> testIf -1.234
-1.234 is a negative number.

실행> testIf 0
0 is zero.

Go 소스 파일에 한글이 포함되어 있으면  UTF8 인코딩으로 저장해야 한다.

     소스 파일명: testArguments.go

1. // Filename: testArguments.go
2. //
3. // Execute: go run testArguments.go 1 2 3
4. // or
5. // Compile: go build testArguments.go
6. // Execute: ./testArguments 1 2 3
8. package main
10. import (
11.     "fmt"             // fmt.Printf 함수 사용을 위해
12.     "os"             // os.Args 사용을 위해
13.     "strconv"      // strconv.ParseFloat 함수 사용을 위해
14. )
16. func main() {
17.     var sum = 0.0;
18.     var y = 0.0
19.     for i, x := range os.Args {
20.         if i > 0 {
21.             // 스트링을 배정밀도 부동소수점수로 변환하여 변수 sum에 누적
22.             y, _ = strconv.ParseFloat(x, 64)
23.             // fmt.Printf("y = %f\n", y)
24.             sum += y
25.         }
26.     }
28.     // 명령행 인자(command-line argument) 개수 출력
29.     fmt.Printf("Count of arguments: %d\n", len(os.Args));
30.     // 부동소수점수 값을 %g로 출력
31.     fmt.Printf("The sum of arguments is %g\n", sum);
32. }
    

실행> go run testArguments.go 1 2 3 4
Count of arguments: 5
The sum of arguments is 10

실행> go run testArguments.go 1 2 3 4.2
Count of arguments: 5
The sum of arguments is 10.2

또는

컴파일> go build testArguments.go

실행> testArguments 1 2 3 4
Count of arguments: 5
The sum of arguments is 10

실행> testArguments 1 2 3 4.2
Count of arguments: 5
The sum of arguments is 10.2