华为上机题目

1、求一个整型数字中有没有相同的部分，例如12386123这个整型数字中相同的部分是123，相同的部分至少应该是2位数，如果有相同部分返回1，如果没有则返回0。

/*************判断是否有相同部分*************/

int IsSameNumber(int data)
{
    char data_str[100];
    int len = 0;

    //转字符串
    while (data)
    {
        data_str[len] = data % 10 + ‘0‘;
        data /= 10;
        len++;
    }
    data_str[len] = ‘\0‘;
    

    //显示一下，倒序
    cout << data_str << endl;

    int i = 0;
    int j = 0;

    int cnt = 0;
    int cnt_last = 0;

    int remember_i = 0;
    int remember_j = 0;

    for (i = 0; i < len; i++)
    {
        for (j = i + 1; j < len; j++)
        {
            cnt_last = cnt;

            if (data_str[i] == data_str[j])  //相等计数
            {
                cnt++;
                i++;

                if (cnt >= 2 && (j - i + 1 >= cnt) )    //找到两个相同的,且不重叠
                {
                    return 1;
              }
            }

            if (cnt_last == 0 && cnt == 1)    //开始计数
            {
                remember_i = i ;
                remember_j = j ;
            }

            if (cnt_last == cnt && cnt !=0 )   //没有继续计数
            {
                i = remember_i - 1;
                j = remember_j;
                cnt_last = cnt = 0;
            }

        }
    }

    return 0;
}

求两个字符串的乘积，结果存到字符串中，例如字符串一中存的“657891”，字符串二中存的“521”

/*************判断乘积*************/

void Mul(string data)
{
    int answer = 1;
    int i = 0;

    char answer_str[100];

    for (auto ch : data)
    {
        answer *= ch - ‘0‘;
    }
    

    //乘法
    while (answer)
    {
        answer_str[i++] = answer % 10 + ‘0‘;
        answer /= 10;
    }
    answer_str[i] = ‘\0‘;

    //反向
    for (int j = 0; j < i / 2; j++)
    {
        int temp = answer_str[j];
        answer_str[j] = answer_str[i - j - 1];
        answer_str[i - j - 1] = temp;
    }
    cout << answer_str << endl;
}

删除子串，只要是原串中有相同的子串就删掉，不管有多少个

void Delete(string string_small, string string_big)
{
    int i = 0;
    int j = 0;
    int j_last = 0;
    int k = 0;
    
    int remember_i = 0;
    int remember_j = 0;
    int remember_k = 0;

    char return_string[100];

    for (i = 0; string_big[i] != ‘\0‘; i++,k++)    //用大的字符串
    {
        return_string[k] = string_big[i];      //先搬进去

        j_last = j;

        if (string_big[i] == string_small[j])   //有相等的
        {
            j++;    //计数

            if (j_last == 0 && j == 1)   //第一次出现，记录i的初始值，以及k的初始值
            {
                remember_i = i;
                remember_k = k;
            }
            
        }

        if (string_small[j] == ‘\0‘)       //字符串用完了，返回去掉那个字符串，j清零。
        {
            k = remember_k - 1;
            j = 0;
        }

        if (j_last != 0 && j_last == j)    //中途断掉,i回退，j清零，k回退
        {
            i = remember_i;
            k = remember_k;
            j = 0;
        }

        
    }
    return_string[k] = ‘\0‘;

    cout << return_string << endl;
}

输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺序
比如： 输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置） 第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数 第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成，输出数值出列顺序为：2,3,1,4。

void Val(void)
{
    int num[Length] = { 3,1,2,4 };

    int max = 7;

    int len = Length;
    int i = 0;
    int cnt = 0;
    
    while (len)
    {
        while (!num[i])   i++;     //跳过零

        cnt++;

        if (cnt == max)   //数到了之后
        {
            cnt = 0;
            max = num[i];
            cout << max << " ";
            num[i] = 0;
            len -= 1;
        }

        //报数
        i++;
        if (i >= Length)  i = 0;
        
    }



}

10.简单的四则运算
问题描述： 输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 1、表达式只含 +, -, *, /, (, ), 四则运算符
2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
3、要考虑加减乘除按通常四则运算规定的计算优先级
4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况

#define Length 4


int Identify_Grade(char ch)
{
    switch (ch)
    {
    case ‘+‘:return 1;
    case ‘-‘:return 1;
    case ‘*‘:return 2;
    case ‘/‘:return 2;
    case ‘(‘:return 3;
    case ‘)‘:return 0;
    case ‘=‘:return 0;
    }
}

int Calculate(int val1, int val2 , char ch)
{
    switch (ch)
    {
    case ‘+‘:return val1 + val2;
    case ‘-‘:return val1 - val2;
    case ‘*‘:return val1 * val2;
    case ‘/‘:return val1 / val2;
    }
}

void SimpleDeal(void)
{
    char express[20];
    cin >> express;

    int data_stack[20] ;
    int data_stack_pointer = 0;
    char symbol_stack[20] ;
    int  symbol_stack_pointer = 0;

    for (int i = 0; express[i] != ‘\0‘; i++)
    {
        //数字存入数字堆栈
        if (express[i] >= ‘0‘&&express[i] <= ‘9‘)
        {
            data_stack[data_stack_pointer++] = express[i] - ‘0‘;
        }

        //否则入字符堆栈
        else
        {
            while (symbol_stack_pointer > 0
                && Identify_Grade(express[i]) <= Identify_Grade(symbol_stack[symbol_stack_pointer - 1]))   //优先级大的先算
            {
                if (symbol_stack[symbol_stack_pointer - 1] == ‘(‘)   //有左括号
                {
                    if (express[i] == ‘)‘)   //是右括号，去掉一对括号
                    {
                        symbol_stack_pointer--;
                    }
    
                    break;
                }

                char sym = symbol_stack[--symbol_stack_pointer]; //取运算符

                if (sym == ‘(‘) //左括号，直接退出
                {
                    break;
                }

                //取出数字
                int val2 = data_stack[--data_stack_pointer];
                int val1 = data_stack[--data_stack_pointer];

                //计算答案
                data_stack[data_stack_pointer++] = Calculate(val1, val2, sym);
            }

            //符号入堆栈
            if(express[i] != ‘)‘ )
                symbol_stack[symbol_stack_pointer++] = express[i];


        }
    }

    cout << data_stack[0] << endl;


}