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

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

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

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

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


아래의 소스파일은 C  언어용으로 민들어 두었던 소스 조립제법(Horner의 방법) 예제 for C and Ch 를 아주 조금 수정한 것이다. 수정한 부분은 #include를 #import로 바꾸고, 또

        #import  <Foundation/Foundation.h>

를 추가했을 뿐이다. 만일 Foundation.h 를 수입(import)하지 않으면, calloc, free, atof, exit 에러가 발생한다.

컴파일은 Dev-C++ 개발 도구에서 Ctrl+F11 을 클릭한다.

1. /*
2.  *  Filename: testSyntheticDivisionMain.m
3.  *
4.  *  Purpose:  Find the quotient and remainder when some polynomial is
5.  *            divided by a monic polynomial of the first degree.
6.  *
7.  *  Compile:  Click Ctr;+F11 on Dec-C++ 
8.  *
9.  *  Execute:  testSyntheticDivision -2 1 3 3 1
10.  */
12. #import <Foundation/Foundation.h>
13. #import <stdio.h>
14. #import <string.h>
15. #import <math.h>
16. #import <memory.h>
18. void print(char str[]) {
19.     printf("%s", str);
20. }
22. void println(char str[]) {
23.     printf("%s\n", str);
24. }
26. // 사용법 표시
27. void printUsage() {
28.      println("사용법: testSyntheticDivision [수] [피제식의 계수들]");
29.      println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
30. }
32. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
33. // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
34. char *simplify(double v, int width) {
35.     int n, len;
36.     static char t[] = "                               ";
37.     char tmp[] = "                               ";
38.     sprintf(t, "%g", v);
39.     n = strlen(t);
40.     if ((n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0'))
41.         t[n-2] = '\0';
42.     len = strlen(t);
43.     strcpy(tmp, t);
44.     if (len < width) {
45.         strncpy(t, "               ", width - len);
46.         t[width - len] = '\0';
47.         strcat(t, tmp);
48.     }
49.     return (char *) t;
50. }
52. // 다항식을 내림차순의 문자열로 반환하는 함수
53. // 반환된 문자열은 동적 메모리에 존재하므로.
54. // 사용 후 반드시 해제(free)하여야 한다.
55. char *toPolyString(double c[], int size) {
56.     int SIZE = size;
57.     int i;
58.     static char t[300];
59.     char tmp[80];
60.     char *pc = simplify(c[0], -1);
61.     char *pci;
62.     if (SIZE > 2) {
63.         if (strlen(pc) == 1 && pc[0] == '1')
64.             sprintf(t,  "x^%d", SIZE - 1);
65.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
66.             sprintf(t,  "-x^%d", SIZE - 1);
67.         else
68.             sprintf(t,  "%s x^%d", simplify(c[0], -1), SIZE - 1);
69.     }
70.     else if (SIZE == 2) {
71.         if (strlen(pc) == 1 && pc[0] == '1')
72.             strcpy(t,  "x");
73.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
74.             strcpy(t,  "-x");
75.         else
76.             sprintf(t,  "%s x", simplify(c[0], -1));
77.     }
78.     else if (SIZE == 1) {
79.         sprintf(t,  "%s", simplify(c[0], -1));
80.     }
82.     for (i = 1; i < SIZE; i++) {
83.         pci = simplify(c[i], -1);
84.         if (SIZE - 1 - i > 1) {
85.             if (c[i] > 0.0) {
86.                 if (strlen(pci) == 1 && pci[0] == '1') {
87.                     sprintf(tmp,  " + x^%d", SIZE - 1 - i);
88.                     strcat(t, tmp);
89.                 }
90.                 else {
91.                     sprintf(tmp,  " + %s x^%d", simplify(c[i], -1), SIZE - 1 - i);
92.                     strcat(t, tmp);
93.                 }
94.             }
95.             else if (c[i] < 0.0) {
96.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
97.                     sprintf(tmp,  " - x^%d", SIZE - 1 - i);
98.                     strcat(t, tmp);
99.                 }
100.                 else {
101.                     sprintf(tmp,  " - %s x^%d", simplify(fabs(c[i]), -1), SIZE - 1 - i);
102.                     strcat(t, tmp);
103.                 }
104.             }
105.         }
106.         else if (SIZE - 1 - i == 1) {
107.             if (c[i] > 0.0) {
108.                 if (strlen(pci) == 1 && pci[0] == '1') {
109.                     strcat(t, " + x");
110.                 }
111.                 else {
112.                     sprintf(tmp,  " + %s x", simplify(c[i], -1));
113.                     strcat(t, tmp);
114.                 }
115.             }
116.             else if (c[i] < 0.0) {
117.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
118.                     strcat(t, " - x");
119.                 }
120.                 else {
121.                     sprintf(tmp,  " - %s x", simplify(fabs(c[i]), -1));
122.                     strcat(t, tmp);
123.                 }
124.             }
125.         }
126.         else if (SIZE - 1 - i == 0) {
127.             if (c[i] > 0.0) {
128.                 sprintf(tmp,  " + %s", simplify(c[i], -1));
129.                 strcat(t, tmp);
130.             }
131.             else if (c[i] < 0.0) {
132.                 sprintf(tmp,  " - %s", simplify(fabs(c[i]), -1));
133.                 strcat(t, tmp);
134.             }
135.         }
136.     }
137.     return (char *) t;
138. }
140. // 다향식 나눗셈 결과를
141. //     (피제식) = (제식)(몫) + (나마지)
142. // 형태로 출력
143. void printDivisionResult(double a, double c[], double b[], int size) {
144.     int SIZE = size;
145.     int i;
146.     double *pTmpPoly;
147.     double r;
148.     double monic[] = { 1.0, 0.0 };
150.     print("  ");
151.     print(toPolyString(c, SIZE));
152.     println("");
154.     print("    = ( ");
155.     monic[1] = -a;
156.     print(toPolyString(  monic, 2 ));
157.     print(" )");
159.     pTmpPoly = (double *)  calloc(SIZE - 1, sizeof(double));
160.     for (i = 0; i < SIZE - 1; i++) {
161.         pTmpPoly[i] = b[i];
162.     }
163.     print("( ");
164.     print(toPolyString(pTmpPoly, SIZE - 1));
165.     print(" )");
166.     free(pTmpPoly);
168.     r = b[SIZE - 1];
169.     if (r > 0.0) {
170.         print(" + ");
171.         print(simplify(r, -1));
172.     }
173.     else if (r < 0.0) {
174.         print(" - ");
175.         print(simplify(fabs(r), -1));
176.     }
177.     println("");
178. }
180. // 조립제법 계산표 출력 함수
181. void printSyntheticTable(double a, double c[], double s[], double q[], int size) {
182.     int SIZE = size;
183.     int i;
184.     print("       | ");
185.     print(simplify(c[0], 6));
186.     for (i = 1; i < SIZE; i++) {
187.         print("  ");
188.         print(simplify(c[i], 6));
189.     }
190.     println("");
192.     print(simplify(a, 6));
193.     print(" | ");
194.     print("        ");
195.     print(simplify(s[1], 6));
196.     for (i = 2; i < SIZE; i++) {
197.         print("  ");
198.         print(simplify(s[i], 6));
199.     }
200.     println("");
202.     print("       |-");
203.     for (i = 0; i < SIZE; i++) {
204.         print("--------");
205.     }
206.     println("");
208.     print("         ");
209.     print(simplify(q[0], 6));
210.     for (i = 1; i < SIZE; i++) {
211.         print("  ");
212.         print(simplify(q[i], 6));
213.     }
214.     println("");
215. }
218. // C/C++/Ch/Objective-C 언어의 실행 시작 지점
219. int main(int argc, char *argv[]) {
220.     int i;
221.     int SIZE = argc - 2;
222.     double a, c[15], s[15], b[15];
223.     if (argc < 4) {
224.         printUsage();
225.         exit(1);
226.     }
228.     //////////////////////////////////////////////////////
229.     // 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
230.     // 제식은 x -  a
231.     a = atof(argv[1]);
233.     for (i = 0; i < SIZE; i++) {
234.         c[i] = atof(argv[i + 2]);
235.     }
237.     //////////////////////////////////////////////////////
238.     // 조립제법의 주요 부분
239.     s[0] = 0.0;
240.     b[0] = c[0];
241.     for (i = 1; i < SIZE; i++) {
242.         s[i] = b[i-1]*a;
243.         b[i] = c[i] + s[i];
244.     }
246.     //////////////////////////////////////////////////////
247.     // 몫의 계수와 나머지를 출력한다.
248.     print("몫의 계수는 ");
249.     for (i = 0; i < SIZE - 2; i++) {
250.         print(simplify(b[i], -1));
251.         print(", ");
252.     }
253.     print(simplify(b[SIZE - 2], -1));
254.     print(" 이고, 나머지는 ");
255.     print(simplify(b[SIZE - 1], -1));
256.     println(" 이다.");
257.     println("");
259.     //////////////////////////////////////////////////////
260.     // 조립제법 표를 출력한다.
261.     printSyntheticTable(a, c, s, b, SIZE);
262.     println("");
264.     //////////////////////////////////////////////////////
265.     // (피제식) = (제식) x (몫) + (나머지)
266.     printDivisionResult(a, c, b, SIZE);
267.     return 0;
268. }

