아즈키의 블로그 Ver 2005

정렬은 자료 구조와 알고리즘을 배우면서 가장 재미있는 부분임이 틀림없습니다. 문제 자체도 무척 실용적이면서도 정말 다양한, 기발함 그 자체인 알고리즘이 존재하고, 이들은 마치 스타 크래프트 유닛처럼 다양한 요소와 자신만의 장단점이 있습니다. 어떤 알고리즘을 쓰느냐에 따라 결과(소요 시간)도 천차만별이 됩니다.

이런 것들을 직접 코딩하면서 죽음의 삽질-_-도 하고 고민도 많이 했습니다. 자, 그럼 정렬 알고리즘들에 대한 간략한 설명과 함께 소스 나갑니다~

거품 정렬
바로 옆 원소끼리의 비교· 대입만 죽어라고 하는 무식한 노가다 알고리즘. 비교도 많고 대입도 많은 상당히 비효율적인 알고리즘이지요. 그나마 대입 여부를 플래그로 저장하면, 루프를 다 돌기 전에 정렬 작업을 끝낼 수는 있습니다. 이 알고리즘의 동작 모습을 그래픽 (x, y)->(x, 배열의 x째 원소)로 시연해 보면 대각선 부위에서 점들이 거품처럼 부글부글 움직이는 모습을 볼 수 있습니다.

선택 정렬
가장 큰 값부터 차례대로 리스트의 끝으로 옮겨서 정렬하는 방법으로, 실제 상황에서 가장 코딩하기 쉽고 직관적인 알고리즘입니다. 수행 시간이 데이터 상태의 영향을 잘 받지 않고, 데이터의 대입 횟수가 적은 게 특징입니다.

삽입 정렬
삽입 정렬과 거품 정렬을 비교해 보면, O(n^2)이라고 다 같은 O(n^2) 알고리즘은 아니라는 걸 알 수 있습니다. 평균적인 성능이 O(n^2) 알고리즘들 중에서 뛰어난 축에 들기 때문에, 이 정렬은 다른 정렬 알고리즘의 일부로도 자주 인용됩니다. 이 방법은 데이터의 상태, 데이터 한 개의 크기에 따라 성능 편차가 심한 편입니다.

쉘 정렬
삽입 정렬을 응용한 것 뿐인데 삽입 정렬과는 비교할 수 없을 정도로, O(n log n) 알고리즘에 버금가는 성능을 자랑하는 알고리즘입니다. 부가적인 메모리도 전혀 필요없죠. 비용 대 성능이 가장 뛰어난 알고리즘임이 틀림없습니다. 시간 복잡도도 O(n^2)나 O(n log n)처럼 정확하게 계산하기 힘든 신비로운(?) 알고리즘이기도 합니다.

퀵 정렬
가장 유명하고, 정렬 알고리즘의 표준이다시피 한 방법입니다. 이 알고리즘을 보면 정말 사기-_-라는 생각이 듭니다. 실제로 코딩을 해 보면, 퀵 정렬이 코드가 가장 긴데, 실행 시간은 퀵 정렬이 다른 알고리즘들보다 기막힐 정도로 짧습니다. 중간값이라는 뭔가 적당한(모호한-_-) 값을 선택해야 하고, 최악의 경우 시간 복잡도가 O(n^2)에 메모리 복잡도가 O(n)이 될 가능성까지 있는 알고리즘이 어쩜 이럴 수 있는지... 퀵 정렬만치 자료 상태에 민감한 알고리즘이 또 있을까 하는 생각이 듭니다.

하지만, 중간값을 기준으로 데이터를 반으로 갈라 놓고, 양측에 대해서 재귀적으로 정렬을 또 수행한다는 발상은 깔끔하고 멋집니다. 이런 걸 분할 정복법이라고 하지요. 이게 '퀵 정렬'이 아니었으면 '이분 검색'을 따라 '이분 정렬'이라는 이름이 붙었을 것입니다.

퀵 정렬은 본디 재귀적으로 정의되지만, 사용자 정의 스택을 구현해서 비재귀적으로 만들 수도 있습니다. 또한, 원소 개수가 한 자리 수로 떨어졌을 때는 또 재귀호출을 하는 게 아니라 삽입 정렬을 해서 능률을 극대화하기도 합니다.

병합 정렬
O(n log n)인 정렬 알고리즘 중에 가장 간단하고 쉽게 떠올릴 수 있는 방법입니다. 퀵 정렬이 큰 리스트를 반씩 쪼갠다면, 이 방법은 이미 정렬이 된 리스트를 하나 둘씩 합쳐서 작업을 수행합니다. 이 알고리즘은 소요 시간이 데이터 상태에 별 영향을 받지 않고, 시간 복잡도가 O(n log n)인 알고리즘 중에 유일하게 안정성이 있다는 데 의미를 둘 수 있습니다. O(n^2) 알고리즘들은 모두 안정성이 있지만.. 쿨럭~

