Adventurer on ClipperShip

#include <stdio.h>
#include <stdlib.h>
typedef struct  _node
{
    int             key;
    struct _node    *next;
} node;
#define success 1
#define fail    0
node    *init_node( void );     //head와 tail node의 초기화
node    *delete_all( node *head );      // head와 tail을 제외한 모든 node 삭제
node    *find_key( node *head, int s_key ); // 주어진 key값으로 node탐색
int     insert_node( node *head, int i_key );   // head와 첫번째 node사이 삽입
int     delete_node( node *node_n );    // 주어진 node의 다음 node 삭제
int     insert_key( node *head, int f_key, int i_key ); // 주어진 key값의 node 새로운 node 삽입
int     delete_key( node *head, int d_key );    // 주어진 key값의 노드삭제
void    print_node( node *head );   // node 출력

//  구현해야할 함수
//  oscending_node()   오름차순정렬
//  descending_node()   내림차순 정렬
int main( int argc, char **argv )
{
    int     result  =   0;
    node    *temp   =   NULL;
    node    *head   =   init_node();
    fputs( "Insert Node 1 to 10\n", stdout );
    insert_node( head, 10 );
    insert_node( head, 9 );
    insert_node( head, 8 );
    insert_node( head, 7 );
    insert_node( head, 6 );
    insert_node( head, 5 );
    insert_node( head, 4 );
    insert_node( head, 3 );
    insert_node( head, 2 );
    insert_node( head, 1 );
    print_node( head );
    fputs( "Finding key 5\n", stdout );
    temp    =   find_key( head, 5 );
    printf( "Finding 5 is %ssuccessful\n", temp == NULL ? "un" : "" );
    fputs( "Insert key 11 after 3\n", stdout );
    insert_key( head, 3, 11 );
    print_node( head );
    fputs( "Delete key 10\n", stdout );
    delete_key( head, 10 );
    print_node( head );
    fputs( "Finding key 3 and Delete next node\n", stdout );
    temp    =    find_key( head, 3 );
    delete_node( temp );
    print_node( head );
    fputs( "Delete key 7\n", stdout );
    delete_key( head, 7 );
    print_node( head );
    fputs( "Delete all node\n", stdout );
    delete_all( head );
    print_node( head );
    return 0;
}
node    *init_node( void )
{
    node    *head   =   (node *)malloc( sizeof(node) ); // head node initialization
    node    *tail   =   (node *)malloc( sizeof(node) ); // tail node initialization
    if( head == NULL ) // Head Node에 대해 할당에 실패했을때
    {
        fputs( "Failed to allocate for Head node\n", stdout );
        return  NULL;
    }
    if( tail == NULL ) // Tail Node에 대해 할당에 실패했을때
    {
        fputs( "Failed to allocate for tail node\n", stdout );
        free( head );  // Tail Node에 대해 할당에 실패했을 땐, Head Node를 해제
        return NULL;
    }
    head->next  =   tail;
    tail->next  =   NULL;
    return  head;
}

