다음은  대화형 모드(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 ]
  8. function println(s)
  9.     if s ~= nil then
  10.         print(s)
  11.     else
  12.         print("")
  13.     end
  14. end
  15. function printUsage()
  16.     println("Usage: lua convertRadix.lua")
  17.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
  18. end
  19. function printAbout()
  20.     println("    About: Convert radix in a interactive mode.")
  21. end
  22. function printMainMenu()
  23.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
  24. end
  25. function printMainPrompt()
  26.     io.write("  Prompt> ")
  27. end
  28. function printSubMenu(srcRadix, destRadix)
  29.     println("    Convert Radix_" .. srcRadix .. " to Radix_" .. destRadix)
  30.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
  31. end
  32. function printSubPrompt()
  33.     io.write("    Input Value>> ")
  34. end
  35. local BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  36. function itoa(num, radix)
  37.    local isNegative = false
  38.    if num < 0 then
  39.       isNegative = true
  40.       num = -num
  41.    end
  42.    local arr = {}
  43.    local q, r = num, 0
  44.    while q >= radix do
  45.       r = math.fmod(q, radix)
  46.       q = math.floor(q / radix)
  47.       table.insert(arr, string.sub(BASE36, r+1, r+1))
  48.    end
  49.    table.insert(arr, string.sub(BASE36, q+1, q+1))
  50.    if isNegative then
  51.       table.insert(arr, "-")
  52.    end
  53.    local ret = ""
  54.    for i = #arr, 1, -1 do
  55.        ret = ret .. arr[i]
  56.    end
  57.    return ret
  58. end
  59. function convertRadix(s, srcRdx, destRdx)
  60.     local val = tonumber(s, srcRdx)
  61.     local ret = itoa(val, destRdx)
  62.     return string.upper(ret)
  63. end
  64. function doConvert(srcRadix, destRadix)
  65.     local line = ""
  66.     local cmd = ""
  67.     local srcStr = ""
  68.     local destStr = ""
  69.     printSubMenu(srcRadix, destRadix)
  70.     while true do
  71.         printSubPrompt()
  72.         cmd = io.read()
  73.         while string.len(cmd) < 1 do
  74.             cmd = io.read()
  75.         end
  76.         if "main()" == cmd then
  77.             return
  78.         elseif "exit()" == cmd or "quit()" == cmd then
  79.             os.exit(0)
  80.         end
  81.         local flagContinue = true
  82.         if tonumber(cmd, srcRadix) == nil then
  83.             flagContinue = false
  84.         end
  85.         if flagContinue then
  86.             srcStr = cmd
  87.             destStr = convertRadix(srcStr, srcRadix, destRadix)
  88.             println("        ( " .. srcStr .. " )_" .. srcRadix .. "   --->   ( " .. destStr .. " )_" .. destRadix)
  89.             println("")
  90.         end
  91.     end
  92. end
  93. function doStart()
  94.     local line = ""
  95.     local cmd = ""
  96.     local srcRadix = 10
  97.     local destRadix = 10
  98.     local srcStr = ""
  99.     local destStr = ""
  100.     local onlyOnce = true
  101.     while true do
  102.         println()
  103.         if onlyOnce then
  104.             println("  The supported maximum radix is 36.")
  105.             onlyOnce = false
  106.         end
  107.         printMainMenu()
  108.         printMainPrompt()
  109.         cmd = io.read()
  110.         while string.len(cmd) < 1 do
  111.             cmd = io.read()
  112.         end
  113.         if string.find("qQxX", cmd) ~= nil and string.len(cmd) == 1 then
  114.             os.exit(0)
  115.         elseif string.find("aA", cmd) ~= nil and string.len(cmd) == 1 then
  116.             printAbout()
  117.         elseif string.find("sS", cmd) ~= nil and string.len(cmd) == 1 then
  118.             io.write("  Input the source and target radices (say, 16 2): ")
  119.             line = io.read()
  120.             while string.len(line) < 1 do
  121.                 line = io.read()
  122.             end
  123.             st = {}
  124.             for w in string.gmatch(line, "[0-9]*") do
  125.                 if string.len(w) > 0 then
  126.                     table.insert(st, w)
  127.                 end
  128.             end
  129.             while #st < 2 do
  130.                 io.write("  Input the source and target radices (say, 16 2): ")
  131.                 line = io.read()
  132.                while string.len(line) < 1 do
  133.                     line = io.read()
  134.                 end
  135.                 st = {}
  136.                 for w in string.gmatch(line, "%a+") do
  137.                     if string.len(w) > 0 then
  138.                         table.insert(st, w)
  139.                     end
  140.                 end
  141.             end
  142.             println("")
  143.             srcRadix = tonumber(st[1])
  144.             destRadix = tonumber(st[2])
  145.             doConvert(srcRadix, destRadix)
  146.         end
  147.     end
  148. end
  149. -- Begin here
  150. if #arg > 0 and "-h" == arg[1] then
  151.     printUsage()
  152.     os.exit(1)
  153. end
  154. 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()





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

