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

원시 피타고라스 삼조(primitive pythagorea triplet)를 생성하는

명령줄 어플(Command Line Application) C# 소스

C# 소스:

// Filename: GeneratePrimitivePythagoreanTriplets.cs
//
// Compile: csc GeneratePrimitivePythagoreanTriplets.cs
//
// Execute: GeneratePrimitivePythagoreanTriplets 7

using System;
using System.Collections.Generic;

namespace GeneralCommandLineApp
{
   class Program
    {
    	   public static Int64 GetGCD(Int64 xa, Int64 xb)
    	  {
    	  	  Int64 a = Math.Abs(xa);
    	  	  Int64 b = Math.Abs(xb);
    	  	  Int64 c;
    	  	  if (b > a) {
    	  	  	  c = b;
    	  	  	  b = a;
    	  	  	  a = c;
    	  	  }
    	  	  Int64 r;
    	  	  r = b;
    	  	  while (r > 0)
    	  	  {
    	  	  	  r = a % b;
    	  	  	  a = b;
    	  	  	  b = r;
    	  	  }
    	  	  return a;
    	  }

    	  public static void GeneratePrimitivePythagoreanTriplets(List<PythagoreanTriplet> data, Int64 k)
    	  {
    	  	  for (Int64 m = 2; m <= k; m++)
    	  	  {
    	  	      for (Int64 n = 1; n < m; n++)
    	  	      {
    	  	      	     if (GetGCD(m, n) == 1 && ((m % 2 == 0 && n % 2 != 0) || (m % 2 != 0 && n % 2 == 0))) {
    	  	  	         data.Add(new PythagoreanTriplet(m, n));
    	  	  	     }
    	  	      }
    	  	  }
        }

    	  public static void PrintTripletsAsTableForm(List<PythagoreanTriplet> data)
    	  {
    	  	  Int64 k = data.Count;
    	  	  Int64 a, b, c, m, n;
    	  	  Console.WriteLine("Print out some primitive Pythagorean triplets (a, b, c)\neach of which satisfies a^2 + b^2 = c^2.");
    	  	  Console.WriteLine();
    	  	  Console.WriteLine("      +--------+--------+-----------+-----------+-----------+");
    	  	  Console.WriteLine("      |        |        | m^2 - n^2 |     2mn   | m^2 + n^2 |");
    	  	  Console.WriteLine("      |     m  |     n  |      a    |      b    |      c    |");
    	  	  Console.WriteLine("      +--------+--------+-----------+-----------+-----------+");
    	  	  for (int i = 0; i < k; i++) {
    	  	      a = data[i].GetA();
    	  	  b = data[i].GetB();
    	  	  c = data[i].GetC();
    	  	  m = (Int64) Math.Sqrt((a + c)/2);
    	  	  n = b/(2*m);
    	  	  Console.WriteLine("      | {0, 6} | {1, 6} | {2, 9} | {3, 9} | {4, 9} |", m, n, a, b, c);
               }
               Console.WriteLine("      +--------+--------+-----------+-----------+-----------+");
        }

        static void Main(string[] args)
        {
        	Int64 c;
        	if (args.Length == 1) {
                c = Convert.ToInt64(args[0]);
                if (c < 1) {
                     Console.WriteLine("Sorry, you should a positive integer as an upper boud.");
                     return;
                }
                else {
                    List<PythagoreanTriplet> data = new List<PythagoreanTriplet>();
                    GeneratePrimitivePythagoreanTriplets(data, c);
                    PrintTripletsAsTableForm(data);
                    return;
                }
            }
            else
                Console.WriteLine("Usage:  GeneratePrimitivePythagoreanTriplets [UpperBound]");
        }
    }


     class PythagoreanTriplet {
        Int64 a, b, c;
        public PythagoreanTriplet(Int64 m, Int64 n) {
           	this.a = m*m - n*n;
            	this.b = 2*m*n;;
           	this.c = m*m + n*n;
       }
        public Int64 GetA() {
        	return this.a;
        }
        public Int64 GetB() {
        	return this.b;
        }
        public Int64 GetC() {
        	return this.c;
        }