병합 정렬의 큰 결점은 데이터 전체 크기만한 메모리가 더 필요하다는 점입니다. 아주 현학적인 방법으로 한 배열 안에서 병합을 구현하는 방법도 있긴 하지만, 밀고 당기고 하는 과정으로 인해 속도가 크게 떨어지기 때문에, 메모리를 아끼려면 차라리 아래에 나오는 힙 정렬을 쓰는 게 더 낫습니다.

무조건 2의 배수씩 리스트를 합치는 게 병합 정렬의 기본 원리지만, 리스트에서 오름차순인 부분만 골라내서 지능적으로 병합을 하는 방법도 생각할 수 있습니다. 또한 퀵 정렬과 비슷한 원리로 재귀판을 만들 수도 있지요.

힙 정렬
이진 완전 나무를 배열에다 접목시킨 절묘한 알고리즘입니다. 이 알고리즘을 뜯어 보면 절로 감탄이 나옵니다. 처음에는 나무 아래에서 위(뿌리)로 각 원소들을 최대값 힙 조건에 맞게 정리한 뒤, 나무 뿌리에 있는 자료를 차례차례 나무 뒤로 옮기면서 힙을 정렬된 배열로 바꿉니다. 뿌리에는 힙 나무 맨 뒤에 있던 원소가 왔다가, 다시 힙 조건에 맞는 위치로 내려가지요.

시간 복잡도가 O(n log n)인 정렬 알고리즘 중에서는 부가적인 메모리가 전혀 필요없다는 게 힙 정렬의 큰 장점이지만, 하지만 수행 속도가 동급 O(n log n) 알고리즘들에 비해서는 약간(아주...) 낮은 편입니다.

기수 정렬
기발함 그 자체입니다. 네 자리 수가 있으면, 백 자리, 십 자리, 일 자리 순으로 차례차례 정렬을 한다는 게 기본 전략입니다. 저는 이 알고리즘을 이해하고 나서도, "그렇게 해서 어떻게 실제로 정렬이 되는데?" 이걸 이해하는 데 한참 시간이 걸려야 했습니다.

이 정렬법은 비교 연산을 하지 않으며, 무엇보다도 시간 복잡도가 O(n)입니다. 물론 데이터 전체 크기에 기수 테이블의 크기만한 메모리가 더 필요하지요. 기수 정렬은 정렬 방법의 특수성 때문에 부동소숫점처럼 특수한 비교 연산이 필요한 데이터에는 적용할 수 없지만, 매우 특이하고 멋진 알고리즘임은 틀림없습니다.