Posted by Scripter
,

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

See:  http://en.wikipedia.org/wiki/Golden_ratio


  1. -- Filename: testGoldenRatio.lua
  2. --    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
  3. --
  4. --  Execute: lua testGoldenRatio.lua
  5. --
  6. -- Date    24-March-2008
  7. -- Author  PH Kim   [ pkim (AT) scripts.pe.kr ]
  8. function printUsing()
  9.     print("Using: lua testGoldenRatio.lua [-h|-help]");
  10.     print("This calculates the value of the golden ratio.");
  11. end
  12. -- 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
  13. function findQuadraticRoot(a, b, c)
  14.     if a == 0.0 then
  15.         error( "Since the highest coefficient is zero, the given equation is not a quadratic equation." )
  16.     elseif b*b - 4*a*c < 0.0 then
  17.         error( "Since the discriminant " .. (b*b - 4*a*c) .. " is negative, the given equation has no real root." )
  18.     end
  19.     x1 = (-b + math.sqrt(b*b - 4*a*c)) / (2.0 * a)
  20.     x2 = (-b - math.sqrt(b*b - 4*a*c)) / (2.0 * a)
  21.     return {x1, x2}
  22. end
  23. -- 실행 시작 지점
  24. if #arg > 0 and (arg[1] == "-h" or arg[1] == "-help") then
  25.     printUsing()
  26.     os.exit(1)
  27. end
  28. values = findQuadraticRoot(1.0, -1.0, -1.0)
  29. x1 = values[1]
  30. x2 = values[2]
  31. if x1 >= x2 then
  32.     print("The bigger root is " .. x1 .. ", ")
  33.     print("and the less root is " .. x2 .. ".")
  34. else
  35.     print("The bigger root is " .. x2 .. ", ")
  36.     print("and the less root is " .. x1 .. ".")
  37. end



실행> lua testGoldenRatio.lua
The bigger root is 1.6180339887499,
and the less root is -0.61803398874989.



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

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


  1. --[[
  2.    Filename: testCTime.lua
  3.    Execute: lua testCTime.lua
  4. --]]
  5. -- See http://www.lua.org/manual/5.1/manual.html#pdf-os.clock
  6. weekNames = { "일", "월", "화", "수", "목", "금", "토" }
  7. cNow = os.date("*t")
  8. -- 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
  9. print("UTC: " .. os.time(cNow) .. "초")
  10. -- 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
  11. io.write(cNow["year"] .. "년 " .. cNow["month"] .. "월 " .. cNow["day"] .. "일 ")
  12. io.write("(" .. weekNames[cNow["wday"]] .. "요일) ")
  13. io.write(cNow["hour"] .. "시 " .. cNow["min"] .. "분 " .. cNow["sec"] .. "초")
  14. print()
  15. -- 1월 1일은 1, 1월 2일은 2
  16. -- Time.now.isdat == false 이면, 서머타임 없음
  17. strIsDST = "안함"
  18. if cNow["isdst"] then
  19.     strIsDST = "함"
  20. end
  21. print("올해 몇 번째 날: " .. cNow["yday"] .. ", 서머타임 적용 여부: " .. strIsDST)



실행> lau testCTime.lua
UTC: 1206325100초
2008년 3월 24일 (월요일) 11시 18분 20초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함




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

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

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

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

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