        public override string ToString() {
        	return "(" + this.a + ", " + this.b + ", " + this.c + ")";
        }

        public bool IsPrimitive(Int64 xa, Int64 xb, Int64 xc)
        {
            return GCD(xa, xb, xc) == 1;
        

        public Int64 GCD(Int64 xa, Int64 xb)
        {
            Int64 a = Math.Abs(xa);
            Int64 b = Math.Abs(xb);
            Int64 c;
            if (b > a) {
                c = b;
                b = a;
                a = c;
            }
            Int64 r;
            r = b;
            while (r > 0)
            {
                r = a % b;
                 a = b;
                b = r;
            }
            return a;
        }

        public Int64 GCD(Int64 xa, Int64 xb, Int64 xc)
        {
            Int64 t = GCD(xa, xb);
            Int64 y = GCD(t, xc);
            return y;
        }
    }
}

명령 GeneratePrimitivePythagoreanTriplets 7 에 의한 실행 결과:

Print out some primitive Pythagorean triplets (a, b, c)
each of which satisfies a^2 + b^2 = c^2.

      +--------+--------+-----------+-----------+-----------+
      |        |        | m^2 - n^2 |     2mn   | m^2 + n^2 |
      |     m  |     n  |      a    |      b    |      c    |
      +--------+--------+-----------+-----------+-----------+
      |      2 |      1 |         3 |         4 |         5 |
      |      3 |      2 |         5 |        12 |        13 |
      |      4 |      1 |        15 |         8 |        17 |
      |      4 |      3 |         7 |        24 |        25 |
      |      5 |      2 |        21 |        20 |        29 |
      |      5 |      4 |         9 |        40 |        41 |
      |      6 |      1 |        35 |        12 |        37 |
      |      6 |      5 |        11 |        60 |        61 |
      |      7 |      2 |        45 |        28 |        53 |
      |      7 |      4 |        33 |        56 |        65 |
      |      7 |      6 |        13 |        84 |        85 |
      +--------+--------+-----------+-----------+-----------+

C# 소스:

// Filename: GeneratePythagoreanTriplesn.cs
//
// Compile: csc GeneratePythagoreanTriples.cs
//
// Execute: GeneratePythagoreanTriples 40

using System;
using System.Collections.Generic;

namespace GeneralCommandLineApp
{
     class PythagorianTriple {
        Int64 a, b, c;
        public PythagorianTriple(Int64 x) {
             Int64 t;
        	if (x >1 && x % 2 == 1) {
           	    this.a = x;
            	    this.b = (x*x - 1)/2;;
           	    this.c = this.b + 1;;
        	}
        	else if (x >= 2) {
        	    t = x + 2;
            	    this.a = t;
            	    this.b = t*t/4 - 1;
           	    this.c = this.b + 2;;
           	}
       }
        public Int64 GetA() {
        	return this.a;
        }
        public Int64 GetB() {
        	return this.b;
        }
        public Int64 GetC() {
        	return this.c;
        }

        public override string ToString() {
        	return "(" + this.a + ", " + this.b + ", " + this.c + ")";
        }
    }
    
   class Program
    {
         public static void GenerateTriples(List<PythagorianTriple> data, Int64 k)
        {
    	  for (Int64 i = 1; i <= k; i++)
    	  {
    	      data.Add(new PythagorianTriple(2*i + 1));
    	      data.Add(new PythagorianTriple(2*i));
    	  }
        }

        public static void PrintTriplesAsTableForm(List<PythagorianTriple> data)
        {
    	  Int64 c = data.Count;
    	   int j;
              Console.WriteLine("Show Pythagorian triples (a, b, c) each of which satisfies a^2 + b^2 = c^2.");
              Console.WriteLine();
              Console.WriteLine("      +--------+--------+--------+         +--------+--------+--------+");
              Console.WriteLine("      |   Odd  |        |        |         |  Even  |        |        |");
              Console.WriteLine("      |     a  |     b  |     c  |         |     a  |     b  |     c  |");
              Console.WriteLine("      +--------+--------+--------+         +--------+--------+--------+");
               for (int i = 0; i < c; i += 2) {
                   Console.Write("      | {0, 6} | {1, 6} | {2, 6} |", data[i].GetA(), data[i].GetB(), data[i].GetC());
                   j = i + 1;
                   Console.WriteLine("         | {0, 6} | {1, 6} | {2, 6} |", data[j].GetA(), data[j].GetB(), data[j].GetC());
               }
              Console.WriteLine("      +--------+--------+--------+         +--------+--------+--------+");
        }


