algospot.com :: 질문과 답변: NAMING문제에 런타임 오류가 뜹니다

NAMING문제에 런타임 오류가 뜹니다

http://algospot.com/judge/problem/read/NAMING
문제에서

RTE (SIGABRT: program aborted, probably assertion fail)
오류가 뜹니다

대부분의 런타임 오류는 메모리 관련해서 발생하더라구요
그래서 최대한 고칠수 있을만큼 고쳐봤지만 찾을수가 없었습니다 ㅠㅠ

소스를 평소 쓰던 레퍼를 이용해 만들고, 헤더파일과 c파일 내용을 조잡하게 이어붙인채로 제출을 해서 많이 보기 힘드시겟지만 일단 정리를 해보긴 했습니다;;;

#include stdio.h
#include stdlib.h
#include string.h

#define TRUE 1
#define FALSE 0

typedef struct ArrayQueueNodeType
{
char data;
}ArrayQueueNode;
typedef struct ArrayQueueType
{
int maxElementCount;
int currentElementCount;
ArrayQueueNode* pElement;
}ArrayQueue;

ArrayQueue* createArrayQueue(int _maxElementCount);
int pushAQ(ArrayQueue* _pQueue, ArrayQueueNode _element);
ArrayQueueNode* popAQ(ArrayQueue* _pQueue);
ArrayQueueNode* peekAQ(ArrayQueue* _pQueue);
void deleteArrayQueue(ArrayQueue* _pQueue);
int isArrayQueueFull(ArrayQueue* _pQueue);
int isArrayQueueEmpty(ArrayQueue* _pQueue);

typedef struct ArrayStackNodeType{
char data;
} ArrayStackNode;

typedef struct ArrayStackType{
int maxElementCount;
int currentElementCount;
ArrayStackNode* pElement;
} ArrayStack;

ArrayStack* createArrayStack(int maxElementCount);
int pushAS(ArrayStack* pStack, ArrayStackNode element);
ArrayStackNode* popAS(ArrayStack* pStack);
ArrayStackNode* peekAS(ArrayStack* pStack);
void deleteArrayStack(ArrayStack* pStack);
int isArrayStackFull(ArrayStack* pStack);
int isArrayStackEmpty(ArrayStack* pStack);

char* reverce(char* _str);

char name[400000];
char temp[400000];

int main()
{

int i=0, length=0;
char reverse;
ArrayStack* S=NULL;
ArrayQueue* Q=NULL;
ArrayStackNode* nS;
ArrayQueueNode* nQ;
gets(name);
gets(temp);

strcat(name,temp);
length=strlen(name);
S=createArrayStack(length);
Q=createArrayQueue(length);

for(i=0;i<length;i++)
{
    nS=(ArrayStackNode*)malloc(sizeof(ArrayStackNode));
    nQ=(ArrayQueueNode*)malloc(sizeof(ArrayQueueNode));

    nS ->data = nQ ->data =name[i];

    pushAS(S,*nS);
    pushAQ(Q,*nQ);
}

memset(name,0,400000);
memset(temp,0,400000);

for(i=0;i<length;i++)
{
    name[i]=popAS(S)->data;
    temp[i]=popAQ(Q)->data;

    reverce(name);
    if(strcmp(name,temp) == 0)
    {
        printf("%d ",strlen(name));
    }

    reverce(name);
}

deleteArrayStack(S);
deleteArrayQueue(Q);
free(nS);
free(nQ);

return 0;

}

