이코의 세상 Season 1

옼플군은 나와 생년월일이 같은 친구다.

참.. 특이한 정신세계을 가지고 있는데,

오늘 대화를 정리하다보니, 나도 만만치 않다는걸 느꼈다.

옼플: 잌 너 책 많이봐?
잌군: 왜?
옼플: 흠..
옼플: '교도소명'교도소의 하루 라는 책이있는데 교도소명을 몰라서 뭔 책인지 못찾는중 orz.. 지금 한시간째야 T^T
잌군: "00교도소의 하루? "라는 책이있다고?
옼플: 어 외국 고전소설
잌군: 그거 찾기가 힘든가;
옼플: 검색하면 책이 너무많이나와서 찾아볼 엄두가안나 ㄷㄷㄷ
잌군: =_=a... 없는데?
옼플: -_- 그바
잌군: ....; 외국소설이야?
옼플: 어, 외국고전소설
잌군: 우리학교 도서관에도 "교도소"로 검색해도 외국소설은 없는데?
옼플: ㅡ.ㅡ;;; 아니삼.. 있으삼
잌군: jailbird?
옼플: -_-;
잌군: 흐음....
옼플: 설마.. 도스토예프스키!!?
잌군: .;;
옼플: 설마 교도소가 아니라 감옥이라면 울어버릴거야
잌군: 도스토예프스키로 찾아봤는데 그딴거 없어
옼플: 그럼 도스아저씨도아닌건가 ㅡ.,ㅡ
잌군: 아.... 설마 수용소의 하루 아냐?
옼플: 허어억!! 수용소라니!!
잌군: 이반 데니소비치의 소용소의 하루
옼플: 아, 신발.. 그거였냐.. ㅡ,.ㅡ
잌군: 삐리리~
옼플: 도스아저씨도아니었네... 어제 술마시면서 들어서 가물가물했나봐 orz
옼플: 오오오~ 땡큐베리캄사~

밥이 먹고싶다...
밥을 먹은지 오래되었다.




1일째: 저녁은 간단하게 STEFF핫도그로..

2일째: 아침은 빵한조각, 점심은 굶고 저녁은 햄버거

3일째: 아침을 굶고 점심은 라면, 저녁도 라면

4일쨰: 아침 굶고 점심 샌드위치, 저녁 햄버거와 닭꼬치

5일째: 아침은 늦게 일어나서 패스, 점심은 짜장면과 탕수육, 저녁은 삼각김밥

....


OTL (밥이 먹고싶어 ㅠ0ㅠ)

속눈썹님의 블로그에서 트랙백: http://ilashman.cafe24.com/5393

OTP (One Time Password) Device라는것이 인터넷 뱅킹에서도 사용이 되고 있네요.
One Time Password란 한번만 사용할 수 있는 패스워드로, 보통 로그인 방식이 매번 같은 id와 같은 password를
사용하는 방식이라면 OTP는 이런것이죠.

이렇게 매번 다른질문으로 사용자에게 질문을 하면 사용자는 그에 맞는 password를 입력함으로서
다른사람이 합법적 유저가 한 행위를 똑같이 반복함으로서 인증수단이 무효화되는 것을 방지하려는 거죠

오늘 속눈썹님의 블로그에서 재미있는 글을 봤습니다. HSBC의 OTP라고 해서 뭔가하고 봤는데...

이렇게 생긴 장치더군요. 속눈썹맨님의 궁금해 하신건

과연 이 device가 자체적으로 통신을 해서 HSBC와 password를 주고 받느냐 인데..

결론부터 말씀드리자면 "제 생각엔 아닙니다." 입니다.

만일 OTP라는게 One Time Password의 줄임말이라면 말이죠..



HSBC의 홈페이지에 가보니 OTP를 맨처음 사용할 때 뒤에있는 바코드의 일련번호를 입력해서 등록하는게 나오는데, 이것은 각각의 device에 저장된 6자리 password의 목록일꺼라 생각됩니다.

이런식으로 서버에 저장이 되어있겠죠, 꼭 번호가 다 틀리지 않아도 순서만으로도 다른 OTP가 만들어 질 수 있는겁니다. 하지만 그것도 어느정도의 범위가 지정되어 있겠죠, 앞뒤 50개사이에는 각각의 OTP가 같은 값을 가질수 없다 라던지 하는...

그리고 여러번 눌러놓고도 패스워드가 다 입력이 가능했다는것은 사용자의 실수를 만회하기 위해서 어느정도 여유를 둔것 같네요, 마지막 입력한 패스워드의 앞뒤 10개정도면 입력해도 받아들일수 있도록 말이죠...

어디까지나 제 생각입니다만..ㅋ 궁금하신게 해결되셨나 모르겠네요.


여담입니다만, 저게 통신이 가능하다면 아마 은박지로 쌓아놓으면 전파가 방해되어서 사용이 불가능할겁니다.
아니면 핸드폰이 처지지않는 지하라던지, 이런곳에서는 통신이 된다면 동작이 불가능 하겠죠.

