고요한 하늘

32비트 머신에서는 warning 없이 잘 컴파일 되던 것이 64비트 머신으로 갔더니
cast from pointer to integer of different size
이런 메세지가 뜬다..

unsigned short int* 형을 unsigned int형으로 바꾸는 부분에서 발생한 warning인데
sizeof로 확인해보니
unsigned short int*가 64비트에서는 8byte 자료형이고, unsigned int는 4byte 자료형이라서 발생하는 문제였다.
그래서 unsigned int를 unsigned long int로 수정했더니 warning이 사라졌다.

보면 알겠는데
누가 설명해 달라면 입이 닫힌다...
잊어 버릴때마다 정리를 해야겠다.

조건부 확률 이라함은.
P(A|B) 이런식으로 표현을 하고
사건 B가 일어나고  사건A가 일어날 확률을 구하는 문제이다.
( 이 말은 B가  전체 도메인이 되었다는 것을 의미한다. {B = 전체도메인} 이 표현이 없다면 A,B를 포함하고 있는 전체 박스가 전체 도메인이다 )
단순하게 생각하면 A와 B의 교집합을 구하는 문제로 생각할수 있는데
항상 P(A|B) = P(B|A)가 아니기 때문에 이말은 틀린 말이다.


보통 이식은 다음과 같이 풀어진다.
P(A|B) = P(B|A)*P(A)/P(B)

유도과정을 살펴보면

먼저 P(A|B)는 아래와 같다


그러면 반대로 사건 A가 일어 났을때  사건 B가 일어날 확률은 아래와 같다.

P(A|B)=P(A^B)/P(B)
=> P(A|B)*P(B) = P(A^B)가 되고

P(B|A)=P(A^B)/P(A)
=> P(B|A)*P(A)=P(A^B)가 된다.

이두식의 우변이 같으므로
결과적으로 아래와 같은 식이 성립한다.


그러면 P(A|B)를 구하기 위해서는 결과적으로 아래의 식과같이 유도가 된다.


P(A|B)를 구하기 위해서는
P(B|A) ,
P(A),
P(B) 의 값을 알고 있어야 한다.

 결론적으로 P(B|A)를 알고  있으면 P(A|B)를 구할수 있다.


간단히
참고 :
1. http://synap.tistory.com/entry/%EC%A1%B0%EA%B1%B4%EB%B6%80-%ED%99%95%EB%A5%A0%EB%B2%A0%EC%9D%B4%EC%A7%80%EC%95%88%EC%9D%98-%EC%9D%B4%ED%95%B4%EB%A5%BC-%EC%9C%84%ED%95%9C-%EC%98%88%EC%A0%9C-%EB%B0%8F-%ED%92%80%EC%9D%B4
2. http://enc.daum.net/dic100/contents.do?query1=20XXXX5791

Machine learning 공부할때 자주 나오는 개념

http://statgen.iop.kcl.ac.uk/bgim/mle/sslike_3.html

간단히 설명하면

사전 X가 나올 확률 P(X|p)로 표현하고

우도값은 L( p | x ) 이렇게 표현한다

동전 던지기 테스트

동전던지기를 100회 시행 해서

56번 앞면이 나왔을때

p = 0.52일 경우

p = 0.5일 경우

(계산 방법은 아래 excel 파일 참조)

p 값을 다양하게 해서 테스트를 해보면

p값이 0.56일때  우도값(likelihood)이 가장 크다

결국 Maximum Likelihood Estimation은 0.56이 된다.

왜 MLE에 우리는 많은 시간을 소비하는가?

이런 예제는 너무 간단해서 눈으로도 대략 MLE를 추정할수 있지만

우리가 접하는 모든 문제가 이렇게 간단하지만은 않기 때문이다.

LSA에 관한 여러 문서를 살펴본 결과 LSA를 WSD( Word Sense Disambiguation )에 사용할수 있을 것 같아서
테스트를 해보았다.

첨부한 input.txt파일을 입력으로 테스트를 진행하였고
input.txt파일의  내용은 '다음검색'에서 검색을 통해 구축했다.
검색어는 '피지'로 하였고
남태평양의 섬 '피지'에 대한 것과 피부 분비물 '피지' 각각 눈으로 선별하여 6개 4개로 총 10개의 문서로 구성되었다.