[CODE] #include <stdio.h> #include <time.h> #include <stdlib.h> #include <string.h> class CTimeRecorder { time_t& m_rWriteTo, m_dwBegin; public: CTimeRecorder(time_t& rTo): m_rWriteTo(rTo), m_dwBegin(clock()) { } ~CTimeRecorder() { m_rWriteTo=clock()-m_dwBegin; } }; template<typename T> void Swap(T& a, T& b) { T c; c=a; a=b; b=c; } template<typename T> class CSortCollection { T *m_pData; int m_nCount; time_t m_dwElapsed; public: //Construction CSortCollection(T *pArr, int nCnt): m_pData(pArr), m_nCount(nCnt) { } void Init(T *pArr, int nCnt) { m_pData=pArr, m_nCount=nCnt; } //Operation void BubbleSort(); void SelectionSort(); void InsertionSort(); void ShellSort(); void QuickSort(); void MergeSort(); void HeapSort(); void RadixSort(); //Elapsed time time_t GetElapsedTime() const { return m_dwElapsed; } int Verify(); }; template<typename T> int CSortCollection<T>::Verify() { int i; for(i=0;i<m_nCount-1;i++) if(m_pData[i]>m_pData[i+1]) return i; return -1; } template<typename T> void CSortCollection<T>::BubbleSort() { int i,j, flag=1; CTimeRecorder rec(m_dwElapsed); for(i=0;i<m_nCount && flag;i++) for(j=flag=0;j<m_nCount-i-1;j++) if(m_pData[j]>m_pData[j+1]) { flag=1; Swap(m_pData[j], m_pData[j+1]); } } template<typename T> void CSortCollection<T>::SelectionSort() { int i,j,k; CTimeRecorder rec(m_dwElapsed); for(i=0;i<m_nCount-1;i++) { k=i; for(j=i+1;j<m_nCount;j++) if(m_pData[k]>m_pData[j]) k=j; Swap(m_pData[k], m_pData[i]); } } template<typename T> void CSortCollection<T>::InsertionSort() { int i,j; T r; CTimeRecorder rec(m_dwElapsed); for(i=1;i<m_nCount;i++) { for(j=i-1, r=m_pData[i];j>=0 && m_pData[j]>r;j--) m_pData[j+1]=m_pData[j]; m_pData[j+1]=r; } } template<typename T> void CSortCollection<T>::ShellSort() { int i,j,k,l; T r; CTimeRecorder rec(m_dwElapsed); for(i=1;i<m_nCount;k=i, i=i*3+1); do { for(l=0;l<k;l++) for(i=l+k;i<m_nCount;i+=k) { for(j=i-k, r=m_pData[i];j>=l && m_pData[j]>r;j-=k) m_pData[j+k]=m_pData[j]; m_pData[j+k]=r; } k=(k-1)/3; } while(k>=1); } template<typename T> void CSortCollection<T>::QuickSort() { CTimeRecorder rec(m_dwElapsed); //sorting boundary, pivot index, and traveling pointers for partition step int lo, hi, mid, loguy, higuy; //stack for saving sub-array to be processed int lostk[40], histk[40], stkptr=0; lo=0; hi=m_nCount-1; //initialize limits while(1) { mid=lo+( ((hi-lo)+1) /2); //find middle element Swap(m_pData[mid], m_pData[lo]); //swap it to beginning of array /* Would it be better to use insertion sort, when hi-lo is very small? for(loguy=lo+1; loguy<=hi; loguy++) { for(higuy=loguy-1, r=m_pData[loguy]; higuy>=lo && m_pData[higuy]>r; higuy--) m_pData[higuy+1]=m_pData[higuy]; m_pData[higuy+1]=r; } */ loguy=lo; higuy=hi+1; while(1) { do loguy++; while (loguy<=hi && m_pData[loguy]<=m_pData[lo]); do higuy--; while (higuy>lo && m_pData[higuy]>=m_pData[lo]); if(higuy<loguy) break; Swap(m_pData[loguy], m_pData[higuy]); } Swap(m_pData[lo], m_pData[higuy]); //put partition element in place if( higuy-1-lo >= hi-loguy ) { if(lo+1<higuy) { //save big recursion for later lostk[stkptr]=lo; histk[stkptr]=higuy-1; ++stkptr; } if(loguy<hi) { lo=loguy; continue; } //do small recursion } else { if(loguy<hi) { //save big recursion for later lostk[stkptr]=loguy; histk[stkptr]=hi; ++stkptr; } if(lo+1<higuy) { hi=higuy-1; continue; } //do small recursion } --stkptr; //pop subarray from stack if(stkptr>=0) { lo=lostk[stkptr]; hi=histk[stkptr]; } else break; //all subarrays done--sorting finished. } } template<typename T> void CSortCollection<T>::HeapSort() { CTimeRecorder rec(m_dwElapsed); int i,j; T *dt=m_pData-1, root; //dt is a 1-based index for m_pData //construct the heap. for(i=m_nCount/2;i>=1;i--) { root=dt[i]; for(j=2*i;j<=m_nCount;j<<=1) { if(j<m_nCount && dt[j]<dt[j+1]) j++; if(root>=dt[j]) break; dt[j/2]=dt[j]; } dt[j/2]=root; } //Perform sorting wow~ for(i=m_nCount;i>0;) { Swap(dt[1], dt[i]); i--; root=dt[1]; for(j=2;j<=i;j<<=1) { if(j<i && dt[j]<dt[j+1]) j++; if(root>=dt[j]) break; dt[j/2]=dt[j]; } dt[j/2]=root; } } template<typename T> void CSortCollection<T>::MergeSort() { int i,j,a,b,c,d; CTimeRecorder rec(m_dwElapsed); T *pTmp=new T[m_nCount], *orig=m_pData, *dest=pTmp; for(i=1;i<m_nCount;i<<=1) { for(j=0;j<m_nCount;j+=(i<<1)) { //for each fragment, d=j+(i<<1); if(d>m_nCount) d=m_nCount; if(j+i>=m_nCount) { //Copy the remaining elems for(a=j;a<m_nCount;a++) dest[a]=orig[a]; break; } for(a=c=j,b=j+i; c<d; c++) if((orig[a]<=orig[b] && a<j+i) || b==d) dest[c]=orig[a], a++; else dest[c]=orig[b], b++; } Swap(orig, dest); } if(orig!=m_pData) memcpy(m_pData, orig, sizeof(T)*m_nCount); delete []pTmp; } #define BITOF(i,b) ((unsigned char *)orig)[i*sizeof(T)+b] //#define BITOF(i,b) ((orig[i])>>(b*8))&0xff template<typename T> void CSortCollection<T>::RadixSort() { CTimeRecorder rec(m_dwElapsed); int b,i, count[256], index[256]; T *pTmp=new T[m_nCount], *orig=m_pData, *dest=pTmp; for(b=0;b<sizeof(T);b++) { memset(count, 0, sizeof(count)); for(i=0;i<m_nCount;i++) count[ BITOF(i,b) ]++; index[0]=0; for(i=1;i<256;i++) index[i]=index[i-1]+count[i-1]; for(i=0;i<m_nCount;i++) dest[index[BITOF(i,b)]++]=orig[i]; Swap(orig, dest); } if(orig!=m_pData) memcpy(m_pData, orig, sizeof(T)*m_nCount); delete []pTmp; } #undef BITOF #define N 1000000 int main(int argc, char* argv[]) { srand(time(0)); int *arr=new int[N], *ar2=new int[N], i,j; for(i=0;i<N;i++) arr[i]= rand()|(rand()<<16); CSortCollection<int> sor(ar2, N); for(i=3;i<8;i++) { memcpy(ar2, arr, sizeof(int)*N); for(j=0;j<10;j++) printf("%d ", ar2[j]); puts(""); switch(i) { case 0: sor.BubbleSort(); printf("BubbleSort: "); break; case 1: sor.SelectionSort(); printf("SelectionSort: "); break; case 2: sor.InsertionSort(); printf("InsertionSort: "); break; case 3: sor.HeapSort(); printf("HeapSort: "); break; case 4: sor.QuickSort(); printf("QuickSort: "); break; case 5: sor.MergeSort(); printf("MergeSort: "); break; case 6: sor.ShellSort(); printf("ShellSort: "); break; case 7: sor.RadixSort(); printf("RadixSort: "); break; } j=sor.Verify(); if(j!=-1) printf("Error: %d %d ", j, arr[j]); printf("%.3g sec ",sor.GetElapsedTime()/(double)CLOCKS_PER_SEC); for(j=0;j<10;j++) printf("%d ", ar2[j]); puts(" "); } delete []arr; delete []ar2; return 0; }[/CODE]