하지만 결국 통신을 하지 않는다면 저 OTP는 버튼을 누를때마다 이미 저장되어있는 번호를 순차적으로 보여주는 장치라는 것밖에 되지 않는다는 거죠. 아주 약간의 메모리(6.56Mb: 하지만 이것은 0부터 999999까지 모든수를 저장했을때)와 버튼 스위치 하나, 그리고 메모리에 있는것을 액정에 표시하는 회로만으로 구성되어져있는 싸구려 장치이라는겁니다. 사실 무슨은행이 이런거에다가 통신이 되는 걸 집어넣겠습니까.. 쓸때마다 돈나오고 은행측에서는 유지비가 장난이 아닐듯 싶은데요.ㅎㅎ

Linear Shifted Array Generator by !kKo

invalid-file

웹을 돌아다니다가 판타지 개그라는것을 발견..

아.. 너무 웃기다 ㅠㅠ

방금 구글에 들어가다가 신기한 것을 발견했습니다.

보통 google.com으로 접속하면 한국어 사이트로 이동을 해서 자동으로 google.co.kr로 변경이 되는데요,

신기한건

http://gogle.com
http://google.com
http://gooogle.com

위의 사이트로 모두다 접속을 해도 똑같이 google.com으로 연결이 된다는거죠.

구우글, 고글, 구글.. =_=ㅋ

재밌군요-ㅎㅎ


10.23 추가: wiziple님의 글로 인해 알게 된 사실
http://gogole.com
http://googel.com
http://ogogle.com

이것들도 모두다 구글로;;;

갑작기 일본어 몇마디를 번역하려고 했는데 인터넷에 찾아보니 여러가지가 있더군요

그중에서 제 목적에 가장 부합한 녀석을 찾았는데 저 혼자만 알고 있기가 뭐해서요..ㅋ

http://ocn.amikai.com/amitext/indexUTF8.jsp

일본의 OCN... 영화사이트(=_=..)가 아닌 Open Computer Network이라는 곳에서 제공하는 서비스 입니다.

NTT의 계열사인듯 싶군요-.

번역은 영어, 중국어(간체), 한국어를 일본어로, 또 그 반대도 가능합니다.

한번에 최대 4000자까지 가능하다니까 간단한 문서도 번역이 가능하겠군요.

평소 절친한(?) 친구인 지니님의 싸이월드에서 펌

●나는 이성을 10번 이상 사겨본적이 있다
- down

●내 키는 남자 178 (여자 165) 이상이다
- down

●내 주량은 2병 이상이다
- down

●나는 비밀을 털어놓을수 있는 친구가 7명 이상이다
- down

●나는 하루에 밥을 3끼 이상 먹는다
- down (두끼정도가 아닐까..)

●소개팅을 3번 이상 받아본적이 있다
- down

●나는 집에서 쫓겨나본적이 3번 이상 있다
- down (쫓겨나본적은 없어)

●지금까지 이성에게 고백을 받아본적이 3번이상 있다
- down인가..=_= 난 매력이 없나 ㅠㅠ

●내 전화부에는 80개 이상이 저장되어 있다.
- up

●나는 지금 현재 2만원 이상 갖고 있다
- up

●지금까지 살면서 가장 뚱뚱했을때의 몸무게는 남자 95 (여자 65) 이상이다
- down 아무리 쪄도 55이상은 무리..

●한달 용돈이 30만원 이상이다
- down

●가출 경험이 2번 이상 있다
- up (내딴엔 가출이였는데 아무도 인정을 안해준다=_= 모.. 반나절 가출한건 외출이라나..)

●가장 비싸게 주고 산 옷이 30만원이 넘는다
- down

●현재 내 핸드폰을 2년 이상 사용하고 있다
- down (집에 4년묵은 흑백 폴더는 있는데-ㅋ)

●앞으로 결혼은 30세 이후에 할것이다
- down 이지 않을까...

●내 애인과의 나이차 극복한계는 위 아래로 4살 정도이다
- down (난 동갑이 좋아)

●경찰서 출입을 3번이상 한적이 있다
- down (한번정도..? =_= 오해는 마시라 어렸을적에 길 잃어버렸는데 부모님이 경찰서에서 날 데려왔다더라..)

●헌팅을 당해본적이 3번 이상 있다
- down (헌...팅... 당해보고 싶어 ㅠㅜ)

●다룰줄 아는 악기가 2개 이상 있다
- up (그냥 기타, 드럼..정도?)

●내 장점을 3가지 이상 말할수 있다
- up

●현재 죽여버리고 싶은 사람이 5명 이상이다
- down (그냥 좀 없어졌으면 좋겠다는 사람은 가끔 있었지만 지금은 zero)

●목숨과도 바꿀수 있는 친구가 1명 이상이다
- down (내가 짱이야=_=)

●살면서 거짓말을 해본적이 5번 이상있다
- up (이건 대부분의 사람이 up일듯..)

●1년에 머리 스타일을 3번이상 바꾼다
- down

●하루에 흡연량은 한갑 이상이다
- down (안펴)

●자신의 이상형을 1번이상 만나본적이 있다
- up (지니말대로 이상형일뿐...=_=)

●키스를 5번 이상 해본적이 있다
- up (이거 중학교 앙케이트 같다=_=)

●주위로부터 괜찮게 생겼다는 소리를 3번 이상 들은적이 있다
- down (개성있다는 말은 많이 듣는다..ㅠㅠ)

