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

소스 파일명: testWhileCPP.cpp

1. /*
2.  * Filename: testWhileCPP.cpp
3.  *
4.  * Purpose:  Example using the while loop syntax
5.  *               while ....
6.  *
7.  * Compile:  cl -EHsc testWhileCPP.cpp
8.  *
9.  * Execute:  testWhileCPP -200 300
10. */
12. #include <iostream>
13. #include <cmath>
15. using namespace std;
17. // 사용법 표시
18. void printUsage() {
19.     cout << "Using: testWhileCPP [integer1] [integer2]" << endl;
20.     cout << "This finds the greatest common divisor of the given two integers." << endl;
21. }
23. int main(int argc, char *argv[]) {
24.     long val1, val2;
25.     long a, b, q, r, gcd;
27.     if (argc != 3) {
28.         printUsage();
29.         exit(1);
30.     }
32.     // 명령행 인자의 두 스트링을 가져와서
33.     // 긴정수(long) 타입으로 변환하여
34.     // 변수 val1과 val2에 저장한다.
35.     val1 = atoi(argv[1]);
36.     val2 = atoi(argv[2]);
38.     // a는 |val1|, |val2| 중 큰 값
39.     a = abs(val1);
40.     b = abs(val2);
41.     if (a < b) {
42.         a = abs(val2);
43.         b = abs(val1);
44.     }
45.     if (b == 0L) {
46.         cout << "GCD(" << val1 << ", " << val2 << ") = " << a << endl;
47.         exit(0);
48.     }
50.     // -------------------------------------------
51.     // Euclidean 알고리즘의 시작
52.     //
53.     // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
54.     q = a / b;
55.     r = a % b;
57.     // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
58.     while (r != 0L) {
59.         a = b;
60.         b = r;
61.         q = a / b;
62.         r = a % b;
63.     }
65.     // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
66.     gcd = b;
68.     // 최대공약수(GCD)를 출력한다.
69.     cout << "GCD(" << val1 << ", " << val2 << ") = " << gcd << endl;
70.     return 0;
71. }

컴파일:

Command> cl -EHsc testWhileCPP.cpp


실행:

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

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

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

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

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

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





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

소스 파일명: testWhile.c

1. /*
2.  * Filename: testWhile.c
3.  *
4.  * Purpose:  Example using the while loop syntax
5.  *               while ....
6.  *
7.  * Compile:  cl testWhile.c
8.  *
9.  * Execute:  testWhile -200 300
10. */
12. #include <stdio.h>
13. #include <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 = atoi(argv[1]);
34.     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. }

컴파일:

Command> cl testWhile.c


실행:

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

소스 파일명: testWhile.lua

1. --[[
2.   Filename: testWhile.lua
3.   Purpose:  Example using the while loop syntax
4.                 while ....
5.   Execute: lua testWhile.lua -200 300
6. --]]
8. -- 사용법 표시
9. function printUsage()
10.     print "Using: lua testWhile.lua [integer1] [integer2]"
11.     print "This finds the greatest common divisor of the given two integers."
12. end
14. if #arg ~= 2 then
15.     printUsage()
16.     os.exit(1)
17. end
19. -- 명령행 인자의 두 스트링을 가져와서
20. -- 정수 타입으로 변환하여
21. -- 변수 val1과 val2에 저장한다.
22. val1 = tonumber(arg[1])
23. val2 = tonumber(arg[2])
25. -- a는 |val1|, |val2| 중 큰 값
26. a = math.abs(val1)
27. b = math.abs(val2)
28. if a < b then
29.     a = math.abs(val2)
30.     b = math.abs(val1)
31. end
33. if b == 0 then
34.     print( "GCD(" .. val1 .. ", " .. val2 .. ") = " .. a )
35.     os.exit(0)
36. end
38. -- Euclidean 알고리즘의 시작
39. --
40. -- a를 b로 나누어 몫은 q에, 나머지는 r에 저장
41. q = a / b
42. r = a % b
44. -- Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
45. while r ~= 0 do
46.     a = b
47.     b = r
48.     q = a / b
49.     r = a % b
50. end
52. -- 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
53. gcd = b
55. -- 최대공약수(GCD)를 출력한다.
56. print( "GCD(" .. val1 .. ", " .. val2 .. ") = " .. gcd )