ArrayQueue* createArrayQueue(int _maxElementCount)
{
ArrayQueue* pReturn=NULL;
int i=0;

if(_maxElementCount > 0)
{
    pReturn = (ArrayQueue*)malloc(sizeof(ArrayQueue));
    if(pReturn != NULL)
    {
        memset(pReturn,0,sizeof(ArrayQueue));
        pReturn ->maxElementCount = _maxElementCount;
    }

    else
    {
        printf("오류, 메모리 할당 createArrayQueue()\n");
        return NULL;
    }

    pReturn ->pElement = (ArrayQueueNode*)malloc(sizeof(ArrayQueueNode) * _maxElementCount);
    if(pReturn ->pElement != NULL)
    {
        for(i = 0; i< _maxElementCount; i++)
        {
            memset(pReturn ->pElement,0,sizeof(ArrayQueueNode)*_maxElementCount);
        }
    }
    else
    {
        printf("오류, 메모리 할당2 createArrayQueue()\n");
        return NULL;
    }

}

else
{
    printf("큐의 크기는 1 이상이어야 합니다\n");
    return NULL;
}

return pReturn;

}

int pushAQ(ArrayQueue* _pQueue, ArrayQueueNode _element)
{
int Return;

if(_pQueue != NULL)
{
    if(isArrayQueueFull(_pQueue) != TRUE)
    {
        _pQueue ->currentElementCount++;
        _pQueue ->pElement[_pQueue ->maxElementCount-_pQueue ->currentElementCount] = _element;
        Return = TRUE;
    }
    else
    {
        Return = FALSE;
        printf("오류, 큐가 가득 찻습니다\n");
    }
}
else
{
    Return = FALSE;
    printf("오류, NULL 포인터 전달 pushAQ()\n");
}
return Return;

}

ArrayQueueNode* popAQ(ArrayQueue* _pQueue)
{
ArrayQueueNode* Return=NULL;
int i=0;

if(_pQueue != NULL)
{
    if(isArrayQueueEmpty(_pQueue) != TRUE)
    {
        Return = (ArrayQueueNode*)malloc(sizeof(ArrayQueueNode));
        if(Return != NULL)
        {
            _pQueue ->currentElementCount--;
            *Return = _pQueue ->pElement[ _pQueue->maxElementCount-1];
            for(i=0; i<_pQueue ->currentElementCount; i++)
            {
                _pQueue ->pElement[_pQueue ->maxElementCount-(i+1)] = _pQueue ->pElement[_pQueue ->maxElementCount-(i+2)];
            }
        }
        else
        {
            printf("오류, 메모리 할당 popAQ()\n");
        }
    }
    else
    {
        printf("오류, 큐가 비어 있습니다\n");
    }
}
else
{
    printf("오류, NULL 포인터 전달 popAQ()\n");
}
return Return;

}

ArrayQueueNode* peekAQ(ArrayQueue* _pQueue)
{
ArrayQueueNode* Return;
int i=0;

if(_pQueue != NULL)
{
    if(isArrayQueueEmpty(_pQueue) != TRUE)
    {
        Return = &(_pQueue ->pElement[ _pQueue->maxElementCount-1]);
    }
    else
    {
        printf("오류, 큐가 비어 있습니다\n");
    }
}
else
{
    printf("오류, NULL 포인터 전달 peekAQ()\n");
}
return Return;

}

void deleteArrayQueue(ArrayQueue* _pQueue)
{
if(_pQueue != NULL)
{
if(_pQueue ->pElement != NULL)
{
free(_pQueue ->pElement);
}
free(_pQueue);
}
}

int isArrayQueueFull(ArrayQueue* _pQueue)
{
int Return = FALSE;

if(_pQueue != NULL)
{
    if(_pQueue ->currentElementCount == _pQueue->maxElementCount)
    {
        Return = TRUE;
    }
}

return Return;

}

int isArrayQueueEmpty(ArrayQueue* _pQueue)
{
int Return = FALSE;
if(_pQueue != NULL)
{
if(_pQueue->currentElementCount == 0)
{
Return = TRUE;
}
}

return Return;

}