●내 얼굴중 고치고 싶은 부분이 3군데 이상 있다
- down (생긴대로 사는거지 사는데 지장이 있거나 연애인이 아닐바에야=_=)

●최근 한달동안 울어본적이 3번 이상 있다
- down

●나는 애인이 아닌 그냥 이성친구가 3명 이상 있다
- up  (좀 많다)

●나는 친구한테 배신당해본적이 3번 이상 있다
- down

●나는 죽고싶은적이 2번 이상 있다
- up (자아가 완전히 형성되기 이전에 좀 많이 그랬다. 하지만 이젠 아냐)

●지금까지 이성에게 해준 선물중 가장 비싼것은 10만원 이상이다
- up

●이성에게 차여본적이 2번 이상있다
- down (차인건지 찬건지 구분안가=_=)

●술먹고 필름 끊겨본적이 3번 이상 있다
- down (한번도 없다)

●피자를 large크기로 5조각 이상을 먹을수 있다
- down (예전엔 많이 먹었는데 요새는 max 4조각;;)

●우리집에서 바퀴벌레를 2번 이상 본적이 있다
- up (가끔 휴지로 눌러준다=_=.. 바그작;;)

●길에서 시비가 붙어 싸워본적이 3번 이상 있다
- down (한번도 없다)

●누군가를 1시간 이상 기다려 본적이 있다
- up (하염없이 기다린다=_=)

●이 문제에 답하는데 1시간 이상 걸렸다
- down

HDD
--------------------
서버 80G, 40G
컴1 80G, 80G, 6.4G
컴2 10G
컴3 6.4G
안방 40G
동생 120G
백업 250G
남는거 40G, 40G, 20G, 2G, 1.2G, 340MB, 350MB, 300MB
=================
810.59Gb

Memory
-------------------
서버 512Mb
컴1 1G
컴2 128Mb
컴3 256Mb
안방 384Mb
동생 2G
남는거 16Mbx12
=================
4544Mb

Flash
-------------------
CF-512Mb
  1G
  16Mb
SD-2G
===================
3600Mb

CPU
-------------------
서버 1.5Ghz
컴1 3.0Ghz
컴2 600Mhz
컴3 1.0Ghz
안방 733Mhz
동생 2.8Ghz
남는거 ...pass
==================
9.633Ghz!!!


종합해보면...
CPU: 9.6Ghz
RAM: 4Gb
HDD: 810TB

역시나 말도 안되는 사양인가요-ㅋㅋ

얼마전 오픈한 미니채널에서 메일이 왔다. 설문조사를 참여해 달라는데,

이해가 가질 않는다. 베타테스터라고 명분을 달아놓고 우리가 무슨 설문조사하는 단체도 아니고

애초부터 이런식의 성의없는 메일하며 차일피일 미뤘던 오픈일 하며...

난 또 베타테스터라길래 뭔가 일반인들에게 공개하지 않은 다른 서비스가 있는줄 알았는데 웬걸?

어제 가입한놈이나 베타테스터를 신청한놈이나 다 똑같다라는 말이다.

웃긴건 베타테스터가 더 성가신게 이메일와서 읽어보면 설문조사 해달라는거다.

떡밥을 뿌려야 생선도 잡히는 거고, 요즘세상엔 오히려 경품을 줄테니 우리껄 써라 라는 식으로도 하는데

이놈의 미니채널은 이메일부터가 성의없다. 담당자의 말투가 원래 싸가지 없는 건지...

처음엔 설문조사가 왔길래 그냥 안하려고 했다.

내용이 이렇다면 당신은 설문조사를 하고 싶겠는지...

그래서 기분이 상해서 안하고 있다가 오늘 새로운 이메일이 날라왔다.

/*
Data Structure Assignment #3
Spring, 2006
Due Date: 2006. 5. 8. Monday 6:00 PM.

주어진 input sequence에 대하여 heap을 구성하여 array에 저장하고 이를 in-order(type 1), pre-order(type 2), post-order(type 3), level-order(type 4)로 저장하는 프로그램을 작성 하시오. 속도에 따라 점수가 부여된다. 따라서, heap은 array에 저장되어야 하고 traversal은 iterative한 방법을 사용해야 한다 (recursive한 프로그램은 0점 처리).

예:
? Input:
10 // number of item
2 // traversal type
1 3 20 61 91 123 8 71 32 21 // items

30
1
30 40 13 12 11 .....

:
:

-1 // end of input

첫 번째 input으로부터의 max heap은 다음과 같다.

   123
          /   /    \
71   /   91
     /      /
61  21  3  8
  /       /       \
  1    32    20

123719161213813220

? Output:
123 71 61 1 32 21 20 91 3 8 // preorder traversal (because traversal type = 2)
123 71 61 1 32 21 20 91 3 8
0.034 // 수행속도 (입출력 시간 제외, 소수점 3자리)

40 30 13 12 11 ....
0.040

.
제한 사항
1. Input item의 개수는 최대 100000개입니다.

2. Input은 C:\ass3_input.txt에서 입력 받아서 C:\학번_이름_반.txt에 출력하면 된다.
예)출력 파일 c:\200621094_홍길동_A.txt

3.제출시 파일명은 "학번_이름_반"으로 작성하세요. 여기서 반은 과제물 제출 게시판의 반입니다.(A,B,C) 실행 파일과  C파일 두 개를 올려주세요.
예) 200621094_홍길동_A.exe /200621094_홍길동_A.c

4.소스 파일과 실행 파일을 압축하지 말고 올려주세요.  

5. c:\ 폴더에 실행파일이 없을 경우에도 동작해야 합니다.

6.변동 사항이 있을 수 있으니 공지 사항을 꼭 확인해 주세요.

7.과제물 제출 시 반드시 비밀글을 체크하시고 올리셔야 합니다. 

*/
ac
#include<stdio.h>
#include<windows.h>