실행:

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

Command> lua testWhile.lua -200 0
GCD(-200, 0) = 200

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

Command> lua testWhile.lua 21 81
GCD(21, 81) = 3

Command> lua testWhile.lua 23 25
GCD(23, 25) = 1





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

소스 파일명: testWhile.py

1. # coding=euc-kr
3. #  Filename: testWhile.py
4. #
5. #  Purpose:  Example using the while loop syntax
6. #                while ....
7. #
8. # Execute: python testWhile.py -200 300
9. #
11. import sys
12. # 사용법 표시
13. def printUsage():
14.     print "Using: python testWhile.py [integer1] [integer2]"
15.     print "This finds the greatest common divisor of the given two integers."
17. if len(sys.argv) != 3:
18.     printUsage()
19.     sys.exit(1)
21. # --------------------------------------
22. # 명령행 인자의 두 스트링을 가져와서
23. # 정수 타입으로 변환하여
24. # 변수 val1과 val2에 저장한다.
25. val1 = long(sys.argv[1])
26. val2 = long(sys.argv[2])
28. # a는 |val1|, |val2| 중 큰 값
29. a = abs(val1)
30. b = abs(val2)
32. if a < b:
33.     a = abs(val2)
34.     b = abs(val1)
36. if b == 0:
37.     print "GCD(%d, %d) = %d" % (val1, val2, a)
38.     sys.exit(0)
40. # --------------------------------------
41. # Euclidean 알고리즘의 시작
42. #
43. # a를 b로 나누어 몫은 q에, 나머지는 r에 저장
44. q = a / b
45. r = a % b
47. # --------------------------------------
48. # Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
49. while r != 0:
50.     a = b
51.     b = r
52.     q = a / b
53.     r = a % b
55. # 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
56. gcd = b
58. # 최대공약수(GCD)를 출력한다.
59. print "GCD(%d, %d) = %d" % (val1, val2, gcd)
    

실행:

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

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

Command> python testWhile.py -200 0
GCD(-200, 0) = 200

Command> python testWhile.py 125 100
GCD(125, 100) = 25

Command> python testWhile.py 23 25
GCD(23, 25) = 1


위의 소스 코드는 ipy 명령에 의하여 IronPython에서도 수정 없이 그대로 실행된다.





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

소스 파일명: testWhile.rb

1. #
2. #  Filename: testWhile.rb
3. #
4. #  Purpose:  Example using the while loop syntax
5. #                while ....
6. #
7. # Execute: ruby testWhile.rb -200 300
8. #
9. # 사용법 표시
10. def printUsage()
11.     print "Using: ruby testWhile.rb [integer1] [integer2]\n"
12.     print "This finds the greatest common divisor of the given two integers.\n"
13. end
14. if (ARGV.length != 2)
15.     printUsage()
16.     exit(1)
17. end
18. # --------------------------------------
19. # 명령행 인자의 두 스트링을 가져와서
20. # 정수 타입으로 변환하여
21. # 변수 val1과 val2에 저장한다.
22. val1 = ARGV[0].to_i
23. val2 = ARGV[1].to_i
24. # a는 |val1|, |val2| 중 큰 값
25. a = val1.abs
26. b = val2.abs
27. if (a < b) then
28.     a = val2.abs
29.     b = val1.abs
30. end
31. if (b == 0)
32.     print "GCD(#{val1}, #{val2}) = #{a}\n"
33.     exit(0)
34. end
35. # --------------------------------------
36. # Euclidean 알고리즘의 시작
37. #
38. # a를 b로 나누어 몫은 q에, 나머지는 r에 저장
39. q = a / b
40. r = a % b
41. # --------------------------------------
42. # Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
43. while (r != 0)
44.     a = b
45.     b = r
46.     q = a / b
47.     r = a % b
48. end
49. # 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
50. gcd = b
51. # 최대공약수(GCD)를 출력한다
52. print "GCD(#{val1}, #{val2}) = #{gcd}\n"

실행:

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

Command> ruby testWhile.rb 23 25
GCD(23, 25) = 1