컴파일은 Dev-C++ 에서 Ctrl+F11 클릭

실행> testSyntheticDivision 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 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 )를 Objective-C용 소스로 고친 것이다. 고쳐진 내용은 #import 부근 뿐이다. 특히

        #import <Foundation/Foundation.h>

가 중요하다.
스트링을 처리하고 전달하기 위해 메모리 할당(allocation)과 해제(free)를 하면서 동적 메모리(dynamic memory)를 이용하고 있다.

1. /*
2.  *  Filename: testForForMain.m
3.  *
4.  *  Compile:  Click Ctrl+F11 on Dev-C++
5.  *
6.  *  Execute:  testForFor
7.  *
8.  *  Date:  2012. 4. 30.
9.  */
11. #import <Foundation/Foundation.h>
12. #import <stdio.h>
13. #import <string.h>
14. #import <memory.h>
16. // 매개변수 dan으로 지정된 한 단의 결과를 매개변수 t로 전달한다.
17. // 중요!! t로 전달된 메모리는 사용 후 반드시 해제(free)하여야 한다.
18. void getDan(char *t[19], int dan) {
19.     char sa[10], sb[10], sval[10];
20.     int j;
21.     // t[0], ... , t[18]에 각각 동적 메모리를 할당한다.
22.     for (j = 0; j < 19; j++) {
23.         t[j] = (char *) calloc(21, sizeof(char));
24.     }
25.     for (j = 0; j < 19; j++) {
26.         sprintf(sa, "%d", dan);
27.         if (strlen(sa) < 2)
28.             sprintf(sa, " %d", dan);
29.         sprintf(sb, "%d", j + 1);
30.         if (strlen(sb) < 2)
31.             sprintf(sb, " %d", j + 1);
32.         sprintf(sval, "%d", dan*(j + 1));
33.         if (strlen(sval) < 2)
34.             sprintf(sval, "  %d", dan*(j + 1));
35.         else if (strlen(sval) < 3)
36.             sprintf(sval, " %d", dan*(j + 1));
37.         strcpy(t[j], sa);
38.         strcat(t[j], " x ");
39.         strcat(t[j], sb);
40.         strcat(t[j], " = ");
41.         strcat(t[j], sval);
42.     }
43. }
44. // 19단표를 모두 80컬럼 컨솔에 출력한다.
45. void printAllNineteenDan() {
46.     int d[4] = { 2, 7, 11, 16 };      // 각 줄단위 블럭의 첫단
47.     int counter[4] = { 5, 4, 5, 4 };  // 각 줄단위 블럭에 속한 단의 개수
48.     char *lines[19];
49.     char *v[19];
50.     int i, j, k;
51.     char arr[18][19][21];
52.     for (i = 2; i < 20; i++) {
53.         getDan(v, i);
54.         for (j = 0; j < 19; j++) {
55.             strcpy(arr[i - 2][j], v[j]);
56.         }
57.     }
58.     // lines[0], ... , lines[18]에 각각 동적 메모리를 할당한다.
59.     for (j = 0; j < 19; j++) {
60.         lines[j] = (char *) malloc(81 * sizeof(char));
61.     }
62.     for (k = 0; k < (sizeof(d)/sizeof(int)); k++) {
63.         // 80 바이트 길이의 한 줄씩 완성
64.         for (i = 0; i < 19; i++) {
65.             strcpy(lines[i], arr[d[k]-2][i]);
66.             for (j = 1; j < counter[k]; j++) {
67.                 strcat(lines[i], "   ");
68.                 strcat(lines[i], arr[d[k]-2+j][i]);
69.             }
70.         }
71.         // 80 바이트 길이의 한 줄씩 출력
72.         for (i = 0; i < 19; i++) {
73.             printf("%s\n", lines[i]);
74.         }
75.         printf("\n");
76.     }
77.     // lines[0], ... , lines[18]로 할당받은 모든 동적 메모리를 해제한다.
78.     for (j = 0; j < 19; j++) {
79.         free(lines[j]);
80.     }
81.     // v[0], ... , v[18]로 할당받은 모든 동적 메모리를 해제한다.
82.     for (j = 0; j < 19; j++) {
83.         free(v[j]);
84.     }
85. }
87. // Objective-C 언어의 main 함수 : 실행 시작 지점
88. int main(void) {
89.     printAllNineteenDan();    // 객체에 속하는 메소드 printDan()을 호출한다.
90.     return 0;
91. }

 
컴파일은 Dev-C++ 에서 Ctrl+F11 클릭