실행 결과 (1)
32비트 정수 100만 개를 정렬한 결과와, 그 소요 시간입니다. O(n^2)인 알고리즘들은 정렬이 끝날 때까지 도저히 기다릴 수 없어서 일부러 테스트를 하지 않았습니다.

1707157587 317341677 662390333 1176788126 378630338 159730414 512518995 1082726135 929839362 1624122230
HeapSort: 1.13 sec
187 748 1097 3231 5311 6829 7012 7180 8351 8470

1707157587 317341677 662390333 1176788126 378630338 159730414 512518995 1082726135 929839362 1624122230
QuickSort: 0.551 sec
187 748 1097 3231 5311 6829 7012 7180 8351 8470

1707157587 317341677 662390333 1176788126 378630338 159730414 512518995 1082726135 929839362 1624122230
MergeSort: 0.962 sec
187 748 1097 3231 5311 6829 7012 7180 8351 8470

1707157587 317341677 662390333 1176788126 378630338 159730414 512518995 1082726135 929839362 1624122230
ShellSort: 1.59 sec
187 748 1097 3231 5311 6829 7012 7180 8351 8470

1707157587 317341677 662390333 1176788126 378630338 159730414 512518995 1082726135 929839362 1624122230
RadixSort: 0.26 sec
187 748 1097 3231 5311 6829 7012 7180 8351 8470


실행 결과 (2)
32비트 정수 3만 개를 정렬한 결과와, 그 소요 시간입니다.

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
BubbleSort: 7.82 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
SelectionSort: 3.11 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
InsertionSort: 1.42 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
HeapSort: 0.01 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
QuickSort: 0.01 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
MergeSort: 0.02 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
ShellSort: 0.04 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1763461794 1133465913 202967127 1135746381 1504003220 1905358894 1992839703 1334061861 1454975500 966069090
RadixSort: 0 sec
96019 155288 163134 217965 275100 337903 355310 399329 596835 618801

1. 일년에 한번쯤은 해가 뜨는 광경을 본다.
(내 문제가 다소 하찮게 느껴지면서 힘이 솟는다.)