Command> ruby testWhile.rb 230 25
GCD(230, 25) = 5

Command> ruby testWhile.rb 230 125
GCD(230, 125) = 5

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





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

간단한 Groovy 스크립트:
def name='World'; println "Hello $name!"

다소 복잡한 Groovy 스크립트:

class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() + who[1..-1] }
  def salute() { println "Hello $name!" }
}

g = new Greet('world')  // 객체 생성
g.salute()              // "Hello World!"를 출력

class Greet {
  def name
  Greet() {  }
  Greet(who) { name = who[0].toUpperCase() + who[1..-1] }
  def salute() { println "Hello, $name!" }
}

g = new Greet('world')  // 객체 생성
g.salute()              // "Hello, World!"를 출력

import static org.apache.commons.lang.WordUtils.*

명령행 스크립트로 실행한 경우:
groovy -e "println 'Hello ' + args[0] + '!'" World

아래의 소스 코드는 Groovy로도 실행되는 Java 용 소스파일 TestWhileLoop.java를 Groovy 용으로 Groovy 언어 답게 고친 것이다.

소스 파일명: testWhile.groovy

1. /*
2.  *  Filename: testWhile.groovy
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  *
7.  *  Execute: groovy testWhile.groovy -200 300
8.  *
9.  */
11. // java.lang.Math 클래스를 명시적으로 import하는 구문이 없어도
12. // Groovy는 이 클래스를 자동으로 import한다.
14. // 사용법 표시
15. def printUsage() {
16.     println 'Using: groovy testWhile.groovy [integer1] [integer2]'
17.     println 'This finds the greatest common divisor of the given two integers.'
18. }
20. if (args.length != 2) {
21.     printUsage()
22.     System.exit(1)
23. }
25. def val1 = args[0].toLong()
26. def val2 = args[1].toLong()
27. def a, b, q, r, gcd
29. ////////////////////////////////////////////////
30. // 명령행 인자의 두 스트링을 가져와서
31. // 긴정수(long) 타입으로 변환하여
32. // 변수 val1과 val2에 저장한다.
33. a = val1.abs()
34. b = val2.abs()
36. // a는 |val1|, |val2| 중 큰 값
37. if (a < b) {
38.     a = val2.abs()
39.     b = val1.abs()
40. }
42. if (b == 0L) {
43.     println "GCD($val1, $val2) = $a"
44.     System.exit(0)
45. }
47. ////////////////////////////////////////
48. // Euclidean 알고리즘의 시작
49. //
50. // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
51. q = a / b
52. r = a % b
54. ////////////////////////////////////////
55. // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
56. while (r != 0L) {
57.     a = b
58.     b = r
59.     q = a / b
60.     r = a % b
61. }
63. // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
64. gcd = b
66. // 최대공약수(GCD)를 출력한다.
67. println "GCD($val1, $val2) = $gcd"

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

실행> groovy testWhile.groovy -50, 200
GCD(-50, 200) = 50

실행> groovy testWhile.groovy 50, -30
GCD(50, -30) = 10

실행> groovy testWhile.groovy 0. 30
GCD(0, 30) = 30





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

소스 파일명: TestWhileLoop.java