#define IN_FILE "c:\\ass3_input.txt"
#define OUT_FILE "c:\\200120993_이지황_B.txt"

struct time{
LARGE_INTEGER   st, ed, freq ;
  double          gap ;
  BOOL            bEnable;
  char            szName[256];
  UINT            counter;
  double          fTotal_Time;
}mytime;

struct dat{
int num; // number of input datas
int type;
int *heap, *temp, *out; 
}data;

void inorder(void) // when case 1,
{
int i=1, j=1;
for( ; i<=data.num/2; i*=2);
 
while(1)
{     
if(i == 1)
{
  data.out[j++] = data.heap[i];
  data.temp[i] = -1;
  for(i=i*2+1; i<=data.num/2; i*=2);
}
else
{
  if(i*2 <= data.num && data.temp[i*2] != -1)
  {
   data.out[j++] = data.heap[i*2];
   data.temp[i*2] = -1;
  }

  if(data.temp[i] != -1)
  {
   data.out[j++] = data.heap[i];
   data.temp[i] = -1;
  }
   
  if(i*2+1 <= data.num && data.temp[i*2+1]!= -1)
  {
   for(i=i*2+1; i<=data.num/2; i*=2);
   continue;
  }
  //printf("i:%d j:%d\n",i,j);
}
i/=2;
if(j>data.num) break;
}
}

void preorder(void) // when case 2,
{
int i=1, j=1;

while(1)
{
for( ; i<=data.num; i*=2)
{
  if(data.temp[i]!= -1)
  {
   data.out[j++]=data.heap[i];
   data.temp[i]= -1;
  }
}
if(i/2-1>=data.num)
{
  i=i/2+1;
  data.out[j++]=data.heap[i];
  data.temp[i]= -1;
}

i=i/2+1;

if(i%2==0)
{
  while(i%2==0)
  i=i/2;
}
if(j>data.num)
  break;
}

}

void postorder(void) // when case 3,
{
int i=1, j=1;  
for( ; i<=data.num/2; i*=2);
 
while(1)
{     
if(data.temp[i]!= -1)
{
  data.out[j++]=data.heap[i];
  data.temp[i]=-1;
}

if(i+1<=data.num && data.temp[i+1]!= -1 && (i+1)%2==1) 
{
  i++;
  if(i*2<=data.num)
  {
   for( ; i<=data.num/2; i*=2);
   continue;
  }
  data.out[j++] = data.heap[i];
  data.temp[i]= -1;
}

i/=2;
if(j > data.num) break;
}
}

static void Start()
{
mytime.gap = 0.0;  // init
mytime.bEnable = FALSE;
mytime.counter = 0;
mytime.fTotal_Time = 0.0;

// system test
QueryPerformanceCounter ( &mytime.st ) ;
if ( mytime.st.QuadPart == 0 )
{
mytime.bEnable= FALSE;
OutputDebugString("시스템이 지원이 안됨,,, 사용할 수 없음[CTimeCounter Class]\n");
}

// start()
mytime.counter ++;
QueryPerformanceCounter ( &mytime.st ) ;
}

static void End()
{
char szMsg[64];

QueryPerformanceCounter ( &mytime.ed ) ;
QueryPerformanceFrequency ( &mytime.freq ) ;

// 소요 시간 계산
mytime.gap = ( (double) (mytime.ed.QuadPart - mytime.st.QuadPart )) / ( (double) mytime.freq.QuadPart ) ;
mytime.fTotal_Time += mytime.gap;

sprintf ( szMsg, "수행시간 %.6f초\n", mytime.gap) ;
OutputDebugString(szMsg);
}

int read(FILE *in_file)
{
int i;
fscanf(in_file,"%d",&data.num);
if(data.num== -1) return 0;
else
{
data.heap=(int*)malloc(sizeof(int)*(data.num+1)); // memory allocation
data.temp=(int*)malloc(sizeof(int)*(data.num+1));
data.out= (int*)malloc(sizeof(int)*(data.num+1));

fscanf(in_file,"%d",&data.type);

for(i=1; i<=data.num; i++)
{
  fscanf(in_file,"%d",&data.temp[i]);
}
}
return 1;
}