ArrayStack* createArrayStack(int size)
{
ArrayStack* pReturn = NULL;
int i = 0;

if(size > 0)
{
    pReturn = (ArrayStack*)malloc(sizeof(ArrayStack));
    if(pReturn != NULL)
    {
        memset(pReturn, 0, sizeof(ArrayStack));
        pReturn -> maxElementCount = size;
    }
    else
    {
        printf("오류, 메모리할당. createArrayStack()\n");
        return NULL;
    }

    pReturn -> pElement = (ArrayStackNode*)malloc(sizeof(ArrayStackNode)*size);
    if(pReturn ->pElement != NULL)
    {
        memset(pReturn -> pElement, 0, sizeof(ArrayStackNode)*size);
    }
    else
    {
        printf("오류, 메모리 할당2, createArrayStack()\n");
        free(pReturn);
        return NULL;
    }
}
else 
{
    printf("오류, 스택의 크기는 0 이상이어야 합니다\n");
    return NULL;
}
return pReturn;

}

int pushAS(ArrayStack* pStack, ArrayStackNode element)
{
int ret = FALSE;

if(pStack != NULL)
{
    if(isArrayStackFull(pStack) == FALSE)
    {
        pStack -> pElement[pStack ->currentElementCount] = element;
        pStack->currentElementCount++;
        ret = TRUE;
    }
    else
    {
        printf("오류, 스택이 가득 찼습니다. pushAS()\n");
    }
}

return ret;

}

ArrayStackNode* popAS(ArrayStack* pStack)
{
ArrayStackNode* pReturn = NULL;
if(pStack !=NULL)
{
if(isArrayStackEmpty(pStack)==FALSE)
{
pReturn = (ArrayStackNode*)malloc(sizeof(ArrayStackNode));
if(pReturn != NULL)
{
*pReturn = pStack -> pElement[pStack ->currentElementCount -1];
pStack->currentElementCount--;
}
else
{
printf("오류, 메모리 할당. popAS()\n");
}
}
}
return pReturn;
}

ArrayStackNode* peekAS(ArrayStack* pStack)
{
ArrayStackNode* pReturn = NULL;
if(pStack != NULL)
{
if(isArrayStackEmpty(pStack) == FALSE)
{
pReturn = &(pStack ->pElement[pStack ->currentElementCount -1]);
}
}
return pReturn;
}

void deleteArrayStack(ArrayStack* pStack)
{
if(pStack != NULL)
{
if(pStack ->pElement != NULL)
{
free(pStack ->pElement);
}
free(pStack);
}
}

int isArrayStackFull(ArrayStack* pStack)
{
int ret = FALSE;

if(pStack != NULL)
{
    if(pStack ->currentElementCount == pStack->maxElementCount)
    {
        ret = TRUE;
    }
}

return ret;

}
int isArrayStackEmpty(ArrayStack* pStack)
{
int ret = FALSE;
if(pStack != NULL)
{
if(pStack->currentElementCount == 0)
{
ret = TRUE;
}
}

return ret;

}

char* reverce(char* _str)
{
char temp;
int i=0, length = strlen(_str);

for(i=0;i<length/2;i++)
{
    temp = _str[i];
     _str[i] = _str[length-(i+1)];
    _str[length-(i+1)] = temp;
}

return _str;

}

10년 전

1개의 댓글이 있습니다.

Kureyo
1. 코드 정리 부탁드립니다(...) 편집에서 아래쪽에 보시면 코드를 적는 방법에 대한 설명이 있습니다.
2. 저 문제를 푼건 아니지만 길이의 입력이 40만자라고 가정하면 char배열을 40만으로 잡으면 안될거같습니다. 자주 하는 실수 모음페이지를 참고하세요.
10년 전 link
정회원 권한이 있어야 커멘트를 다실 수 있습니다. 정회원이 되시려면 온라인 저지에서 5문제 이상을 푸시고, 가입 후 7일 이상이 지나셔야 합니다. 현재 문제를 푸셨습니다.

SINCE 2007

다가오는 이벤트들

NAMING문제에 런타임 오류가 뜹니다

1개의 댓글이 있습니다.