결과를 살펴보면
DOC1과 가장 관련이 깊은 문서는 DOC4이고
DOC2와 가장 관련이 깊은 문서는 DOC3이다.
input.txt 파일을 열어 보시면 알겠지만 테스트 결과를 확인하기 쉽게 하기 위해
문서 번호 1,2,3,4,5는 남태평양의 섬 '피지'에 관한 문서이고, 6,7,8.9,10은 피부 분비물 '피지'에 관한 것이다.
문서 6번부터 문서 10번까지 붉게 표신된 것들을 살펴보면 유사한 문서들이 모두 6번에서 10번 문서 사이에 존재하는 것을 알수 있다.
이결과만 놓고 판단할때는 LSA를 WSD에 사용해도 의미 있는 결과를 얻을수 있을것 같다.

보통의 경우 파일을 처리할때

open보다는 fopen을 사용한다.

O_CREAT니 O_RDWR과 같은 옵션을 외우느니 그런 옵션이 내장되어 있어서

사용하기 편한 fopen을 사용한다.

습관의 차이일수도 있다.(보통은 open보다는 fopen을 먼저 접한다 )

그런데 가끔은 open을 사용해야하는 경우도 있다.

파일을 빈번히 열고 닫을 경우 fopen보다는 open이 속도가 빠르기 때문이다.

정말로 그런지 테스트를 한번 해보았다.

첫번째 파일은 test_open.c로

open, close만 10,000,000번 한다.

두번째 파일은 test_fopen.c는

fopen, fclose만 10,000,000번 한다.

테스트는 test_open한번 실행하고 test_fopen실행하는 식으로 총 5번 시간을 측정했다.

test_open  : avg 24.6/sec

test_fopen : avg 37.6/sec

open, close 함수가 fopen(fclose)함수에 비해 1.5배 정도 빠른것으로 보인다.

물론 open을 파일을 열었을 경우에는 read,write함수를 사용해야 하고 read, write함수를 효율적으로 사용하기 위해서는 한번에 읽어오는  page size를 알아야 하는 번거로움이 있다.

이 테스트에서는 이런 것들을 모두 배제하고 파일을 열고 닫는데 어느 정도 속도차이가 있는지에만 초점을 맞추어 테스트를 진행했다.

보너스 : open, close를 1억번 해도 결과는 같을까?

test_open : 3m54.256s

test_fopen :  5m35.421s

LSA를 이용한 내용기반 검색엔진 시스템.pdf

Singular_Value_Decomposition_Tutorial.pdf

http://www.miislita.com/
LSA(Latent Semantic Analysis)를 구현하기 위해서 알아야 할 것들이 몇 가지 있다.
우선 SVD( Singular Value Decompositon )을 알아야 한다.
SVD에 대한 설명 아래 블로그에 가서 보면 도움이 될것이다.
SVD 설명 : http://blog.daum.net/hazzling/15807155
SVD 라이브러리 : http://tedlab.mit.edu/~dr/SVDLIBC/
svd 공부하기전에 알아야 할 것들

• vector length  = [4, 11, 8, 10]  |v| = sqrt(4^2 + 11^2 + 8^2 + 10^2) = p301 = 17.35
• Orthogonality = [2, 1,-2, 4] and [3,-6, 4, 2] [2, 1,-2, 4] * [3,-6, 4, 2] = 2(3) + 1(-6) - 2(4) + 4(2) = 0
• Normal vector = unit vector = vector length가 1인 vector
• transpose = 행렬의 행과 열은 바꾸는 것

 

• Orthogonal Matrix = A^T와 A는 orthogonal하다
  

• digonal matrix  = 대각선에만 값이 있는 행렬
  
  

  

   
• Determinant =
  n = 2

  

  n > 2
  

  

  
  
  
  
  그리고 또한가지 일반적으로 백터의 유사도를 계산하기 위해서 사용하는 코사인 유사도( cosine similarity )는

위에 있는 공식만 알면 된다.

대용량에서 문서와 문서와의 관계 텀과 텀의 관계에서 어떤 보이지 않는 정보를 추출할때 사용하는 방법론이 LSA이다.
간단하게 작은 샘플을 가지고 어떤 능력이 있는지 살펴보자

우선
6개의 문서가 있다.
문서 1: cosmonaut, moon, car
문서 2 : astronaut, moon
문서 3 : cosmonaut
문서 4 : car, truck
문서 5 : car
문서 6 : truck