void sort(FILE *out_file)
{
int i,j,tmp;
int flaglevelorder=0;

Start(); // clock starts

// max heap insertion occurs here.
for(i=1; i<=data.num; i++)
{
data.heap[i]=data.temp[i];
for(j=i; j>1; j/=2)
{
  if(data.heap[j]<data.heap[j/2]) break;
  else
  {
   tmp=data.heap[j/2];
   data.heap[j/2]=data.heap[j];
   data.heap[j]=tmp;
  }
}
}

switch(data.type)
{
case 1:
inorder();
break;
case 2:
preorder();
break;
case 3:
postorder();
break;
case 4: //level-order
flaglevelorder=1;
//for(i=1; i<=data.num; i++) data.out[i]=data.heap[i];
break;
}

End(); // clock stops

if(flaglevelorder)
{
for(i=1;i<=data.num;i++) fprintf(out_file, "%d ", data.heap[i]);
}
else
{
for(i=1;i<=data.num;i++) fprintf(out_file, "%d ", data.out[i]);
}

fprintf(out_file,"\n%5.3f\n\n", mytime.fTotal_Time);

free(data.heap); // unallocation of memory
free(data.temp);
free(data.out);
}

void main(void)
{
FILE *infile, *outfile;

infile=fopen(IN_FILE,"r");
outfile=fopen(OUT_FILE,"w");

while(read(infile)) sort(outfile);

fclose(infile);
fclose(outfile);
}

/*
자료구조 - 2번째 과제물.
제출 기한 : 2006. 3. 31. Friday 6:00 PM.

주어진 숫자를 radix sort algorithm (pp. 350-357) 을 이용하여 정렬하라.

예 (radix 가 10일 경우):

329        720        720        329
457        355        329        355
657        436        436        436
839  ->    457   ->   839   ->   457
436        657        355        657
720        329        457        720
355        839        657        839

Input 양식:
5                // input 개수
10329353
2340213
234091223
2342321
2341323

Output 양식:
2340213
2341323
2342321
10329353
234091223

조건:
1. 각 숫자는 최대 9자리이다.
2. Input은 C:ass2_input.txt에서 입력 받아서 C:ass2_output.txt에 출력하면 된다.
3. 제출시 파일명은 "학번_이름_반"으로 작성하세요. 여기서 반은 과제물 제출 게시판의 반입니다.(A,B,C)
  예) 200621094_홍길동_A.exe /200621094_홍길동_A.c
4. 소스 파일과 실행 파일모두 제출 하셔야 합니다.  
5. input 개수에 상관없이 작동해야 합니다. 단 integer범위를 벗어나진 않습니다.
6. c: 폴더에 실행파일이 없을 경우에도 동작해야 합니다.
7. Radix_Size에 변동 사항이 있을 경우 공지사항에 다시 올리겠습니다.
8. 공지 사항을 꼭 확인해 주세요.
*/

#include <stdlib.h>  // to use function: atoi()
#include <string.h>  // to reset buffer: memset()
#include <windows.h> // for class CTimeCouter
#include <stdio.h>  // for class CTimeCouter

#define IN_FILE "c:\\ass2_input.txt"
#define OUT_FILE "c:\\ass2_output.txt"

// global variables here
struct data{
int* list;      // input data enters here
int* temp;  // mydata.temporary data to exchange
int num_in;    // number of inputs
}mydata;

struct time{
LARGE_INTEGER   st, ed, freq ;
   double          gap ;
   BOOL            bEnable;
   char            szName[256];
   UINT            counter;
   double          fTotal_Time;
}mytime;

static void Start()
{
mytime.gap = 0.0;         // init
mytime.bEnable = FALSE;
mytime.counter = 0;
mytime.fTotal_Time = 0.0;

// system test
QueryPerformanceCounter ( &mytime.st ) ;
if ( mytime.st.QuadPart == 0 )
{
 mytime.bEnable= FALSE;
 OutputDebugString("시스템이 지원이 안됨,,, 사용할 수 없음[CTimeCounter Class]\n");
}

// start()
mytime.counter ++;
QueryPerformanceCounter ( &mytime.st ) ;
}

static void End()
{
char szMsg[64];

QueryPerformanceCounter ( &mytime.ed ) ;
QueryPerformanceFrequency ( &mytime.freq ) ;

// 소요 시간 계산
mytime.gap = ( (double) (mytime.ed.QuadPart - mytime.st.QuadPart )) / ( (double) mytime.freq.QuadPart ) ;
mytime.fTotal_Time += mytime.gap;

sprintf ( szMsg, "수행시간 %.6f초\n", mytime.gap) ;
OutputDebugString(szMsg);
}

int read(FILE * in_file)
{
char tmpr[10]="";
int i;

fscanf(in_file,"%s",&tmpr);
if (atoi(tmpr)==0) return 0; // break if input is zero
else
{
 mydata.num_in=atoi(tmpr)+1;

 mydata.list = (int*)malloc(sizeof(int)*mydata.num_in); // memory allocation as size of mydata.num_in, and link this to mydata.list
 mydata.temp = (int*)malloc(sizeof(int)*mydata.num_in); // memory allocation as size of mydata.num_in, and link this to mydata.temp

 for(i=1; i<mydata.num_in; i++)
 {
  fscanf(in_file,"%s",&tmpr);
  mydata.list[i] = atoi(tmpr);
 }
}
return 1;
}