실행> 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

소스 파일명: testWhileMain.m

1. /*
2.  * Filename: testWhileMain.cm
3.  *
4.  * Purpose:  Example using the while loop syntax
5.  *               while ....
6.  *
7.  * Execute:  testWhile -200 300
8. */
10. #import <Foundation/Foundation.h>  // strtol, abs, exit 등을 위해 필요
11. #import <stdio.h>
12. #import <string.h>
13. #import <math.h>
15. // 사용법 표시
16. void printUsage() {
17.     printf("Using: testWhile [integer1] [integer2]\n");
18.     printf("This finds the greatest common divisor of the given two integers.\n");
19. }
21. int main(int argc, char *argv[]) {
22.     long val1, val2;
23.     long a, b, q, r, gcd;
25.     if (argc != 3) {
26.         printUsage();
27.         exit(1);
28.     }
30.     // 명령행 인자의 두 스트링을 가져와서
31.     // 긴정수(long) 타입으로 변환하여
32.     // 변수 val1과 val2에 저장한다.
33.    val1 = strtol(argv[1], NULL, 10);    /// val1 = atoi(argv[1]);
34.    val2 = strtol(argv[2], NULL, 10);    /// val2 = atoi(argv[2]);
36.     // a는 |val1|, |val2| 중 큰 값
37.     a = abs(val1);
38.     b = abs(val2);
39.     if (a < b) {
40.         a = abs(val2);
41.         b = abs(val1);
42.     }
44.     if (b == 0L) {
45.         printf("GCD(%ld, %ld) = %ld\n", val1, val2, a);
46.         exit(0);
47.     }
49.     // -------------------------------------------
50.     // Euclidean 알고리즘의 시작
51.     //
52.     // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
53.     q = a / b;
54.     r = a % b;
56.     // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
57.     while (r != 0L) {
58.         a = b;
59.          b = r;
60.         q = a / b;
61.         r = a % b;
62.     }
64.     // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
65.     gcd = b;
67.     // 최대공약수(GCD)를 출력한다.
68.     printf("GCD(%ld, %ld) = %ld\n", val1, val2, gcd);
69.     return 0;
70. }