1. /*
2.  *  Filename: TestWhileLoop.java
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  *
7.  *  Compile: javac -d . TestWhileLoop.java
8.  *  Execute: java TestWhileLoop -200 300
9.  *
10.  */
12. import java.lang.Math;
13. public class TestWhileLoop {
15.     // 사용법 표시
16.     public static void printUsage() {
17.          System.out.println("Using: java TestWhileLoop [integer1] [integer2]");
18.          System.out.println("This finds the greatest common divisor of the given two integers.");
19.     }
21.     // Java 애플리케이션의 실행 시작 시점 main 메소드
22.     // (C 언어의 main 함수에 해당)
23.     public static void main(String[] args) {
24.         if (args.length != 2) {
25.             printUsage();
26.             System.exit(1);
27.         }
29.         ////////////////////////////////////////////////
30.         // 명령행 인자의 두 스트링을 가져와서
31.         // 긴정수(long) 타입으로 변환하여
32.         // 변수 val1과 val2에 저장한다.
33.         long val1 = Long.parseLong(args[0]);
34.         long val2 = Long.parseLong(args[1]);
35.         long a, b, q, r, gcd;    // r은 나머지, q는 몫
37.         // a는 |val1|, |val2| 중 큰 값
38.         a = Math.abs(val1);
39.         b = Math.abs(val2);
40.         if (a < b) {
41.             a = Math.abs(val2);
42.             b = Math.abs(val1);
43.         }
45.         if (b == 0L) {
46.             System.out.println("GCD(" + val1 + ", " + val2 + ") = " + a);
47.             System.exit(0);
48.         }
50.         ////////////////////////////////////////
51.         // Euclidean 알고리즘의 시작
52.         //
53.         // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
54.         q = a / b;
55.         r = a % b;
56.         ////////////////////////////////////////
57.         // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
58.         while (r != 0L) {
59.             a = b;
60.             b = r;
61.             q = a / b;
62.             r = a % b;
63.         }
65.         // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
66.         gcd = b;
67.         // 최대공약수(GCD)를 출력한다.
68.         System.out.println("GCD(" + val1 + ", " + val2 + ") = " + gcd);
69.     }
70. }
    

컴파일> javac -d . TestWhileLoop.java

실행> java TestWhileLoop
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> java TestWhileLoop 200 300
GCD(200, 300) = 100

실행> java TestWhileLoop 50, -20
GCD(50, -20) = 10

실행> java TestWhileLoop -30, 0
GCD(-30, 0) = 30



Groovy를 사용하면 위의 소스를 (컴파일 과정 없이) 그대로 실행시킬 수 있다. 그대신 파일 확장자명을 groovy로 하여 저장하여야 한다. 아래는 파일명을 TestWhileLoop.groovy로 저장하여 실행시칸 경우이다.


실행> groovy TestWhileLoop.groovy
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> groovy TestWhileLoop.groovy -200 500
GCD(-200, 500) = 100

실행> groovy TestWhileLoop.groovy 108, 180
GCD(108, 180) = 36

실행> groovy TestArguments.groovy -30, 0
GCD(-30, 0) = 30





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

소스 파일명: testIf.lua

1. --[[
2.    Filename: testIf.lua
4.    Purpose:  Example using the conditional control structure syntax
5.                  if .... else ...
7.    Execute: lua testIf.lua [number]
8. --]]
10. -- 사용법을 보여주는 함수
11. function printUsing()
12.    print("Using: ruby testIf.rb [number]")
13.    print("This determines whether the number is positive or not.")
14. end
16. -- 명령행 인자의 개수가 1이 아니면 사용법을 보여준다.
17. if #arg ~= 1 then
18.     printUsing()
19.     os.exit(1)
20. end
22. -- 명령행 인자의 스트링을 가져와서
23. -- 배정밀도 부동소수점수로 변환하여
24. -- 변수 val에 저장한다.
25. val = tonumber(arg[1])
27. -- 변수 val에 저장된 값이 양수인지 음수인지 0인지를
28. -- 판단하는 if...else... 조건문
29. if (val > 0.0) then
30.     print(val .. " is a positive number.")
31. elseif (val < 0.0) then
32.     print(val .. " is a negative number.")
33. else
34.     print(val .. " is zero.")
35. end
    

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

실행> lua testIf.lua 1.21
1.21 is a positive number.

실행> lua testIf.lua -1.21
-1.21 is a negative number.

실행> lua testIf.lua 0
0 is zero.





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

소스 파일명: testIfCPP.cpp

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

컴파일> cl /GX testIfCPP.cpp

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

실행> testIfCPP 1.234
1.234 is a positive number.

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

실행> testIfCPP 0
0 is zero.



※ Ch 5.5를 사용하여 컴피일 과정 없이 소스를 실행시키려면 인클루드문

        #incldue <cmath>

을

        #incldue <math.h>

로 고치면 된다. 그대신 부동소수점수의 출력이 다소 다르다.



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

실행> ch testCPP.cpp 2.7
2.7000 is a positive number.

실행> ch testCPP.cpp -2.7
-2.7000 is a negative number.

실행> ch testCPP.cpp 0
0 is zero.





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