static void sort(FILE* out_file)
{
int cnt[256], idx[256], i;

Start(); // start stopwatch

memset(cnt, 0, 1024); // initializing count
idx[0]=0; // initializing index
for(i=0; i<mydata.num_in; i++)   cnt[(mydata.list[i] >> 0) & 255]++;
for(i=1; i<256; i++)   idx[i] = idx[i-1] + cnt[i-1];
for(i=0; i<mydata.num_in; i++)   mydata.temp[idx[(mydata.list[i] >> 0) & 255]++] = mydata.list[i];

memset(cnt, 0, 1024); // initializing count
idx[0]=0; // initializing index
for(i=0; i<mydata.num_in; i++)   cnt[(mydata.temp[i] >> 8) & (255)]++;
 for(i=1; i<256; i++)   idx[i] = idx[i-1] + cnt[i-1];
for(i=0; i<mydata.num_in; i++)   mydata.list[idx[(mydata.temp[i] >> 8) & 255]++] = mydata.temp[i];

memset(cnt, 0, 1024); // initializing count
idx[0]=0; // initializing index
for(i=0; i<mydata.num_in; i++)   cnt[(mydata.list[i] >> 16) & (255)]++;
for(i=1; i<256; i++)   idx[i] = idx[i-1] + cnt[i-1];
for(i=0; i<mydata.num_in; i++)   mydata.temp[idx[(mydata.list[i] >> 16) & 255]++] = mydata.list[i];

memset(cnt, 0, 1024); // initializing count
idx[0]=0; // initializing index
for(i=0; i<mydata.num_in; i++)   cnt[(mydata.temp[i] >> 24) & (255)]++;
for(i=1; i<256; i++)   idx[i] = idx[i-1] + cnt[i-1];
for(i=0; i<mydata.num_in; i++)   mydata.list[idx[(mydata.temp[i] >> 24) & 255]++] = mydata.temp[i];

End();  // stop stopwatch

fprintf(out_file,"%.10f\n", mytime.fTotal_Time);
for(i=0; i<mydata.num_in-1;i++) fprintf(out_file,"%d ", mydata.list[i]);
fprintf(out_file,"\n");
}

void main(void)
{
   FILE *in_file, *out_file;

in_file=fopen(IN_FILE,"r");
out_file=fopen(OUT_FILE,"w");

while(read(in_file)) sort(out_file);

fclose(in_file);
fclose(out_file);

free(mydata.list);
free(mydata.temp);
}

/*/////////////////////////////////
Data Structure Assignment #1

과제1:
Operand의 크기가 너무커서 integer type으로 처리하지 못하는 더하기 연산을 integer 덧셈처럼 처리하는 프로그램을 작성하시오.

채점에 사용될 양식
예)
input.txt

21123424543254546575767868
+4235465475678687979797

2335344365547657
-345463574687

25434665457655765879
+4547568798080980

3543454
-46576985679

..
..
..
EOF

output.txt
325243436576970808976

3655765876987908606080

654768780900897979799
..
..
..

답 생성시 음수는 숫자앞에 '-'기호를 붙이셔야 됩니다.
위의 방식으로 하겠습니다.

값 사이의 줄 공백은 input 파일에서는 처리하셔야 되고
처리가 안되어 있다면 '순서대로 2줄을 읽어들여' 처리하는 식으로 되어 있으면 됩니다.

output파일에서의 공백은 처리 안하셨어도 됩니다.
*/

#include <fstream.h> // includes iostream.h
#include <string.h>  // for strcmp()

#define IN_FILE "C:\\input.txt" // don't forget to use double '\\' instead of '\'
#define OUT_FILE "C:\\output.txt"
#define MAX_LEN 200 // up to 200 chars (w/ cr & sign, +1)
#define POSITIVE 0
#define NEGATIVE 1

void mysort(char *mychar) // clear out spaces;
{
int j=0;
char temp[MAX_LEN]=""; // clearing garbages out (will temporary store cleared *mychar values)
for (int i=0;i<=MAX_LEN+1;i++)
{
 if (mychar[i]!=' ') temp[j++]=mychar[i]; // if the character is not a blank, than save to the temp.
}
strcpy(mychar, temp); // overwrite strings with 'blank removed' ones.
} 

int signcheck_rmv(char *mychar) // check sign and return 1 if it's negative, else 0.
{
int ret_key=0;
for (int i=0;i<=MAX_LEN+1;i++)
{
 switch(mychar[i])
 {
 case '-':
  ret_key=1;     // if it's negative turn the flag on.
 case '+':
  mychar[i]=' '; // and then change the sign symbol to a blank.
  break;
 }
}
mysort(mychar); // call sort function to remove spaces

return ret_key; // return 1 if it's negative, otherwise 0
}

void remove_zeros(char* output) // remove front zeros, ej) 001023 -> 1023
{
char temp[MAX_LEN]="";
strcpy(temp,output);

for (int i=0;(unsigned)i<strlen(temp);i++) {
 if(temp[i]>='1') break;
 else temp[i]=' ';
}
mysort(temp);

if (strcmp(temp,"")==0) strcpy(temp,"0"); // leave one '0', if output is null.
strcpy(output,temp);
}

inline int bigger(int a, int b){ if(a>b) return a; else return b; }  // return bigger integer, else return first input.