이렇게 6개의 문서가 있는데
사람이 보고 유사한 문서를 찾으면
term을 기준으로 같은 텀이 들어간 4,5번 문서가 유사하고, 1,2번 문서가 유사하다고 말할것이다.
그런데 LSA는 이것말고 이 안에 숨겨진 다른 정보를 보여준다.
우선
위 6개의 문서를 행렬로 표현하면
A =  

	d1	d2	d3	d4	d5	d6
cosmonaut	1	0	1	0	0	0
astronaut	0	1	0	0	0	0
moon	1	1	0	0	0	0
car	1	0	0	1	1	0
truck	0	0	0	1	0	1

A라는 행렬에 숨겨진 정보를 찾기 위해서 SVD라는 것을 사용하는데
간단하게 설명하면 원본 행렬 A를 3개의 행렬로 분리하는 것이다.
공식으로 쓰면 A = USV 라고 쓰고
아래 보이는 테이블이 첫부분에 소개한 svdlibc로 얻은 값이다.

          
U=
 

	dim1	dim2	dim3	dim4	dim5
cosmonaut	-0.44	-0.3	0.57	0.58	0.25
astronaut	-0.13	-0.33	-0.59	0	0.73
moon	-0.48	-0.51	-0.37	0	-0.61
car	-0.7	0.35	0.15	-0.58	0.16
truck	-0.26	0.65	-0.41	0.58	-0.09

S=
 

2.16	0.00	0.00	0.00	0.00
0.00	1.59	0.00	0.00	0.00
0.00	0.00	1.28	0.00	0.00
0.00	0.00	0.00	1.00	0.00
0.00	0.00	0.00	0.00	0.39

V =

	d1	d2	d3	d4	d5	d6
dimension1	-0.75	-0.28	-0.2	-0.45	-0.33	-0.12
dimension2	-0.29	-0.53	-0.19	0.63	0.22	0.41
dimension3	0.28	-0.75	0.45	-0.2	0.12	-0.33
dimension4	0	0	0.58	0	-0.58	0.58
dimension5	-0.53	0.29	0.63	0.19	0.41	-0.22

이렇게 계산된 값중에 행렬 S에서 2*2만을 위하여
V와 곱한다.
B=S*V

그러면 아래와 같은 행렬이 만들어진다.
 

	d1	d2	d3	d4	d5	d6
dimension1	-1.62	-0.60	-0.40	-0.97	-0.71	-0.26
dimension2	-0.46	-0.84	-0.30	1.00	0.35	0.65

이들 사이의 cosine 유사도를 계산하면
                   DOC1        DOC2        DOC3       DOC4       DOC5     DOC6
   DOC1           1             0               0              0             0             0
   DOC2    0.781837           1              0              0             0             0
   DOC3    0.950136    0.937276           1              0             0             0
   DOC4    0.474432   -0.177918    0.176269           1             0             0
   DOC5    0.740118    0.159375    0.493512    0.943112          1              0
   DOC6    0.110596    -0.53319   -0.204841    0.927362    0.750205         1




위에 언급한 svdlibc 라이브러리고 위의 예제를 테스트 해본 결과 화면( cosine similarity를 사용 )

처음 데이터를 보면 d2,d3에는 하나의 공통 단어도 존재하지 않는다.

따라서 처음 데이터를 가지고 유사도를 계산한다면 0에 가까운 값이 나올 것이다.

그런데 SVD후에 유사도를 보면 유사도가 0.93으로 나온다.

문서 2에는 cosmonaut라는(러시아 우주비행사)가 있고 문서 3에는 astronaut(우주비행사)라는 의미적으로 유사한 단어가 포함되어 있음을 겉으로 드러낸 결과라고 할수 있다.









continue ---

최근 2개월간 나의 최대 관심사는 띄어쓰기이다.

물런 2개월 이전에도 관심을 가지고 논문 몇편을 보긴 했었다. 하지만 회사에서나 집에서나 대부분의 시간을 이문제에 대해서 생각한건 최근 2개월 동안이었던것 같다.

논문을 쓰기 위한 고민이 아니었기 때문에 고민의 가지수는 더 많아졌고,

그 고민들중 두가지는 필드에서 사용가능한 퀄리티와 속도였다.

이런 프로그래을 개발하는 것은 마치  두마리 토끼를 동시에 잡는 것과 비슷한 느낌의 일이었다.