컴파일: Dev-C++ 에서 Ctrl+F11 클릭

실행:

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

소스 파일명: testIfMain.m

1. #import <stdio.h>
2. #import <stdlib.h>
4. // 사용법 표시 함수
5. void printUsing() {
6.     printf("Using: testIf [number]\n");
7.     printf("This determines whether the number is positive or not.\n");
8. }
10. // main 함수
11. int main(int argc, char *argv[]) {
12.     float val;
13.     if (argc != 2) {
14.         printUsing();
15.         exit(1);
16.         return 1;
17.     }
19.     // 명령행 인자의 스트링을 가져와서
20.     // 배정밀도 부동소수점수로 변환하여
21.     // 변수 val에 저장한다.
22.     val = atof(argv[1]);
24.     // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
25.     // 판단하는 if...else... 조건문
26.     if (val > 0.0)
27.         printf("%g is a positive number.\n", val);
28.     else if (val < 0.0)
29.         printf("%g is a negative number.\n", val);
30.     else
31.         printf("%g is zero.\n", val);
32.     return 0;
33. }
    

컴파일은 Dev-C++ 에서

실행> 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.

컴파일은 Dev-C++ 에서

소스 파일명: testArgumentsMain.m

1. #import <Foundation/Foundation.h> // NSLog 사용을 위해
2. #import <stdio.h>   // printf 함수 사용을 위해
3. #import <string.h>    // atof 함수 사용을 위해
5. // argc는 명령행 인자 개수, argv는 명령행 인자 문자열의 배열
6. int main(int argc, const char *argv[]) {
7.     int i;
8.     double sum = 0.0;    // 초기화
10.     // 명령행 인자(command-line argument) 개수 출력
11.     printf("Count of arguments: %d\n", argc);
13.     for (i = 0; i < argc; i++) {
14.         // C 스트링을 배정밀도 부동소수점수로 변환하여 누적
15.         sum += atof(argv[i]);
16.     }
18.     // 배정밀도 부동소수점수 값을 %g로 출력
19.     printf("The sum of arguments is %g\n", sum);
21.     // 배정밀도 부동소수점수 값을 %lg로 출력
22.     NSLog(@"The sum of arguments is %lg\n", sum);
23.     system("PAUSE");    // 키보드 입력 대기
24.     return 0;
25. }