2. 꽃한송이,작은정성,맑게 개인날 아침햇살,주변의 작은일에 감동을 한다.
(감동을 많이 할수록 체내항생제가 많이 생겨 건강에 도움이 된다.)

3. 웃음은 낙천적인 사람의 트레이드 마크다.
(미소에 자신이 없다면 거울 앞에서라도 웃는다.)

4. 샤워를 할땐 노래를 부른다. (외국영화에서 처럼..)

5. 봄이 되면 꽃을 심는다.
(꽃이 피기까지 몇달간의 과정을 지켜봄으로서 인내를 배우고 꽃이란 결과를 봄으로서 생애에 대한 신뢰를 얻는다.)

6. 직접 연주할수 있는 악기를 하나쯤 배운다.

7. 만화를 읽는다. (만화를 포기하는것은 창조성,유머,젊음을 포기하는것이다.)

8. 길가다 빈자리가 있다면 앉아 지나가는 행인들을 지켜본다.
(타인의 삶을 상상할수 있는 좋은기회다.)

9. "안녕하세요""감사합니다""죄송합니다"를 자주쓴다.

10. 지금 느낄수 있는 기쁨을 뒤로 미루지 않는다.

11. 화가 치밀면 한시간 정도 여유를 갖고 화를 식힌후 상대를 대한다.
(중요한 일이라면 하루정도 생각할 여유를 갖는다.)

12. 아이들과 놀때는 반드시 져 준다.

13. 부정적인 사고를 하는 사람을 피한다.

14. 하고싶은일을 절대로 포기하지 않는다.
(대망을 가진자가 현실적인 사람보다 강하다.)

15. 좀더 느긋해지자.
(당장 사느냐 죽느냐가 걸려있는 일이 아니라면 그다지 급한일이란 아무것도 없다.)

16. 성공의 척도를 자신이 현재 느끼는 마음의 평화, 건강, 그리고 사랑에둔다.

17. 인생이 공평할것을 기대하지 않는다.

18. 수입의 일정액을 남을 돕는데 사용한다.

19. 남을 부러워 하지 않는다. (시샘은 불행을 낳는다.)

20. 죽어도 후회가 없을 만큼 열정적으로 산다.

21. 행복은 권력,부,명예와 무관하다는 사실을 받아들인다.
(행복은 내가 사랑하는 사람들과 나와의 관계에서 온다.)

22. 전화를 받을때는 항상 활기찬 목소리로 받는다.
(마찬가지로 울적할땐 전화를 하지않는다.)
(꼭 해야한다면 간단한 체조라도 한 뒤에 활기찬 목소리로 한다.)

23. 마음에 드는일이 있으면 실리를 따지지 않고 일단 시작한다.
(내가 좋아서 하는일이라면 곧 느낌이 전달돼 손해 볼일은 없을테니까.)

24. 남이 말하는 도중에 끼어들지 않는다.

25. 사람들 앞에서 돈얘기를 하지 않는다.

26. 잘못한일에는 반드시 용서를 구한다.
(용서받지 못할,용서하지 못할 마음이상 무거운게 있을까?)

27. 문제가 생기면 최악에 대비하고 최선을 바란다.

28. 나를 위해 작은 투자를 한다.
(새 잠옷,새 양말,꽃한송이,내가 있어야 세상도 있음을 자각한다.)

29. 한달에 한번쯤은 나 혼자 외출을 한다.
(특별한 할 일이 없는 외출에서 의외로 나의 자신감을 만날수도 있으니까.)

30. 마지막으로 가장 중요한 한가지!! 잠을 충분히 잔다.


- 몇가지는 평소에도 하는데 초공감 ㅋㅋㅋ -

관리자 글의 비밀번호를 알아내는 문제ㅋ

문제는 간단 명료합니다 과정은 조금 복잡하지만..

글이나 아무거나 올리셔도 됩니다.

남에게 피해만 안주면 됩니다. ^^

대부분 학습예제용? 혹은 엉성한? 게시판에 적용되는 문제입니다.


힌트를 드리자면 푸는 과정에서 살짝의 추측?이 필요해요.

하지만 생각해 본다면 보통 그 경우의 수가 5가지도 안되니까 확인해보면 알지요.

길게쓴다면 ******** 이겠고, 짧게는 **, ****, ***, ****** 등이 되겠죠.

뭐 이거야 센스니.. 이정도는 삽질도 아니죠 '-'

이외에 힌트는 따로 안드리겠습니다.

그러한 성격의 문제이기 때문입니다.

그러한 것을 풀자고 낸 문제이기 때문입니다


그리고 게시판의 제공자 '백찬호'님께 감사드려요. ^^


문제 : http://azki.org/cathole3/quest.php?q=9