보통 한국어 띄어쓰기의 경우 손쉽게 생각해 볼수 있는 방법이 통계적 방법을 이용하는 것이고 그중에서도 속도나 데이터 부족 문제를 피하기 위해서 바이그램(음절)을 사용하는 경우가 제일 쉬운 접근 방법일 것이다.

우선 바이그램 정보를 어떻게 추출하는지 살펴보면

바이그램으로 데이터를 트레이닝한다고 할때에도 여러가지 방법이 있을수 있다. 외부에 보여지는 두개의 음절이외에 어떤 정보를 추가적으로 담을 것인가..

트라이 그램보다는 바이그램 정보가 작고, 정보량도 부족하기 때문에 바이그램이 담을수 있는 최대치의 정보를 담기 위해서 노력했다.

예를 들면

[띄어쓰기가 더 쉽다 ]

이런 문장이 있다고 할때 여기서 바이그램을 추출하면

(공백 대신 => _ )

[ 띄어], [어쓰], [쓰기], [가가_], [가_더], [_더_쉽], [쉽다_]

 위와 같이 추출된다. (꺽쇠 괄호 안의 음절수는 항상 2이다)

 [_더_쉽]의 경우 음절 바이그램이지만 총 4개의(공백 포함) 정보를 담고 있다.

이처럼 바이그램이지만 비교적 정보를 많이 담았다고 생각했지만

아래의 예제와 같은 경우를 만나는 순간 바이그램의 한계를 직감할수 있었다.

ex> [먹는데이가아파요]

위 문자열에 대한 바이그램 정보를 다음과 같다.

먹는    2042 5848 0 1 8388 15699 8 21
는데    179998 187 53367 90 328859 309 113573 153
데이    73361 73171 76141 29836 10477 949 9636 307
이가    5692 2605 223119 25558 115146 3166 705 18
가아    2112 85 153333 331 4 1 166 0
아파    68547 166835 2413 213 6551 1309 17 2
파요    467 2 109 0 33 0 0 0

위의 테이블에 대해서 간단하게 설명하명

[먹는] 라는 바이그램 음절은

[먹는] 앞,중앙,뒤 공백없이 사용된 횟수가 2042 번이다.

[_먹는] 앞부분에 공백, 중간,뒤 공백없이 사용된 횟수가 5848 이다.

[먹_는] 중간에만 공백이 들어간 횟수가 0 번이다.

[_먹_는] 앞과 중간에 공백이 들어간 횟수가 1 번이다.

[먹는_] 뒤에 공백이 들어간 횟수가 8388 이다.

[_먹는_] 앞과 뒤에 공백이 들어간 횟수는 15699 이다

[먹_는_] 중간과 뒤에 공백이 들어간 횟수는 8이다.

[_먹_는_] 앞,중간,뒤 모두에 공백이 들어간 횟수는 21이다.

처음 시작은 공백이 있다고 가정한다.

다시 말하면 [_먹는데이가아파요_]와 같은 문장이 입력으로 들어왔다고 가정한다.

그렇게 되면

처음 시작은

[_먹는]     5848

[_먹_는]    1

[_먹_는_]    21

[_먹는_]    15699

이정도의 경우의 수가 생길것이다.

이중에서 가장 빈도가 높은 것은 [_먹는_] 이 된다.

문서 상에서는 "먹는 방법" 먹는 이유" 먹는 자세" 등과 같은 형태가 많기 때문에 당연히 [_먹는_]과 같은 형태가 고빈도로 나타난다.

그런데 우리는 [_먹는_]을 선택하면 안된다.

왜냐하면 우리가 원하는 것은 [_먹는_]이 아니고 [_먹는] 이어야 다음 [는데]를 시작할수 있기 때문이다.

시작이 틀리면 다음에 오는 분석에 영향을 미치기 때문에 우리는 다음단계의 확률 더나아가 다다음단계의 확률까지 계산을 해야할지도 모른다.

현재 상태에서는 일단 [_먹는_]이 확률이 가장 높기 때문에 이 다음 확률이 어떻게 되는지 살펴볼 필요가 있다.

다음 확률 값은 "는데"
는데    179998 187 53367 90 328859 309 113573 153

[는데]      179998

[_는데]    187

[는_데]     53367

[_는_데]   90

[는데_]     328859

[_는데_]   309

[는_데_]   113573

[_는_데_]  153

다행히 [는데_]의 빈도가 328859 로 가장 높다.