실행> TestArguments 1 2 3 4
Count of arguments: 5
The sum of arguments is 10
TestArguments[2456] The sum of arguments is 10

실행> TestArguments 1 2 3 4.2
Count of arguments: 5
The sum of arguments is 10.2
TestArguments[5180] The sum of arguments is 10.2

GNUStep 이 설치되었다면 헤더 파일 Foundation.h 를 수입(import)하였겠지만,
GNUStep 이 설치되지 않아 헤더 파일 Object.h 를 수입(import)하였다.


헤더 파일 HelloWorld.h
#import <Objc/Object.h>

@interface HelloWorld : Object
-(void) sayHello;
@end


구현 파일 HelloWorld.m
#import <stdio.h>
#import <Objc/Object.h>
#import "HelloWorld.h"

@implementation HelloWorld
-(void) sayHello {
    printf("Hello, world!\nThis was created by the Objective-C language.\n");
}
@end


실행부 파일 main.m
/*
 * Filename: main.m
 *
 *  Compile: gcc -v -o HelloWorld HelloWorld.m main.m -lobjc
 *  Execute: ./HelloWorld
 *
 *     Date: 2011. 8. 4.
 *   Author: phk
 */

#import <stdio.h>
#import <Objc/Object.h>
#import "HelloWorld.h"

int main() {
    id obj = [HelloWorld alloc];
    [obj sayHello];
    return 0;
}


컴파일하기
$ gcc -v -o HelloWorld HelloWorld.m main.m -lobjc


실행하기
 $ ./HelloWorld
Hello, world!
This was created by the Objective-C language.