아래의 소스파일은 Ruby용 소스파일 testSyntheticDivision.rb 를 Lua용으로 수정한 것이다.


  1. --[[
  2.   Filename: testSyntheticDivision.lua
  3.   Purpose:  Find the quotient and remainder when some polynomial is
  4.             divided by a monic polynomial of the first degree.
  5.   Execute:  lua testSyntheticDivision.lua -2 1 3 3 1
  6. --]]
  7. -- 사용법 표시
  8. function printUsage()
  9.     print("사용법: lua testSyntheticDivision.lua [수] [피제식의 계수들]")
  10.     print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
  11. end   
  12. -- 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
  13. -- 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
  14. function simplify(v, width)
  15.     t = "" .. v
  16.     tlen = string.len(t)
  17.     if string.sub(t, tlen-2) == ".0" then
  18.         t = string.sub(t, 0, tlen-2)
  19.     end
  20.     if width ~= nil then
  21.         if tlen < width then
  22.             t = string.sub("              ", 0, width - tlen) .. t
  23.         end
  24.     end
  25.     return t
  26. end
  27. -- 다항식을 내림차순의 스트링 표현으로 반환
  28. function toPolyString(c)
  29.     local t = ""
  30.     sc0 = simplify(c[1], null)
  31.     if #c > 2 then
  32.         if sc0 == "1" then
  33.             t = t .. "x^" .. (#c-1)
  34.         elseif sc0 == "-1" then
  35.             t = t .. "-x^" .. (#c-1)
  36.         else
  37.             t = t .. sc0 .. " x^" .. (#c-1)
  38.         end
  39.     elseif #c == 2 then
  40.         if sc0 == "1" then
  41.             t = t .. "x"
  42.         elseif sc0 == "-1" then
  43.             t = t .. "-x"
  44.         else
  45.             t = t .. sc0 .. " x"
  46.         end
  47.     elseif #c == 1 then
  48.         t = t .. sc0
  49.     end
  50.     for i = 2, #c do
  51.         k = #c - i
  52.         sc = simplify(c[i], nil)
  53.         if k > 1 then
  54.             if c[i] > 0.0 then
  55.                 if sc == "1" then
  56.                     t = t .. " + " .. "x^" .. k
  57.                 else
  58.                     t = t .. " + " .. sc .. " x^" .. k
  59.                 end
  60.             elseif c[i] < 0.0 then
  61.                 if sc == "-1" then
  62.                     t = t .. " - " .. "x^" .. k
  63.                 else
  64.                     t = t .. " - " .. simplify(math.abs(c[i]), nil) .. " x^" .. k
  65.                 end
  66.             end
  67.         elseif k == 1 then
  68.             if c[i] > 0.0 then
  69.                 if sc == "1" then
  70.                     t = t .. " + " .. "x"
  71.                 else
  72.                     t = t .. " + " .. sc .. " x"
  73.                 end
  74.             elseif c[i] < 0.0 then
  75.                 if sc == "-1" then
  76.                     t = t .. " - " .. "x"
  77.                 else
  78.                     t = t .. " - " .. simplify(math.abs(c[i]), null) .. " x"
  79.                 end
  80.             end
  81.         elseif k == 0 then
  82.             if c[i] > 0.0 then
  83.                 t = t .. " + " .. sc
  84.             elseif c[i] < 0.0 then
  85.                 t = t .. " - " .. simplify(math.abs(c[i]), null)
  86.             end
  87.         end
  88.     end
  89.     return t
  90. end
  91. -- 다향식 나눗셈 결과를
  92. --     (피제식) = (제식)(몫) + (나마지)
  93. -- 형태로 출력
  94. function printDivisionResult(a, c, b)
  95.     local strLine = "  " .. toPolyString(c)
  96.     io.write( strLine .. "\n")
  97.     strLine = "    = ( " .. toPolyString( { 1.0, -a } ) .. " )"
  98.     tmp = { }
  99.     for i = 1, #b - 1 do
  100.         tmp[i] = b[i]
  101.     end
  102.     strLine = strLine .. "( " .. toPolyString(tmp) .. " )"
  103.     r = b[#b]
  104.     if r > 0.0 then
  105.         strLine = strLine .. " + " .. simplify(r, nil)
  106.     elseif r < 0.0 then
  107.         strLine = strLine .. " - " .. simplify(math.abs(r), nil)
  108.     end
  109.     io.write( strLine .. "\n" )
  110. end
  111. -- 조립제법 계산표 출력 함수
  112. function printSyntheticTable(a, c, s, q)
  113.     strLine = "       | "
  114.     strLine = strLine .. simplify(c[1], 6)
  115.     for i = 2, #c do
  116.         strLine = strLine .. "  " .. simplify(c[i], 6)
  117.     end
  118.     io.write( strLine .. "\n" )
  119.     strLine = simplify(a, 6) ..  " |"
  120.     strLine = strLine .. "         "
  121.     strLine = strLine .. simplify(s[2], 6)
  122.     for i = 3, #s do
  123.         strLine = strLine .. "  " .. simplify(s[i], 6)
  124.     end
  125.     io.write( strLine .. "\n" )
  126.     strLine = "       |"
  127.     for i = 1, #q do
  128.         strLine = strLine .. "--------"
  129.     end
  130.     io.write( strLine .. "\n" )
  131.     strLine = "         "
  132.     strLine = strLine .. simplify(q[1], 6)
  133.     for i = 2, #q do
  134.         strLine = strLine .. "  " .. simplify(q[i], 6)
  135.     end
  136.     io.write( strLine .. "\n" )
  137. end
  138. -- 실행 시작 지점
  139. if #arg < 3 then
  140.     printUsage()
  141.     os.exit(1)
  142. end
  143. -- 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
  144. -- 제식은 x -  a
  145. a = arg[1]
  146. c = { }
  147. s = { }
  148. b = { }
  149. for i = 1, #arg-1 do
  150.     c[i] = tonumber(arg[i + 1])
  151. end
  152. -- 조립제법의 주요 부분
  153. s[1] = 0.0
  154. b[1] = c[1]
  155. for i = 2, #c do
  156.     s[i] = b[i-1]*a
  157.     b[i] = c[i] + s[i]
  158. end
  159. -- 몫의 계수와 나머지를 출력한다.
  160. io.write("몫의 계수는 ")
  161. for i = 1, #b-1 do
  162.     io.write(simplify(b[i], nil) .. ", ");
  163. end
  164. io.write(simplify(b[#b], nil) .. " ")
  165. io.write("이고, 나머지는 " .. simplify(b[#b], nil) .. " 이다." .. "\n")
  166. io.write("\n")
  167. -- 조립제법 표를 출력한다.
  168. printSyntheticTable(a, c, s, b)
  169. io.write("\n")
  170. -- (피제식) = (제식) x (몫) + (나머지)
  171. printDivisionResult(a, c, b)




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



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

다음은 Ruby용 소스파일 testForFor.rb를 Lua용으로 수정한 것이다.
Lua 언어에서의 print 문은 Python 언어의 print 문은 처럼 개행(newline) 문자를 포함한다.

Ruby 언어의에서 쓰이는 조건 분기 구문

        if 조건식1 then
            블럭1
        elsif 조건식2 then
            블럭2
        elsif 조건식3 then
            블럭3
        else
            블럭4
        end

에 해딩하는 Lua 언어의 구문은

        if 조건식1 then
            블럭1
        elseif 조건식2 then
            블럭2
        elseif 조건식3 then
            블럭3
        else
            블럭4
        end

이다. 또 다음은 Python, Ruby, Groovy, Lua 언어의 for 반복 구문의 비교이다.


Python 언어의 for 반복 구문
     for n in range(1, 10, 1):
          블럭


Ruby 언어의 for 반복 구문
     for n in 1...10 do
          블럭
     end


Groovy 언어의 for 반복 구문
     for (n in 1..<10 {
          블럭
    }

Lua 언어의 for 반복 구문
     for n = 1,9,1 do
          블럭
    end




  1. --[[
  2.   Filename: testForFor.rb
  3.   Execute:  ruby testForFor.rb
  4.         Or  jruby testForFor.rb
  5.   Date:  2008. 3. 3.
  6. --]]
  7. function getDan(dan)
  8.     t = { }
  9.     for j = 1, 19 do
  10.         sa = "" .. dan
  11.         if #sa < 2 then
  12.             sa = " " .. dan
  13.         end
  14.         sb = "" .. j
  15.         if #sb < 2 then
  16.             sb = " " .. j
  17.         end
  18.         sval = "" .. (dan*j)
  19.         if #sval < 2 then
  20.             sval = "  " .. (dan*j)
  21.         elseif #sval < 3 then
  22.             sval = " " .. (dan*j)
  23.         end
  24.         t[j] = sa .. " x " .. sb .. " = " .. sval
  25.     end
  26.     return t
  27. end
  28. -- 19단표를 모두 80컬럼 컨솔에 출력한다.
  29. function printAllNineteenDan()
  30.     arr = { }
  31.     for i = 2, 19 do
  32.         arr[i - 1] = getDan(i)
  33.     end
  34.     -- Lua 소스 코드에서는 배열 대신 테이블을 사용한다.
  35.     d = { 2, 7, 11, 16 }      -- 각 줄단위 블럭의 첫단
  36.     counter = { 5, 4, 5, 4 }  -- 각 줄단위 블럭에 속한 단의 개수
  37.     lines = { }
  38.     for k = 1, #d do
  39.         -- 80 바이트 길이의 한 줄씩 완성
  40.         for i = 1, 19 do
  41.             lines[i] = arr[d[k] - 1][i]
  42.             for j = 1, counter[k]-1  do
  43.                 lines[i] = lines[i] .. "   " ..  arr[d[k] - 1 + j][i]
  44.             end
  45.         end
  46.         -- 80 바이트 길이의 한 줄씩 출력
  47.         for i = 1, 19 do
  48.             print( lines[i] )
  49.         end
  50.         print( "" )
  51.     end
  52. end
  53. printAllNineteenDan()


 


실행> lua testForFor.lua 

 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


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

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




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

Posted by Scripter
,

소스 파일명: testIf.lua

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




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

Posted by Scripter
,
Lua 언어에서 명령행 인자는 변수 arg로 처리한다. 즉, arg는 Lua 언어에서 하나의 (명령행 인자 처리 변수) 예약어인 셈이다. 이 변수는 명령행 실행시 옵션으로 입력된 인자들을 스트링 값으로 모아둔 리스트 타입의 변수이다. 이 변수가 가리키는 리스트에 속한 아이템의 개수를 구하기 위해서는 전위 단항연산자 #을 선두에 붙이면 된다. 즉 #arg가 리스트에 속한 (아이템의 개수)-1이다. 그런데 Lua 언어에서는 Python 언어에서 처럼, 명령행 실행시 실행될 소스파일명의 인덱스 번호가 0번이므로, 아래의 소스 코드에서 우리가 처리할 명령행 인자들은 1번, 2번, 3번, .... 의 인텍스 번호를 갖는다.
(참고로, Lua 언어의 신택스는 테이블 타입의 자료 처리를 기반으로 하고 있으며, 리스트 타입이라고 하는 것도 실제로는 특수한 테이블 타입 중 하나인 셈이다.)

Lua 언어에서 줄 단위 주석문 기호는 --이다. 소스 코드의 어느 줄이든 -- 및 그 우측 부분은 모두 주석으로 처리된다. 이 기호는 Python/Ruby 언어의 줄 단위 주석문 기호 #에 해당하며, C/C++/Java/Groovy 언어의 줄 단위 주석문 기호 //에 해당한다.



소스 파일명: testArguments.lua
  1. -- 명령행 인자(command-line argument) 개수 출력
  2. print( "Count of arguments: " .. #arg )
  3. sum = 0.0
  4. for i = 1, #arg do
  5.     -- 스트링을 부동소수점수로 변환하여 누적
  6.     sum = sum + tonumber(arg[i])
  7. end
  8. -- 누적된 값을 출력
  9. print( "The sum of arguments is " .. sum)


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


실행> lua testArguments.lua 1 2 3 4.5
Count of arguments: 4
The sum of arguments is 10.5





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

Posted by Scripter
,

lua 언어의 for 반복문 양식은

       for varName = startValue, endValue, stepValue do
             block
     end

또는

       for varName = startValue, endValue do
             block
     end

이다.

또 문자열이나 자료의 붙이기(concatenation) 연산자는 .. 이다. (즉 두 개의 점)


'
소스 파일명: for_test.lua
------------------------------[소스 시작]
local function printDan(dan)
  for i = 1, 9 do
    print( dan .. " x " .. i .. " = " .. (dan*i) )
  end
end

printDan(2)
------------------------------[소스 끝]

실행> lua for_test.lua
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18





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

Posted by Scripter
,
컨솔에 문자 출력하는 lua 구문은

       print "문자열(스트링)"

이다. 여기서 개행문자 "\n"은 추가하지 않아도 된다.
 
소스 파일명: hello.lua
------------------------------[소스 시작]
print "Hello, world!"
------------------------------[소스 끝]

실행> lua hello.lua
Hello, world!

Posted by Scripter
,