그러면 [는데_]가 될수 있도록 하려면 [_먹는]이 선택되어야 한다.

두가지 경우의 수만 가지고 판단을 하면

1. [_먹는]  [는데_] => [_먹는데_] => 5848 + 328859  = 334,707

2. [_먹는_][는_데] => [_먹는_데] => 15699 + 113573 = 129,272

   
   

   이와 같은  방식으로 마지막 음절까지 최대 빈도값을 추적해 가면

   먹는데/이가/아파요 라는 문장을 얻을수 있을 것이다.

   다음 포스트에서는 바이그램으로는 절대 처리할수 없는 예에 대해서 설명하겠다.
   

이 글은 스프링노트에서 작성되었습니다.

프로그램을 자주 고치다 보면 이전에는 사용했지만 현재에는 사용하지 않는 함수들이 많이 생긴다.

그런 함수들이 한두개에 지나지 않고, 자신이 모든 함수들을 제어할수 있다면 상관없겠지만.
자신이 만든 코드를 다른 사람에게 인수 인계 하거나 문서화를 할때 사용하지 않는 함수는 시선을 혼란시키기 코드 집중도를 떨어뜨리기 때문에 가급적 지우는것이 바람직하다.

그런데 잘 사용하는지 사용하지 않는지 확인 하기 위해서 grep로 찾아도 보고 했지만 정착 최상위 함수가 if 조건으로 복잡하게 되어 있다면 이것을 판단하기는 여간 어려운 것이 아니다.

만에 하나....만번중에 한번정도 실행되는 코드일 가능성 때문에 지울수가 없다.
이런 경우를 사용하지 않는 코드를 찾아볼수 있는 툴이 있는데 이 툴이 바로 gcov 이다.

gcov를 설명하려고 한게 아닌데 이야기가 길어졌다.

본론으로 들어가면
tistory에 포스팅한후에 혹시나 해서 구글에 가서 검색을 했다.(포스팅후 1,2시간 정도 지난것 같다 )

그런데 검색이 된다.


지금 티스트리에는 글을 한달에 한두개 정도 밖에 올리지 않아서 클롤러의 방문횟수가 많지 않을텐데
그럼에도 불구하고, 글을 게시한지 1시간도 되지 않아서 글이 검색에 노출이 된다.

이것은 두가지 의미를 내포한다.
1. 크클롤러가 열라 바쁘게 돌아다닌다. 내 블로그같이 글을 자주 포스팅 하지 않는 곳에도
2. 동적 색인을 한다.  영어권 웹페이지에 대한것과 한국어 웹페이지에 대한것을 별도의 색인 서버에서 색인할텐데 한국어 웹페이지에 대한것은 적어도 1시간 이내에 동적색인을 하는것 같다.

아직 네이버나 다음에서는 검색되지 않는다.
요약하면  TISTORY에 글을 쓰면 구글이 국내 검색엔진 가운데 가장 먼저 검색에 노출시킨다.(성급한 일반화 일수 있음)



언제 시간이 나면 동적 색인이 어느 정도의 interval을 두고 실행되는지 확인해 봐야 겠다.

만들어 놓고 쓰지 않는 함수가 if 분기로 인해 실행이 되지 않는 코드를 찾기 위한 방법으로

아래와 같이 컴파일 하면

gcc -fprofile-arcs -ftest-coverage -g test.c -o test

  test.gcda , test.gcno 와 같은 두개의 파일이 생긴다.

execution>> ./test 1000

execution>> gcov test.c

test.c.gcov 이 생성된다.