void reform(char *mychar, int len) //digit count and modify 11 as 0011 to fit for 2222
{
int j=len-strlen(mychar); //+1 is for case of increase of number over 10
if (strlen(mychar)==(unsigned)len) {} //skip if strlen(mychar) is equal to itself.
else {
 while(j--) {
  for (int i=len; i>=0; i--) //repeat as length of mychar.
  {
   if(i<=0) mychar[i]='0'; // put '0' to mychar[i] if [i] is 0.
   else mychar[i]=mychar[i-1]; //otherwise
  }
 }
}
}

void calculate_plus(char* a, char* b, char *output, int last) // calculate and saves value to *output
{
int c=0;
int inta, intb;

char temp[MAX_LEN]="";

// digit count and modify 11 as 0011 to fit for 2222
reform(a, last);
reform(b, last);
reform(temp, last);

for (int i=1;i<=last;i++)
{
 inta=a[last-i]-'0';
 intb=b[last-i]-'0'; // converts a character to an integer
 //cout<<"inta+intb:"<<inta+intb<<endl;

 temp[last-i]=(((inta+intb)%10)+c)+'0'; // perform plus calculation

 if((inta+intb)/10) // if a+b is over 10, then we need to
 {
  c=1;    // set flag to 1 which says the output is more than 10.
  if(i==last) // in case the output have more digit than input, like 999+999.
  {
   reform(temp,strlen(temp)+1); // increase one more digit
   temp[0]='1';                 // then put 1 in front.
  }
 }
 else c=0; // otherwise reset the flag
}

remove_zeros(temp);
strcpy(output,temp); // copy temp to output
}

void calculate_minus(char* a, char* b, char *output, int last) // calculate and saves value to *output
{
int inta=0, intb=0, c=0;
char temp[MAX_LEN]="";
char my_a[MAX_LEN]="";
char my_b[MAX_LEN]="";

strcpy(my_a,a);
strcpy(my_b,b);

// count digit and modify 11 as 0011 to fit for 2222
reform(temp, last);
reform(my_a, last);
reform(my_b, last);

for (int i=1;i<=last;i++)
{
 if((my_a[last-i]-'0')==0) inta=0;
 else inta=(my_a[last-i]-'0');
 if((my_b[last-i]-'0')==0) intb=0;
 else intb=(my_b[last-i]-'0'); // converts a character to an integer

 if(inta-intb-c>=0)
 {
  temp[last-i]=(((inta-intb)%10)-c)+'0'; // perform minus calculation
  c=0;
 }
 else //if(inta-intb-c<0)
 {
  temp[last-i]=(inta-intb-c+10)+'0';
  c=1;
 }
}
remove_zeros(temp);
strcpy(output, temp);
}