node    *delete_all( node *head )
{
    node    *navi_node  =   head->next; // 순회노드 선언 및 head 다음으로 설정
    node    *free_node  =   NULL;          // 해제노드 선언
    while( navi_node->next != NULL ) // 순회노드가 tail에 이를때까지
    {
        free_node   =   navi_node;
        navi_node   =   navi_node->next;
        free( free_node );
    }
    head->next  =   navi_node; // navi_node 가 성공적으로 루프를 종료했다면 tail
    return head;
}
node    *find_key( node *head, int s_key )
{
    node    *navi_node =   head->next; // head 다음노드로 설정
    while( navi_node->key != s_key && navi_node->next != NULL ) // key값을 찾거나 꼬리에 이를때까지
        //
    {
        navi_node   =   navi_node->next;
    }
    if( navi_node->key == s_key ) // key값을 찾았을경우
    {
        return navi_node;
    }
    else if( navi_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Node is tail\n", stdout );
        return NULL;
    }
}
int     insert_node( node *head, int i_key)
{
    node    *i_node =   NULL;  // 삽입노드 선언
    i_node          =   (node *)malloc( sizeof(node) ); // 삽입노드 할당
    if( i_node == NULL )
    {
        fputs( "Failed to allocate for Insert Node\n", stdout );
        return fail;
    }
    i_node->key     =   i_key;
    i_node->next    =   head->next;
    head->next      =   i_node;
    return success;
}
int     delete_node( node *node_d)
{
    node        *delete_node    =   node_d->next; // 삭제노드 선언 및 node_next다음노드로 설정
    if( delete_node->next == NULL )
    {
        fputs( "Next node is tail.\n", stdout );
        return fail;
    }
    node_d->next    =   delete_node->next;
    free( delete_node );
    return success;
}
int     insert_key( node *head, int f_key, int i_key )
{
    node    *i_node     =   NULL;
    node    *s_node     =   head->next; // 탐색노드
    while( s_node->next != NULL && s_node->key != f_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
    }
    if( s_node->key == f_key ) // key값일경우
    {
        i_node          =   (node *)malloc( sizeof(node) );
        if( i_node == NULL ) // 할당에 실패했을때
        {
            fputs( "Failed to allocate for Insert node\n", stdout );
            return fail;
        }
        i_node->next    =   s_node->next;
        i_node->key     =   i_key;
        s_node->next    =   i_node;
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}
int     delete_key( node *head, int d_key )
{
    node    *s_node =   head->next; // 탐색노드
    node    *p_node =   head; // 탐색노드를 따라갈 이전노드
    while( s_node->next != NULL && s_node->key != d_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
        p_node  =   p_node->next;
    }
    if( s_node->key == d_key ) // key값일경우
    {
        p_node->next    =   s_node->next;
        free( s_node );
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}
void    print_node( node *head )
{
    node    *c_node =   head->next; // 탐색노드
    int     index_node  =   0; // 노드 개수
    printf("--------------------------------------------------\n");
    while( c_node->next  != NULL )
    {
        index_node++;
        fprintf(stdout, "%2dth Node key value : %2d\n", index_node, c_node->key );
        c_node  =   c_node->next;
    }
    printf("--------------------------------------------------\n");
}
}

#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <unistd.h>
#include    <arpa/inet.h>
#include    <sys/types.h>
#include    <sys/socket.h>
#include    <netdb.h>

void    error_handling( char *message );
void    response( char *recv );
void    pong ( char *ping );

#define MAX 8192

int     sockfd;


int     main( int argc, char *argv[] )
{
    const   char    address[64]    =   "irc.hanirc.org";

    char    nickname[64]    =   "Luna_bot";
    char    channel[64]     =   "#프겔";

    int     port            =   6664;

    struct  sockaddr_in sock;
    struct  hostent     *host_st;

    char    rcv_data[MAX]  =   {0x00, };
    char    send[1024]      =   {0x00, };

    char    *ping;

    host_st     =   gethostbyname( address );
    if( host_st == NULL)
    {
        error_handling( "gethostbyname() error" );
    }

    sockfd      =   socket( AF_INET, SOCK_STREAM, 0 );
    if( sockfd == -1 )
    {
        error_handling( "socket() error" );
    }

    memset( &sock, 0x0, sizeof(sock) );
    sock.sin_family     =   AF_INET;
    sock.sin_port       =   htons( port );
    sock.sin_addr       =   *((struct in_addr*)host_st->h_addr);

    if( connect( sockfd, (struct sockaddr *)&sock, sizeof(sock) ) == -1 )
    {
        error_handling( "connect() error" );
    }

    strncpy( send, "NICK Luna_bot \n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    strncpy( send, "USER iam5duck \"naver.com\" \"irc.hanric.org\" : Luna\n", sizeof(send) -1 );
    printf( "Request : %s\n", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "NICK Luna_bot \n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    /*    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );
    */
    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "USERHOST LaLuna\n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "JOIN #프갤\n", sizeof(send) - 1 );
    printf( "Request : %s", send );
    write( sockfd, send, strlen(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "PRIVMSG #프갤 :HI I'am LaLuna Bot\n", sizeof(send) - 1 );
    printf( "Request : %s", send );
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof( send ) );

    while( 1 )
    {
        read( sockfd, rcv_data, sizeof(rcv_data) );
        response( rcv_data );

        if( strstr( rcv_data, "!out" ) )
        {
            memset(send, 0x0, sizeof(send) );
            strncpy( send, "PRIVMSG #프갤 :Luna_bot 갑니다 ㅂ2ㅂ2\n", sizeof(send) - 1 );
            break;
        }

        if( strstr( rcv_data, "Luna_bot" ) )
        {
            strncpy( send, "PRIVMSG #프갤 :I am so hot, 난 너무 예뻐요\n ", sizeof(send) -1 );
            write( sockfd, send, strlen( send ) );
            memset( send, 0x0, sizeof( send ) );
        }
        memset( rcv_data, 0x0, sizeof( rcv_data ) );
    }

    close( sockfd );
    return 0;
}

void    error_handling( char *message )
{
    fputs( message, stderr );
    fputc( '\n', stderr );
    exit( 1 );
}

void    response( char *recv )
{
    char    temp[MAX];
    char    *parsing;
    char    *ping;

    printf( "-----------------------------------------------\n");
    strncpy( temp, recv, sizeof(temp) - 1);

    parsing     =   strtok( temp, "\n");

    while( parsing != NULL )
    {
        if( parsing )   printf( "Response : %s\n", parsing );
        if( (strstr( parsing, "PING " )) != NULL )
        {
            pong( parsing );
        }
        parsing =   strtok( NULL, "\n" );
    }
    printf( "-----------------------------------------------\n");
}

void    pong( char *ping )
{
    char    temp[MAX]  =   {0x00, };
    char    *parsing;

    strncpy( temp, ping, strlen( ping ) + 1 );
    parsing     =   strtok( temp, "\n" );
    memcpy( parsing, "PONG", 4 );

    printf( "PINGPONG : %s\n", parsing );
    write( sockfd, parsing, strlen( parsing ) + 1 );
}

int insert_key( node *head, int f_key, int i_key )

삽입노드 선언

탐색노드 선언 및 head다음노드로 설정

key값을 찾거나 꼬리에 도달할때까지 반복

탐색노드를 다음노드로 이동

if( key값을 찾으면 )

삽입노드 할당 및 key값 설정 ( 할당에 실패하면 함수 종료 )

삽입노드 다음을 탐색노드 다음으로 설정

탐색노드 다음을 삽입노드로 설정

success 반환

else if( 꼬리라면 )

에러메세지 출력

fail 반환

1. 성공시
• success반환
2. 실패시
• fail 반환
3. 인자값
• head : head 주소값
• i_key : 삽입할 노드의 key 값
  

int     insert_key( node *head, int f_key, int i_key )
{
    node    *i_node     =   NULL;
    node    *s_node     =   head->next; // 탐색노드

    while( s_node->next != NULL && s_node->key != f_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
    }

    if( s_node->key == f_key ) // key값일경우
    {
        i_node          =   (node *)malloc( sizeof(node) );
        if( i_node == NULL ) // 할당에 실패했을때
        {
            fputs( "Failed to allocate for Insert node\n", stdout );
            return fail;
        }
        i_node->next    =   s_node->next;
        i_node->key     =   i_key;
        s_node->next    =   i_node;
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}

int  delete_key( node *head, int d_key )

탐색노드 선언 및 head 다음노드로 설정

탐색노드를 따라갈 이전노드 선언

탐색노드가 key값을 찾거나 꼬리에 도달할때까지 반복

이전노드를 탐색노드로 설정

탐색노드는 다음노드로 이동

if( key값을 찾았으면 )

이전노드 다음노드를 탐색노드 다음노드로 설정

탐색노드 해제

success 반환

else if( 꼬리라면 )

에러메세지 출력

fail 반환

1. 성공시
• success반환
2. 실패시
• fail 반환
3. 인자값
• head : head 주소값
• int d_key : 삭제할 노드의 key 값

int     delete_key( node *head, int d_key )
{
    node    *s_node =   head->next; // 탐색노드
    node    *p_node =   head; // 탐색노드를 따라갈 이전노드

    while( s_node->next != NULL && s_node->key != d_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
        p_node  =   p_node->next;
    }

    if( s_node->key == d_key ) // key값일경우
    {
        p_node->next    =   s_node->next;
        free( s_node );
        return success;
    }

    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}

typedef struct  _node
{
    int             key;       // key값을 저장
    struct _node    *next;       // 다음 node의 주소
} node;

#define success 1
#define fail   0

node    *init_node( void );     //head와 tail node의 초기화
node    *delete_all( node *head );      // head와 tail을 제외한 모든 node 삭제
node    *find_key( node *head, int s_key ); // 주어진 key값으로 node탐색
int     insert_node( node *head, int i_key );   // head와 첫번째 node사이 삽입
int     delete_node( node *node_n );    // 주어진 node의 다음 node 삭제
int     insert_key( node *head, int f_key, int i_key ); // 주어진 key값의 node 새로운 node 삽입
int     delete_key( node *head, int d_key );    // 주어진 key값의 노드삭제
void    print_node( node *head );   // node 출력
//  구현해야할 함수
//  oscending_node()   오름차순정렬
//  descending_node()   내림차순 정렬

▩ ISFP 성인군자형 ▩

▒ 일반적인 특성 ▒

1. 다음은 응용 소프트웨어에 대한 설명이다. 잘못된것은?

① 그래픽 소프트웨어에는 포토샵, 페인트샵, 프리랜서 등이 있다.

② 데이터베이스 스포트웨어에는 액세스, SQL 등이 있다.

③ 인터넷을 사용하기 위해서는 넷스케이프, 익스플로러 등을 이용한다.

④ 스프레드시트 소프트웨어에는 엑셀, 로터스1-2-3- 등이 있다.


7. 운영체제(Operating System)는 시스템의 중추적인 역활을 하는 소프트웨어를 말한다. 다음 중 운영체제에 대한 설명으로 옳은 것은?

① Windows Xp는 안정성이 뛰어나 Windows NT에 비해 서버용으로 더 많이 사용한다.

② FAT32와 NTFS파일 시스템은 서로 호환되지 않기 때문에 디스크상의 데이터를 인식하지 못할 수도 있다.

③ LINUX는 아직 그래픽 사용자 환경 지원이 없어 초보자가 사용하기 어렵다.

④ 매킨토시용 운영체제에서는 인터넷을 사용할 수 없다는 단점이 있다.

답이 뭘까요? 알수가 없군요.

미국 개발자와 일하게 됬는데 내 가방에서 스마트 폰으로 매일 주고받고 블루투스 헤드셋으로 음악,동영상 관람에 갑자기 그 폰으로 전화받고 게임까지 하는것보고 당신은 미래에서 왔는가 하면 떡실신

미국 경력 5년차에 나름 고급 개발자와 일하게 됬는데 나 혼자서 DB,CS로직,HTML 심지어 포토샵으로 이미지까지 편집하는것보고 나에게 당신의 정체는 뭔가 우리회사 전체가 하는일을 혼자서 다하고있다 떡실신

다 시 실리콘 밸리 업체와 몇번인가 일하게 됬는데 처음에 웹어플리케이션 개발에 본인이 투입되어 같이 작업 그후에 윈도우 어플리케이션 또 본인 투입 이번에 FLEX 프로젝트까지 또 본인 투입 외국업체왈 아니 한국인은 순식간에 랭귀지를 마스터 하는가 하면 떡실신

이번에 영국 개발자 와 일하는데 그때 프로젝트가 겹쳐서 오전에 1번 프로젝트 오후에 2번 프로젝트 투입되는 나를 보면 당신은 자아가 두개인가 하면 떡실신

다 시 영국개발자 자신은 프로그램을 만드는데 종이 그림그리고 각종 UML 프로그램등으로 열심히 설계를 하는데 본인은 늘하던되로 코딩부터 시작해서 상당히 복잡한 로직을 순 머리로만 혼자 코딩하고 순식간에 만들어버리자 자신의 개발철학에 심각한 회의를 느꼈다고 넋두리

독일에 임베디드 개발자와 같이 H/W 펌웨어 개발을 하는데 독일 개발자 나름 장인정신으로 고도 집중력을 발휘하면 개발하는데 본인은 옆에서 MP3듣고 웹서핑 하고 업무 전화 통화까지 하면서 개발하는것 보고 떡실신

근 성있다는 미국 개발자 촉박한 프로젝트에 같이 투입됬는데 미국 개발자 야근까지 하고 GG 반면 한국 개발자는 그냥 오전 8시에 시작해서 다음날 저녁 8시까지 무려 36시간동안 엄청난 노가다로 개발해서 기간을 맞추어 버림 미국 개발자 짐승취급함

독일개발자 개발중 모르는 부분이 있자 커뮤니티에 질문을 올리고 관련 서적을 도서관에서 대출하고  며칠만에 해결 반면 나는 메신저로 창뛰워놓고 몇몇 지인들에게 물어서 수분만에 해결하자 독일개발자 떡실신

실리콘 밸리에 업체에 개발자는 한국개발자가 웹사이트,윈도우 어플리케이션 DB,FLEX 심지어 포토샵까지 다루는것 보고 대체 당신의 연봉은 얼마냐는 질문에 현재 환율로 2만불도 안된다고 하자 떡실신

영국개발자와 같이 근처 놀이공원에 놀러감 사격장발견 본인이 정식 사격자세로 10발중 8발을 만발하자 당신 정체가 뭐냐고 물어봄 2년동안 군인이었다는 애길하자 나보고 혹시 CIA 아니냐고 떡실신

개발후 산출물 작업을 하는데 독일 개발자 워드패드와 그림판으로 낑낑되면 힘들게 문서 작성 옆에서 나 파워포인트 엑셀 능숙 능란하게 화려한 스킬로 완전 브로슈어를 만들자 나에게 인생의 재미가 뭐냐고 물어봄

미국개발자 급하고 여건이 안되면 햄버거로 끼니를 떄우기도 하지만 옆에서 컵라면 하나로 철야를 버티는 날 보고 혹시 한국의 노예제도 가 있는것 아니냐고 물어봄

영국개발자 내가 링크드 리스트 어레이 해쉬코드를 등 각종 알고리즘 자료구조를 보지도 않고 그냥 본능적으로 코딩하는것 보고 나에게 과외해줄 생각없냐고 진지하게 상담

미국 에 출장온 한국 개발자들 미국 개발자가 일단 창고에 짐을풀라고 애기하자 영어를 못알아듣고 그곳이 프로젝트 룸인줄 알고 컴퓨터 세팅에 심지어 랜선 설치한다고 천장까지 타서 프로젝트 룸으로 세팅하자 미국 업체 떡실신.