vim으로 test.c.gcov를 열어보면

        1:   10:    if(argc != 2)
        -:   11:    {
    #####:   12:        printf("Usage "%s count\n",argv[0]);
    #####:   13:        exit(1);
        -:   14:    }
        -:   15:
        -:   16:
        -:   17:    else

     1001:   38:    for(i = 0; i < count; i++)
        -:   39:    {

실행되지 않는 코드가 표시된다.
참고 : http://korea.gnu.org/manual/release/gcov/

carryover12.pdf

                              NUMBER OF              LENGTH OF                     NUMBER OF

 SELECTOR             CODES                     EACH CODE (BITS)         UNUSED BITS

 a                             30                            1                                    0

 b                             15                            2                                    0

 c                             10                            3                                    0

 d                             7                              4                                   2

 e                             6                              5                                   0

 f                              5                              6                                   0

 g                             4                              7                                   2

 h                             3                              10                                 0

 i                              2                              15                                 0

 j                              1                              30                                 0

TABLE-1

 

                                                                    possible next selector values

Current selector          a             b             c             d             e              f            g            h              i               j

a                               0             1             2                                                                                                      3

b                               0             1             2                                                                                                      3

c                                             0             1              2                                                                                       3

d                                                            0             1             2                                                                         3

e                                                                          0             1               2                                                         3

f                                                                                          0              1             2                                           3

g                                                                                                        0             1              2                            3

h                                                                                                                       0             1               2            3

i                                                                                                                        0             1               2            3

j                                                                                                                        0             1               2            3

 

TABLE-2

 

 relative-10은 TABLE-1에서처럼 총 10개의 selector가 존재한다.

 

그래서 이름이 relative-10이다.

 

그럼 relative가 의미하는 것은  selector를 선택할때 이전에 선택했던 selector를 기준으로 상대적인 거리를 계산하여 기록하기 때문에 붙여진 이름이다.

예를 들면 이전 selector가 c이었다면 현재 selector로 될수 있는 후보는 b ,c, d, j 이다.

다시 말하면 최대 경우는 수는 4가 되고 이 4를 저장하기 위해 2bit를 사용한다.

 

전체 진행 과정을 예를 들어 설명 하면 다음과 같다.

 

입력되는 포스팅값이 다음과 같이 주어졌다고 가정하자

 1, 3, 9 , 11 ,12, 14

초기 selector를 선택하고 시작할수도 있으나, 여기서는 a를 초기 selector로 하겠다.

-- 데이터를 압축하여 저장할때 기본적으로 데이터 사이의 차이를 저장한다. 차이를 저장하므로써 저장할 수가 작아지기 때문에 효율적으로 데이터 압축이 진행될수 있다. (이것을 보통은 data gap 줄여서 D-gap이라 부른다)

 

a selector가 기본적으로 바뀔수 있는 selector은 a, b, c, j 이다( TABLE-2 참조) 

초기 값이 1, 3, 9, 11, 12, 14 라면 차이값으로 다시 변환하면 아래와 같다.

1, 2, 6, 2, 1, 2

첫번째 숫자 1는 a selector로 저장할수 있기 때문에 selector는 여전히 a이다.

두번째 숫자 2는 a selector로 저장할수 없기 때문에 a보다 큰 selector b를 선택한다.

selector b는 2를 담을수 있기  때문에 현재 selector는 b이다.

세번째 숫자 6은 b selector로 저장할수 없기 때문에 b보다 큰 selector c를 선택한다.

selector c도 6을 담을수 없기 때문에 selector는 마지막 가능한 selector인 j로 이동한다.

 

selector  j는 하나의 데이터만을 저장할수 있기 때문에 첫번째 숫자 1을 저장한

 

여기부터는 다시 위의 과정을 반복한다. 단 j selector에서는 selector가 아래로 이동한다.

2는 selector j로 담기에는 너무 크기 때문에 아래 selector로 이동한다

 selector i 는 2를 담기에는 너무 크기 때문에 아래 selector로 이동한다.

 selector h 는 2를 담기에는 너무 크기 때문에 아래 selector로 이동한다.

 selector g 는 2를 담기에는 너무 크지만 selector에서 이동할수 있는 최대 범위 이기 때문에

더이상의 selector를 아래로 이동하진 못한다.

세번째 숫자 6은  selector g로 저장할수 있기 때문에 현재 selector는 g이다.

세번째 숫자 2은  selector g로 저장할수 있기 때문에 현재 selector는 g이다.

세번째 숫자 1은  selector g로 저장할수 있기 때문에 현재 selector는 g이다.

세번째 숫자 2은  selector g로 저장할수 있기 때문에 현재 selector는 g이다.

 

 

 위와 같은 방식으로 selector는 이전 selector를 기준으로 TABLE-2를 참조하여 이동할수 있다,

selector j일 경우에만 아래(table-2 기준으로 왼쪽)로 이동하고 모든 경우는 위로(table-2기준으로 오른쪽)만 이동한다.

이런 방법으로 위에 든 예처럼 "1, 3, 9 , 11 ,12, 14"은 interger 변수 2개로 모두 표현할수 있다. 

 

 

 

 

 

 

 

 

이 글은 스프링노트에서 작성되었습니다.