int calculate(char *a, char *b, char *output, int a_is_neg, int b_is_neg) //(unsigned)bigger number comes to a, return 1 when the answer is MINUS.
{
char temp[MAX_LEN]="";
int type_a=0, type_b=0, i;
int len_a=strlen(a);
int len_b=strlen(b);
int last=bigger(len_a,len_b);

int a_size=1, b_size=1;

if(len_a==len_b) // assume that we have same length, because we already reform(a)&(b)
{
 for (i=0;i<=last;i++) // compare one by one
 {
  if(a[i]>b[i]) a_size*=(i+1); // +1 to prevent result is 0,  when i==0;
  if(b[i]>a[i]) b_size*=(i+1);
 }
 //cout<<"a_size: "<<a_size<<endl<<"b_size: "<<b_size<<endl;
 if(a_size>b_size)
 {
  if(a_is_neg) {calculate_minus(a,b,output,last); return NEGATIVE;} // when a_is_big and a_is_neg, output must be NEGATIVE
  if(b_is_neg) {calculate_minus(a,b,output,last); return POSITIVE;}
  calculate_plus(a,b,output,last); return POSITIVE;
 }
 if(b_size>a_size) //switch between (a,b) is occuring here.
 {
  if(b_is_neg) {calculate_plus(b,a,output,last); return NEGATIVE;} // when b_is_big and b_is_neg, output must be NEGATIVE
  if(a_is_neg) {calculate_plus(b,a,output,last); return POSITIVE;}
  calculate_plus(a,b,output,last); return POSITIVE;
 }
 calculate_plus(a,b,output,last); return POSITIVE;
}

int LONG=1;  //define as variable because we have to change later..
int SHORT=0;
//negative=1
//positive=0

if (len_a>len_b) { type_a=LONG; type_b=SHORT; }
if (len_b>len_a) { type_b=LONG; type_a=SHORT; }
if (a_is_neg) type_a+=NEGATIVE; else type_a+=POSITIVE;
if (b_is_neg) type_b+=NEGATIVE; else type_a+=POSITIVE;

// long-  type_x=2,
// long+  type_x=1,
// short- type_x=1,
// short+ type_x=0.

// first determine two definite situation.
// long+a(1) - short-b(1) = 0 // minus_calc, return POSITIVE
// long+a(1) - short+b(0) = 1 // plus_calc, return POSITIVE
// long-a(2) - short-b(1) = 1 // plus_calc, return NEGATIVE
// long-a(2) - short+b(0) = 2 // minus_calc, return NEGATIVE
// short+a(0) - long-b(2) = -2 // switch, minus_calc, return NEGATIVE
// short+a(0) - long+b(1) = -1 // plus_calc, return POSITIVE
// short-a(1) - long-b(2) = -1 // plus_calc, return NEGATIVE
// short-a(1) - long+b(1) = 0 // switch, minus_calc, return NEGATIVE

// now arranging by output, we can see top 2 has distinctive output.

// long-a(2) - short+b(0) = 2 // minus_calc, return NEGATIVE
// short+a(0) - long-b(2) = -2 // switch, minus_calc, return NEGATIVE

// long+a(1) - short-b(1) = 0 // minus_calc, return POSITIVE
// short-a(1) - long+b(1) = 0 // switch, minus_calc, return NEGATIVE
// long+a(1) - short+b(0) = 1 // plus_calc, return POSITIVE
// long-a(2) - short-b(1) = 1 // plus_calc, return NEGATIVE
// short+a(0) - long+b(1) = -1 // plus_calc, return POSITIVE
// short-a(1) - long-b(2) = -1 // plus_calc, return NEGATIVE

// so we can write:
if ( (type_a-type_b) == 2 ) { calculate_minus(a,b,output,last); return NEGATIVE; }
else if ( (type_a-type_b) == -2 ) { calculate_minus(b,a,output,last); return NEGATIVE; }

// now we have 6 conditions left, so we change the calculation from a-b to a+b.
// then we'll have two distinctive output from them.

// long+a(1) + short-b(1) = 2 // minus_calc, return POSITIVE
// short-a(1) + long+b(1) = 0 // switch, minus_calc, return NEGATIVE

// long+a(1) + short+b(0) = 1 // plus_calc, return POSITIVE
// long-a(2) + short-b(1) = 3 // plus_calc, return NEGATIVE
// short+a(0) + long+b(1) = 1 // plus_calc, return POSITIVE
// short-a(1) + long-b(2) = 3 // plus_calc, return NEGATIVE

// so we can write:
else if ( (type_a+type_b) == 2 ) { calculate_minus(a,b,output,last); return POSITIVE; }
else if ( (type_a+type_b) == 0 ) { calculate_minus(b,a,output,last); return NEGATIVE; }

// now we have 4 conditions left, so we change the definition of long
// now change the def of long.
else{
 LONG=10;
 type_a=type_b=0; //reset type_a and type_b

 // recalculate then.
 if (len_a>len_b) { type_a=LONG; type_b=SHORT; }
 if (len_b>len_a) { type_b=LONG; type_a=SHORT; }
 if (a_is_neg) type_a+=NEGATIVE; else type_a+=POSITIVE;
 if (b_is_neg) type_b+=NEGATIVE; else type_a+=POSITIVE;

 // LONG=10
 // SHORT=0
 // NEGATIVE=1
 // POSITIVE=0
 
 // which makes
 // long-  type_x=11,
 // long+  type_x=10,
 // short- type_x=1,
 // short+ type_x=0.

 // we perform the plus calculations to determine next top two.
 // long+a(10) + short+b(0) = 10 // plus_calc, return POSITIVE
 // short+a(0) + long+b(10) = 10 // plus_calc, return POSITIVE
 
 // long-a(11) + short-b(1) = 12 // plus_calc, return NEGATIVE
 // short-a(1) + long-b(11) = 12 // plus_calc, return NEGATIVE

 // so we now can write:
 if ((type_a+type_b) == 10) { calculate_plus(a,b,output,last); return POSITIVE; }
 else { calculate_plus(a,b,output,last); return NEGATIVE; }
}

return POSITIVE; // return positive if the answer is 0 situation(a=b) like (111-111)=0
}

void main(void)
{
char a[MAX_LEN]="";
char b[MAX_LEN]="";
char output[MAX_LEN]="";  // clearing out garbages

// opening files...
ifstream input_file(IN_FILE); //open file to read
ofstream output_file(OUT_FILE); //open file to write
if(input_file.fail()) //input file check
 cerr << "Error opening "<<IN_FILE<<endl;
else if(output_file.fail()) //output file check
 cerr << "Error opening "<<OUT_FILE<<endl;
else
{
 while (! input_file.eof()) //loop starts to get lines, stops end of the file.
 {
  strcpy(output,""); // just in case if the line have odd number
  //read file by line
  input_file.getline(a, sizeof(a)); //get a line, when repeats get the next odd line
  input_file.getline(b, sizeof(b)); //get a next line, when repeats get the next even line
  if (strcmp(a,"EOF")==0 || strcmp(b,"EOF")==0) break; // break out loop when meets "EOF" string, no matter if there's more to read.
   // so, really doesn't matter either line number is on even, or odd.

  //calculation
  //remove the sign
  int is_a_neg=signcheck_rmv(a);
  int is_b_neg=signcheck_rmv(b);

  switch(calculate(a, b, output, is_a_neg, is_b_neg)) // check out whether output positive calculation or negative.
  {
  case NEGATIVE:
   reform(output,strlen(output)+1);
   output[0]='-';
  case POSITIVE:
   break;
  }

  //cout<<"a: "<<a<<endl<<"b: "<<b<<endl<<"o: "<<output<<endl;  // just for testing purpose.
  output_file<<output<<endl; // write a line to output file.
 }//end of eof checking loop
}//end of input file error checking

// closing files...
input_file.close();
output_file.close();
} //end of main(void)*/