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;

}