        static void Main(string[] args)
        {
        	Int64 c;
        	if (args.Length == 1) {
                c = Convert.ToInt64(args[0]);
                if (c < 1) {
                     Console.WriteLine("Sorry, you should a positive integer.");
                     return;
                }
                else {
                    List<PythagorianTriple> data = new List<PythagorianTriple>();
                    GenerateTriples(data, c);
                     PrintTriplesAsTableForm(data);
                     return;
                }
            }
            else
                Console.WriteLine("Usage:  GeneratePyThagoriaTriples  [number]");
        }
    }
}

실행: 프롬프트> GeneratePythagoreanTriples 40

실행 결과:

한글, 일본어, 중국어를 모두 사용하는 문서를 작성하기 위해

한글2020을 설치하였지만, 중국어 입력은 되는데 일본어는 일본어 자판기를

선택만하기만 하면 한글2020의 동작이 멈추고 무한 대기 상태가 되어

작업관리자에서 한글2020을 강제 종료 해야먄 했다.

이 문제를 해결하고 나서 깨달은 것은 이전에 설치되어 있던 

한글 Office 2010 을 제거하였는데도 남아 있던 파일 hjimesv.ini 에 있던

내용 때문이었다. 한글 Office 2020을 설치했으면 설치 과정 중에

이 파일의 내용이 새로이 수정되고 자동으로 저장되어야 함에도 여전히 그대로

방치되어 한글 2020에서 일본어 입력을 전혀 못하다가

이 파일에 설정되어 있던 값을 수정하니

한글 2020에서 아무 문제 없이 일본어 입력을 잘 할 수 있게 되었다.

다음은 Right Shift + Spacebar(일본어 Hiragana 키보드)를 눌러 일본어를 입력 중인

화면을 캡쳐한 것이다.

한글 2020에서 일본어자판을 선택하면 한글 2020이 비정상 종료하는 경우를 아래와 같이 해결하였다.

이전 버전의 한글 Office 2010을 사용할 때는 파일 C:\Windows\hjimesv.ini

에 일본어 자판기 관련 설정이 다음 처럼 되어 있었다.

[HncJapaneseIMEServer]
path=C:\Program Files (x86)\Hnc\Common80\him\

윈도우 보조프로그램 Notepad 를 관리자 실행권한으로 열어 이것의 내용을

아래와 같이 수정하였다. (필자의 경우 이전 버전 한글 Office 2010을 C:\ 드라이브에

설치되어 있었지만 새 버전 한글 Office 2020은 D:\ 드라이브에 설치하였다.

[HncJapaneseIMEServer]
path=D:\Program Files (x86)\HNC\Office 2020\HOffice110\Bin\Him\

위와 같이 수정된 내용을 다시 저장하고 한글 2020을 관리자 권한으로 실행하니

일본어 입력이 문제 없이 잘 되었다.

필자의 경우 자판기 설정이 다음 처럼 되어 있다.

(한글 2020의 메뉴에서 "도구" -> "글자판(K)" -> "글자판 바꾸기(K)" 하거나

 키보드 Alt+F2 를 클릭하면 나오는 창)

키보드 Right Shift + Spacebar 를 클릭하면 일본어 하라가나 입력 글자판이 된다.

일본어 입력 상태에서 키보드 Right Shift + Spacebar 를 클릭하면 중국어 간체 입력 글자판이 되고,

중국어 입력 상태에서 키보드 Right Shift + Spacebar 를 클릭하면 일본어 히라가나 입력 글자판이 된다.

[참고 자료] https://namu.moe/w/한컴오피스%20한글