Exemplo n.º 1
0
/* parses a line of the file
 * tries to set the corresponding row in the matrix
 * returns false on error
 */
bool parse_row(char* s, int row, LinearProgram* lp) {
    assert(lp_is_valid(lp));
    assert(row >= 0);
    assert(row < get_rows(lp));

    char* end_ptr;
    int cols = get_cols(lp);

    int i;
    for (i = 0; i < cols; i++) {
        num_t num = parse_num(s, &end_ptr);

        if (!is_num_valid(num, s, end_ptr)) {
            return false;
        }

        set_coef(lp, row, i, num);
        s = end_ptr;
    }


    s = parse_type(s, row, lp);

    if (NULL == s) {
        return false;
    }

    num_t num = parse_num(s, &end_ptr);
    if (!is_num_valid(num, s, end_ptr)) {
        return false;
    }
    s = end_ptr;

    s = skip_spaces(s);

    if ('\0' != *s) {
        return false;
    }

    set_rhs(lp, row, num);

    assert(lp_is_valid(lp));
    return true;
}
Exemplo n.º 2
0
/* parses a line of the file
 * tries to set the corresponding row in the matrix
 * returns false on error
 */
bool parse_row(char* s, int row, LinearProgram* lp) {
    assert(lp_is_valid(lp));
    assert(row >= 0);
    assert(row < lp->rows);

    int i;
    char* end_ptr;
    for (i = 0; i < lp->cols; i++) {
        num_t num = parse_num(s, &end_ptr);

        if (!is_num_valid(num, s, end_ptr)) {
            return false;
        }

        lp->matrix[row][i] = num;
        s = end_ptr;
    }


    s = parse_type(s, row, lp);

    if (NULL == s) {
        return false;
    }

    num_t num = parse_num(s, &end_ptr);
    if (!is_num_valid(num, s, end_ptr)) {
        return false;
    }
    s = end_ptr;

    s = skip_spaces(s);

    if ('\0' != *s) {
        return false;
    }

    lp->vector[row] = num;

    assert(lp_is_valid(lp));
    return true;
}
Exemplo n.º 3
0
/*------------------------------------------------
 * Procedure to solve this problem
 * return how many valid answers
 * 
 * 1. set up numbers: abc, de
 * here are 5 loops to compute
 * 
 * 2. Check partProduct valid or not
 * all digits must be the member of num[]
 * 
 * 3. Check sum vaild or not
 * head digit cant be 0
 * 
 * 4. The partial products must be three digits long!!
 * */
int comp_crypt()
{
	int abc, de;
	int i, j, k, l, m;
	int partProduct1;	// e*abc
	int partProduct2;	// d*abc
	int sum;			// p1 + 10*p2
	int ans = 0;
	
	//n=1;
	// Set up numbers
	for(i=0; i<n; i++)
	for(j=0; j<n; j++)
	for(k=0; k<n; k++)
	for(l=0; l<n; l++)
	for(m=0; m<n; m++) {
		
		// Set numbers
		abc = num[i]*100 + num[j]*10 + num[k];
		de  = num[l]*10 + num[m];
		
		partProduct1 = num[m]*abc;
		partProduct2 = num[l]*abc;
		sum = partProduct1 + partProduct2*10;
		
		// The partial products must be three digits long
		if( partProduct1 > 999 || partProduct2 > 999 )
			continue;
		
		if( is_num_valid(partProduct1) &&
			is_num_valid(partProduct2) &&
			is_num_valid(sum) )
			ans++;
	}

	return ans;
}
Exemplo n.º 4
0
/*词法分析*/
void MYMICRO::parsetoken(std::vector<TOKEN> & tokens)
{
	tokens.clear();
	std::string tokenv ;
	char ch = 0;
	int flag = 0;
	int paras  =0;
	while(input->good())
	{
		*input>>ch;
		if(ch!='\n'&& isspace(ch)) continue; /*跳过空格*/
		input->putback(ch);
		flag = 0;
		while(input->good())
		{
			*input>>ch;
			switch (ch)
			{
			case TOKEN::ASSI:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::VAID;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::ASSI;
					temp.tokenval= '=';
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::MMULT:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::MMULT;
					temp.tokenval= TOKEN::MMULT;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::DIV:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::DIV;
					temp.tokenval= TOKEN::DIV;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::LINE:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::SEMI;
					temp.tokenval= TOKEN::SEMI;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::COMM:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::COMM;
					temp.tokenval= TOKEN::COMM;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::LPAR:
				{
					//std::cout<<paras<<"\n";
					if(paras<0) throw(PAERROR);
					++paras;
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::FUNC;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::LPAR;
					temp.tokenval= TOKEN::LPAR;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::RPAR:
				{
					//std::cout<<paras<<"\n";
					if(paras<1) throw(PAERROR);
					--paras;

					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::RPAR;
					temp.tokenval= TOKEN::RPAR;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::MINU:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::MINU;
					temp.tokenval= TOKEN::MINU;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::PLUS:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::PLUS;
					temp.tokenval= TOKEN::PLUS;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::MULT:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::MULT;
					temp.tokenval= TOKEN::MULT;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			case TOKEN::SEMI:
				{
					if(tokenv.size()>0)
					{
						TOKEN temp;
						temp.tokentype= TOKEN::IDNM;
						temp.tokenval= tokenv;
						tokens.push_back(temp);
						tokenv.clear();/*清空tokenval*/
					}
					TOKEN temp;
					temp.tokentype= TOKEN::SEMI;
					temp.tokenval= TOKEN::SEMI;
					tokens.push_back(temp);
					flag = 1;
					break;
				}
			default:
				tokenv.push_back(ch);
				break;
			}

			if(flag = 1)
			{
				break;
			}

		}

	}
	if(paras>0) throw(PAERROR);
	if(tokenv.size()>0)
	{
		TOKEN temp;
		temp.tokentype= TOKEN::IDNM;
		temp.tokenval= tokenv;
		tokens.push_back(temp);
		tokenv.clear();
	}
	/*判断token正确性*/
	for(auto item = tokens.begin();item != tokens.end();++item)
	{
		if(item->tokentype == TOKEN::FUNC)
		{
			if( ! is_id_valid(item->tokenval))
			{
				throw(IDERROR);
			}
		}
		if(item->tokentype == TOKEN::VAID)
		{
			if( ! is_id_valid(item->tokenval))
			{
				throw(IDERROR);
			}
		}
		if(item->tokentype == TOKEN::IDNM)
		{
			if(is_id_valid(item->tokenval))
			{
				item->tokentype = TOKEN::VAID;
			}
			else if(is_num_valid(item->tokenval))
			{
				item->tokentype = TOKEN::CONSTNUM;
			}
			else throw(NUERROR);
		}
		if(item != tokens.begin())
		{
			auto titem = item-1;
			if(item->tokentype == TOKEN::IDNM || item->tokentype == TOKEN::VAID)
			{
				if(titem->tokentype == TOKEN::IDNM || titem->tokentype == TOKEN::VAID)
				{
					throw(NUERROR);
				}
			}
		}
	}

}