랭크 : http://azki.org/cathole3/rank.php?t=q&q=9

코멘트 : http://azki.org/cathole3/rank.php?t=c&q=9

이 문제 대해 하실 말씀이 있으시면 밑에 답글 다세요. // 답이나 힌트는 올리지 마세요.

마비


시험친 다음 날
컴퓨터 소리 없이
아침에
혼자 눈을 뜨게 된거야

실감이 안나
마비노기 켜보니
길드원들은
우리 길드원들은

그대로
있는데 여기있는데
어떡해, 벌써 난 접었는데
이젠 지워야겠지
모두 지워야겠지
웃는 나의 캐릭을
행복한 에린 세계를

한 파일
마비 지울때마다
가슴이 아려와
나의 에린이 점점흐려져

에린 속
길마 불러도 보고
스샷 만져도 보고
너무 잔인한 일이야

마비 지우는 일


그대로
있는데 웃고있는데
에린 속
니가 웃고있는데
이땐 행복했나봐
이땐 몰랐었나봐
에린 좋았었는데
에린 좋았을텐데

한 장씩
스샷 지울 때 마다
가슴이 아려와
나의 에린이 점점 흐려져

에린 속
길마 불러도보고
스샷 만져도보고
너무 잔인한 일이야
마비 지우는 일

이젠 눈감고
난 지워
어차피 나는 망한 거잖아
이젠 눈감고
난 지워
마지막 스샷 한 장뿐

마지막
에린 속 세상 보여
너무 아름다워요

이제 다시는 볼수없음에
한번더
나오 불러도 보고
나오 만져도 보고
너무 잔인한 일이지

나는 마비 지웠어

여우도 좋아 *-_-*


생텍쥐베리의 동화 '어린왕자'에 등장했던 사막여우 '-'


세계적 희귀종 사막여우.. orz

같이 살고 싶은데 -_-

무리일려나..

※ 가짜와 진짜.. 글구 아즈키..

은근 옛날에 썼던 글인데.. (2003/07/09)

다시 쓰기 귀찮아 그냥 퍼왔다.

다시 쭉 보니 뭔가 많이 웃기다. -_-;

쪽팔리기도하고 많이이상타.. 어째뜬 과거를 부정하지 않는의미?로 그냥 그대로 올린당

어째뜬 책상에는 아직도 아무것도 없구나..

아니 책상이 없다 -_-

요샌 식탁에서 노트북 사용중ㅋㅋ





가짜 : 책상에 온통 책으로 덥혀있다. 자세히 보면 웹부터 시스템 프로그래밍까지 동내서점같다. 그런 자기 책상을 보며 자랑스러워 한다.
진짜 : 책상에 담배재와 잡동사니만 굴러다닌다.
아즈키 : 책상에 아무것도 없다...-_-;;

가짜 : 모르는것이 있을때는 여기저기 관련 사이트에 Q&A에 질문을 올리고 답변을 기다린다.
진짜 : 모르는것이 있을때는 Q&A를 뒤져보고 없으면 깡으로 만든다.
아즈키 : 정말 모르면 깡으로만함....실력은 없음..-_-; Q&A에 질문은 귀찮아서 안하구 찾기만 한다..-_-;;

가짜 : 짜본것보다 아는게 더 많타
진짜 : 아는것보다 짜본게 더 많타
아즈키 : 아는 것도 없고 짜본것도 없다..-_-;

가짜 : 직업을 물어보면 프로그래머라고 당당하게 말한다.
진짜 : 직업을 물어보면 우물쭈물 하다가 상대에 따라 , 자꾸 자세히 물어보면 등 프로그래머라는 말을 피한다.
아즈키 : 물어보면 학생이라구 한다..-_-;

가짜 : 부탁하면 머든지 한다. 물론 끝까지 한다는 보장은 없다.
진짜 : 부탁하면 곤란한 표정을 짓는다. 어쩔수 없이 하게되면 수단과 방법을 안가리고 끝을 본다.
아즈키 : 곤란한 표정 짓고 어쩔수 없이 못한다..-_-;

가짜 : 컴퓨터 관련은 뭐든지 물어보면 모르는게 없다. 아주 성의있게 요목조목 설명해준다.
진짜 : 물어보면 아는게 없다. 중요한 질문이나 확실히 아는것만 간단하게 말한다.
아즈키 : 솔직히 가짜쪽이다..-_-

