纯题目分享

P1981 [NOIP2013 普及组] 表达式求值

题目描述:给定一个只包含加法和乘法的算术表达式，请你编程计算表达式的值。

输入格式:一行，为需要你计算的表达式，表达式中只包含数字、加法运算符 + 和乘法运算符 *，且没有括号  

输出格式:一个整数，表示这个表达式的值。注意：当答案长度多于 4 位时，请只输出最后 4 位，前导 0 不输出。

 分析:这道题也就是写出一个模拟计算机的程序,首先将表达式按加号拆分成多个项，然后再遍历每一项，将每一项按乘号拆分成多个因子，并计算每一项的乘积。最后将每一项的乘积相加，得到最终的结果。

1.用Python的代码 非常简单

def calculate(expression):
    # 将表达式按加法拆分成项
    terms = expression.split('+')
    total_sum = 0

    # 遍历每一项
    for term in terms:
        # 将每一项按乘法拆分成因子
        factors = term.split('*')
        sum = 1

        # 计算每一项的乘积
        for factor in factors:
            sum *= int(factor)

        # 将每一项的乘积加到总和中
        total_sum += sum
    # 返回最终的总和
    return total_sum

# 获取用户输入的表达式
expression = input()

# 调用 calculate 函数计算结果
result = calculate(expression)
end_result=result%10000

print(end_result)

2.c的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义栈结构
typedef struct {
    int* items;
    int top;
    int size;
} Stack;

// 初始化栈
void initStack(Stack* stack, int size) {
    stack->items = (int*)malloc(size * sizeof(int));
    stack->top = -1;
    stack->size = size;
}

// 判断栈是否为空
int isEmpty(Stack* stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(Stack* stack) {
    return stack->top == stack->size - 1;
}

// 入栈
void push(Stack* stack, int item) {
    if (isFull(stack)) {
        printf("栈已满，无法入栈。\n");
        return;
    }
    stack->items[++stack->top] = item;
}

// 出栈
int pop(Stack* stack) {
    if (isEmpty(stack)) {
        printf("栈为空，无法出栈。\n");
        return -1;
    }
    return stack->items[stack->top--];
}

// 获取栈顶元素
int peek(Stack* stack) {
    if (isEmpty(stack)) {
        printf("栈为空。\n");
        return -1;
    }
    return stack->items[stack->top];
}

// 计算只包含加法和乘法的算术表达式的值
int calculate(char* expression) {
    Stack numStack;  // 存储数字的栈
    Stack opStack;   // 存储操作符的栈
    int len = strlen(expression);
    int i, num = 0;
    char op;

    initStack(&numStack, len);
    initStack(&opStack, len);

    for (i = 0; i < len; i++) {
        if (expression[i] >= '0' && expression[i] <= '9') {
            // 如果是数字，将其转换为整数并入栈
            num = num * 10 + (expression[i] - '0');
        }
        else {
            // 如果是操作符，处理之前的数字和操作符
            push(&numStack, num);
            num = 0;

            op = expression[i];

            if (op == '+' || op == '*') {
                // 如果是加法或乘法操作符，将其入栈
                if (!isEmpty(&opStack) && peek(&opStack) == '*') {
                    // 如果操作符栈顶是乘法操作符，则先计算乘法
                    int factor2 = pop(&numStack);
                    int factor1 = pop(&numStack);
                    int result = factor1 * factor2;
                    push(&numStack, result);
                    pop(&opStack);
                }
                push(&opStack, op);
            }
        }
    }

    // 处理最后一个数字
    push(&numStack, num);

    // 计算剩余的乘法
    while (!isEmpty(&opStack)) {
        int factor2 = pop(&numStack);
        int factor1 = pop(&numStack);
        int result = factor1 * factor2;
        push(&numStack, result);
        pop(&opStack);
    }

    // 计算最终结果
    int result = 0;
    while (!isEmpty(&numStack)) {
        result += pop(&numStack);
    }

    return result;
}

int main() {
    char expression[100];

    printf("请输入只包含加法和乘法的算术表达式：");
    fgets(expression, sizeof(expression), stdin);
    expression[strlen(expression) - 1] = '\0';  // 去掉换行符

    int result = calculate(expression);

    printf("计算结果：%d\n", result);

    return 0;
}

LeetCode 最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

分析:这道题运用动态规划的思想,每次遍历一个数,加起来看使得是加以后得数大,还是被遍历到的数大,所以还需要用一个变量来存储这个数.也就是这个f(i)=max{f(i−1)+nums[i],nums[i]}.看是前一段式子大还是被遍历到的数大.然后再用f(i)与f(i-1)比较谁大,然后更新f(i)  

int maxSubArray(int* nums, int numsSize) {
    int pre=0,maxans=nums[0];
    for(int i=0;i<numsSize;i++)
    {
        pre=fmax(nums[i]+pre,nums[i]);
        maxans=fmax(pre,maxans);
    }
    return maxans;
}