2013 아마 존 필기시험 문제

제목 의 대략적인 뜻 은 아마 존 에 프로필 이 있 는데 파일 의 내용 은 다음 과 같은 형식 으로 되 어 있다 는 것 이다.
A={A=1;B=2;C=3;E={A=100;};};
A+={D=4;E={B=10;C=D;};};
규칙 A 는 첫 번 째 줄 에서 표시 한 바 와 같이 모든 규칙 은 하나의 문자열 로 표시 되 며, 몇 가지 규칙 을 통 해 규칙 A 에 하위 항목 을 추가 할 수 있 으 며, 하위 항목 이 같 으 면 이전의 값 을 덮어 쓸 수 있다.마지막 으로 아래 의 형식 을 통 해 규칙 A 의 내용 을 방문 할 수 있 습 니 다. 규칙 이름과 해당 하 는 값 은 A - z, a - z 와 0 - 9 만 포함 합 니 다.
A.E.B
A.A
A.E.A
설명, 하나의 규칙 에 포 함 된 비 포 함 된 규칙 은 하위 항목 으로 표시 합 니 다. 예 를 들 어 A. A, 규칙 에 포 함 된 규칙 은 하위 규칙 으로 A. E 와 같이 표시 합 니 다.
프로필 을 분석 하 는 프로그램 입 니 다. 원본 코드 를 드 리 겠 습 니 다.
다음은 자신 이 정의 한 두 개의 구조 체 로 각각 규칙 과 규칙 안의 하위 항목 을 나타 낸다.

struct rule_component{//      
	char *name; //          NAME_LEN，        ，    _name  
	char *value; //  ，          _value  ，         ，            
	char _name[NAME_LEN + 1];
	char _value[VALUE_LEN + 1];
	struct rule_component *next; //                     
};

struct rule{
	char *name; //          NAME_LEN，        ，    _name  
	char _name[NAME_LEN + 1];
	struct rule_component *head; //       
	struct rule *nested_head; //                
	struct rule *next; //     
};

문자열 을 보 여 줍 니 다. 규칙 의 시작, 하위 항목 의 시작, 하위 규칙 의 시작 등 을 판단 해 야 합 니 다. 문자열 의 머리 부터 옮 겨 다 니 기 시작 합 니 다. = {를 만나면 규칙 의 시작 을 표시 합 니 다.규칙 이 끝난다.
이 두 데이터 구 조 를 관리 하 는 데 보조 함 수 를 추가 합 니 다.

char* is_rule_start(char *ptr)
{
	do{
		if(*ptr == '='){
			if(*(ptr + 1) == '{')
				return ptr;
			else
				return NULL;
		}
		ptr ++;
	}while(*ptr);
	return 0;
}

char* is_rule_append(char *ptr)
{
	do{
		if(*ptr == '='){
			if(*(ptr - 1) == '+')
				return ptr - 1;
			else
				 return NULL;
		}
		ptr ++;
	}while(*ptr);
	return NULL;
}

char* is_comp_start(char *ptr)
{
	char *res;
	do{
		if(*ptr == '='){
			if(*(ptr + 1) != '{')
				return ptr;
			else
				return NULL;
		}
		ptr ++;
	}while(*ptr);
	return 0;
}

int is_rule_end(char *ptr)
{
	if(ptr)
		return strstr(ptr, RULE_END) == ptr;
	return 0;
}

위의 이러한 보조 함수 가 있 으 면 위의 규칙 을 해석 할 수 있 습 니 다. 전체 프로그램 은 다음 과 같 습 니 다. 테스트 함 수 를 포함 합 니 다.

struct rule* make_rule() //new  rule  
{
	struct rule *res;
	res = (struct rule*)malloc(sizeof(*res));
	if(res)
		memset(res, 0, sizeof(*res));
	res->name = res->_name;
	return res;
}

struct rule_component *make_rule_component() //new  rule_component  
{
	struct rule_component *res;
	res = (struct rule_component*)malloc(sizeof(*res));
	if(res)
		memset(res, 0, sizeof(*res));
	res->name = res->_name;
	res->value = res->_value;
	return res;
}

void free_rule(struct rule * r) //  rule  
{
	if(r){
		if(strlen(r->name) > NAME_LEN) // name     NAME_LEN， name     _name  ，    
			free(r->name);
		free(r);
	}
}

void free_rule_component(struct rule_component * c) //  rule_component  
{
	if(c){
		if(strlen(c->name) > NAME_LEN)
			free(c->name);
		if(strlen(c->value) > VALUE_LEN)
			free(c->value);
		free(c);
	}
}

void destroy_rule_recursive(struct rule *rule) //destroy  rule，     ，  
{
	struct rule *nested;
	struct rule_component *comp;
	comp = rule->head;
	while(comp){
		struct rule_component *tmp;
		tmp = comp->next;
		free_rule_component(comp);
		comp = tmp;
	}
	nested = rule->nested_head;
	while(nested){
		struct rule *tmp;
		tmp = nested->next;
		destroy_rule_recursive(nested);
		nested = tmp;
	}
	free_rule(rule);
}

void destroy_rule_list(struct rule *head) //destroy  rule   
{
	struct rule *tmp;
	while(head){
		tmp = head->next;
		destroy_rule_recursive(head);
		head = tmp;
	}
}