가짜 : 다른사람이 잘 공부하지 않는 분야를 익히면 자신이 그분야 전문가가 된줄 안다. 그러나 기술을 재대로 써보지는 못한다.
진짜 : 다른사람이 잘 공부하지 않는 분야는 쓸모가 없기 때문이기에 배우지 않는다. 반드시 필요하면 대강 배워서 쓰고 잊어버린다.
아즈키 : 다른사람이 잘 공부하는 분야건 안하는 분야건.. 대강 배워서 쓰고 잊어버린다. -_-

가짜 : 시간만 나면 관련 게시판 TIP이나 강좌를 읽으면서 외공을 연마하여 자랑하고 다닌다.
진짜 : 시간 나면 가끔식 자료구조,알고리즘,인공지능학, 영상처리학등 개론서를 들어보면서 내공을 연마한다. 누가 물어보면 논다고 한다.
아즈키 : 이런 것들은 전혀 하지 않는다...-_-

가짜 : 클래스만 쓰면 OOP프로그램인줄 안다.
진짜 : 마음만 먹으면 프로그램을 비지오로도 짤수도 있다.
아즈키 : 아..클래스만 쓰면 OOP 인게 아니였구나...-_-;;

가짜 : 100만큼 배워서 10만큼 쓴다.(C/C++/API/MFC/VB바이블을 쓸수 있을정도로 알고 있어
도 프로그램은 1000줄이상 못짠다.)
진짜 : 10만큼 배워서 1000만큼 쓴다.( if문만 배워도 만든다.)
아즈키 : 1600줄 짜리 코딩해봤음... 하하하 난 진짠가봐...<-가짜보다 더 심한 가짜새끼임..-_-;

가짜 : 자신이 프로그래밍에 소질이 있다고 생각한다.
진짜 : 자신은 프로그래밍에 소질이 없다고 생각한다. (입버릇처럼 때려치울꺼라고 하면서 부지런히 짠다.)
아즈키 : 나름대로 짜다보면 정말 자신이 바보 같아짐...-_-; 맨날 짜다보면, 한참 짜고나면.. 알고리즘이 언제나 마음에 들지 않아 자책...ㅡㅜ

가짜 : 코딩할때 타자속도가 600타 이상 나오며 부지런히 친다.
진짜 : 한참 담배피다 300타 이하 속도로 몇자치고 또 담배핀다.
아즈키 : 물론 300타 안나온다..-_-; 아니 정확히 말하자면 못합니다..ㅡㅡ;;

가짜 : 마지막 10%가 고비다.
진짜 : 처음 10%가 고비다.
아즈키 : 나름대로 처음이 고비...-_-; 물론, 추진력등의 문제가 아니구..머리가 나뻐서 어떻게 짜야될지 전혀 발상이 안된다. ㅡㅡ;

가짜 : 빌게이츠,리누스,잡스등 IT유명인들에 관심이 많고 때론 동경한다.
진짜 : 아무 관심없다.
아즈키 : 별 관심 없음...-_-; 미래에 대해 전혀 대책없는... 바보임..ㅡ_ㅜ

가짜 : 언제나 최신 컴퓨터에 최고급 사양으로 유지하고 잡다한 부품이나 오버클럭등에 관심이 많타
진짜 : 컴파일러가 뜨는데 지장 없으면 컴퓨터에는 관심 없다. 스피커에만 관심을 가진다.
아즈키 : 대략 짜놓고 오류만 안뜨면 된다..-_-; 대략 스피커에 마저도 관심이 없다는..-_-; 대략 하드디스크쪽에는 관심있음...왜냐면 소중한 나의 자료들을 넣어놔야 되니까..^^;

가짜 : 최적에 작업 환경을 요구한다.(조용하고, 남의 시선이 안닫고 구석진곳등등..)
진짜 : 컴퓨터만 있으면 작업한다.
아즈키 : 물론 컴터만 있음 만사 오케이다..ㅋㅋ 물론 작업보다는 딴짓을 많이 하지만..-_-;;

가짜 : 알고 있는 모든 프로그램이 다 깔려있다. 깔면 다 사용할수 있다고 생각한다. 물론 나가서도 그렇게 말하고 다닌다. 윈도우 태마나 바탕화면등에 신경을 많이쓴다.
진짜 : 아무 관심없다.
아즈키 : 윈도 테마나 바탕화면엔 나름대로 관심..+_+ 알고 있는 모든 프로그램 다 깔아 두면 좋겠당..+_+ (가짜 지향적 사고방식..-_-;)

가짜 : 심심하면 인터넷에서 특이한 테크닉 소스나 완성된 프로그램 소스를 구해서 구경고 누가 물어보면 자신이 짰다고 말한다.
진짜 : 필요하지 않타면 남의 소스에 관심 없다.
아즈키 : 남의 소스 백개 찾아서 한줄씩 배껴서 잘 짜맞춰서 100줄짜리 프로그램 완성하는거 좋아함..-_-;

가짜 : 가능한한 남이 못알아 보게 짠다. 물론 주석도 안단다.
진짜 : 가능한한 남이 알아보기 쉽게 짠다. 주석은 가끔식 단다
아즈키 : 남이 알아보기 힘들다...-_-; 그래서 주석은 프로그램 완성후 마지막에 웬만하면 달아준다. 남을 위해서가 아니라 내가 나중에 절대 못알아 보기 때문에..(자기가 짜놓고도 자기가 못알아 보는 바보임..-_-;)

가짜 : Q&A게시판에서 조금이라도 들어본 질문이 올라오면 다 아는듯 답변을 단다.
진짜 : 게시판을 잘 이용하지 않는다.
아즈키 : 이건 가짜쪽임...-0-; (알지도 못하면서 아는척하기..짱! -_-;)

가짜 : 온갓 유명 컴퓨터 서적과 잡지를 부지런히 사다 모은다.
진짜 : 가끔식 잡지나 한번씩 사고, 절판되었거나 절판직전 책을 어렵게 구해다 본다.
아즈키 : 젠장...아무것도 안본다..-_-;; 담에 기회가 되면 잡지나 구독원츄다. ㅇㅇ/

가짜 : 책의 목차와 앞에 몇패이지만 본다. 그러면 그 책을 다봤다고 생각한다..
진짜 : 목차도 보지않는다. 가끔식 뒤에 색인만 살핀다.
아즈키 : 중간중간 필요한거만 봐서 앞에 중요하고 기본적인 내용들 조차 모른다. 결국 나중에 프로그램 짤때 망한다..-0-;

가짜 : 가짜들 끼리 모이면 잘 될줄 안다.
진짜 : 진짜들 끼리 모이면 잘 안된다.(가짜가 좀 끼어있어야 한다.)
아즈키 : 내가 껴있으면 잘 안된다..-_-;

가짜 : 가짜가 하는모습을 동경하고 따라할려고 한다.
진짜 : 가짜처럼 살려고 노력한다.
아즈키 : 나름대로 진짜를 동경하고 있다..+_+

진짜와 가짜가 만나서 프로그래밍 이야기를 하면....
가짜 : 입으로 프로그램을 짠다. (현란한 첨단기술은 다써서)
진짜 : 머리로 다짜고 컴파일 시켜서 컴파일된 결과만 말한다. ( if/for만 써서)
아즈키 : 엄청 허접하게 짜서 컴파일된 결과만 말한다. (예를 들자면, 피라미드나 다이아몬드
모양 만들때 프린트문만 쓴다. 그러므로 소스는 공개할수 없다..-_-;)

가짜 : VC를 조금이라도 하면 VB하는 사람은 다 자기보다 프로그램 못짜는 줄 안다.
진짜 : 프로젝트에 최적의 언어를 선택한후 개발한다.(주특기는 있지만 특정 언어만 쓰지 않
는다.)
아즈키 : 아싸...VC 못한다..-_-; 젠장 VB 도 어렵더만..무시하지 마요..ㅡㅜ

가짜 : 왠만하면 VC로 짠다. VB로 프로그램 짜고 있는 사람을 보면 VC몰라서 VB로 짜는줄 안
다.
진짜 : 왠만하면 VC 안쓰려고 노력한다.
아즈키 : VC 못하니 당연히 안쓸려구 노력한다..-_-; 물론 딴것도 할줄 아는게 없다..ㅡㅜ

가짜 : DirectX를 다 익히면 게임 만들수 있을줄 안다.
진짜 : DirectX를 다 모른다. 그러나 필요하면 게임은 만든다.
아즈키 : 아싸.. 뭔소린지도 모르겠다...-_-;



/* 출처: POCS 게시판 */

웬지 디자인이 좋아서.. -_-;
특히 주황색 글자와.. 고정된 배경...등등.. 완전 내스타일(이상형)임..-_-*

http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp1.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp2.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp3.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp4.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp5.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp6.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp7.html
http://nlp.korea.ac.kr/~kjlee/knowledge/part2/cpp/c_to_cpp8.html


뭔가 옛날꺼라서 링크도 많이 깨졌심 -ㅁ-

"Perfection [in design] is achieved not where there is nothing more to add, but rather when there is nothing more to take away."

- Antoine De Saint-Exupery -


"I think that is not only in design, but in programming."
"Because programming is a creative art, same as design."

- azki -

[플래시 보기..]

완전 홀릭해버린 플래시

ㅋㅋㅋㅋㅋ