stackmachine

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


long max(long a, long b) {
        if (a >= b) return a;
        else return b;
}

long min(long a, long b) {
        if (a <= b) return a;
        else return b;
}

void swap(long a, long b) {
        long t = 0;
        t = a;
        a = b;
        b = t;
}

void f_const(long a, long data[], long *i) {
        data[(*i)] = a;
        (*i)++;
}

void f_add(long data[], long *i) {
        (*i)--;
        data[(*i) - 1] = data[(*i)] + data[(*i) - 1];
}

void f_sub(long data[], long *i) {
        (*i)--;
        data[(*i) - 1] = data[(*i)] - data[(*i) - 1];
}

void f_mul(long data[], long *i) {
        (*i)--;
        data[(*i) - 1] = data[(*i)] * data[(*i) - 1];
}

void f_div(long data[], long *i) {
        (*i)--;
        data[(*i) - 1] = data[(*i)] / data[(*i) - 1];
}

void f_max(long data[], long *i) {
        (*i)--;
        if (data[(*i)] > data[(*i) - 1]) data[(*i) - 1] = data[(*i)];
}

void f_min(long data[], long *i) {
        (*i)--;
        if (data[(*i)] > data[(*i) - 1])
          data[(*i) - 1] = data[(*i) - 1];
        else data[(*i) - 1] = data[(*i)];
}

void f_neg(long a, long data[], long *i) {
        (*i)--;
        a = data[(*i)];
        data[(*i)] = -a;
        (*i)++;
}

void f_dup(long data[], long *i) {
        data[(*i)] = data[(*i) - 1];
        (*i)++;
}

void f_swap(int a, long data[], long *i) {
        (*i)--;
        a = data[(*i) - 1];
        data[(*i) - 1] = data[(*i)];
        data[(*i)] = a;
        (*i)++;
}

int main() {
        long n, i = 0;
        scanf("%ld", &n);
        long data[100000] = {0};
        for (long j = 0; j < n; j++) {
                char str[6], constt[6] = "CONST", add[5] = "ADD", sub[5] = "SUB",
                mul[5] = "MUL", div[5] = "DIV", max[5] = "MAX", min[5] = "MIN",
                neg[5] = "NEG", dup[5] = "DUP", swap[5] = "SWAP";
                long a = 0;
                scanf("%s", str);
                if (strcmp(str, constt) == 0) {
                        scanf("%ld", &a);
                        f_const(a, data, &i);
                }
                else if ((int)strcmp(str, add) == 0) f_add(data, &i);
                else if ((int)strcmp(str, sub) == 0) f_sub(data, &i);
                else if ((int)strcmp(str, mul) == 0) f_mul(data, &i);
                else if ((int)strcmp(str, div) == 0) f_div(data, &i);
                else if ((int)strcmp(str, max) == 0) f_max(data, &i);
                else if ((int)strcmp(str, min) == 0) f_min(data, &i);
                else if ((int)strcmp(str, neg) == 0) f_neg(a, data, &i);
                else if ((int)strcmp(str, dup) == 0) f_dup(data, &i);
                else if ((int)strcmp(str, swap) == 0) f_swap(a, data, &i);
        }
        //for (long i = 0; i < n; i++) {
        //  printf("%ld ", data[i]);
        //}
        printf("%ld ", data[i - 1]);
    return 0;
}

____________________________________________________________________________________________________________________________

Стековая машина

Пусть стековая машина – это устройство для выполнения арифметических операций, использующее для хранения промежуточных результатов вычислений стек целых чисел. Подразумевается, что каждая операция берёт операнды из стека и оставляет на стеке результат.
Составьте программу stackmachine.c, моделирующую работу стековой машины.

Формат входных данных
Первая строка, считываемая со стандартного потока ввода, содержит общее количество выполняемых операций n (0 < n ≤ 100000). Каждая из следующих n строк содержит описание операции.
Стековая машина должна обеспечивать выполнение следующих операций:

CONST x – кладёт в стек число x (-1000000000 < x < 1000000000);
ADD – сложение (снимает со стека два операнда a и b и кладёт в стек их сумму);
SUB – вычитание (снимает со стека операнд a, затем снимает со стека операнд b, кладёт в стек a - b);
MUL – умножение (снимает со стека два операнда a и b и кладёт в стек их произведение);
DIV – деление (снимает со стека операнд a, затем снимает со стека операнд b, кладёт в стек результат целочисленного деления a на b);
MAX – максимум двух чисел (снимает со стека два операнда a и b и кладёт в стек max(a,b));
MIN – минимум двух чисел (снимает со стека два операнда a и b и кладёт в стек min(a,b));
NEG – меняет знак числа, находящегося на вершине стека;
DUP – кладёт в стек копию числа, находящегося на вершине стека;
SWAP – меняет местами два числа, находящиеся на вершине стека.
Можно считать, что последовательность операций составлена правильно, то есть перед вызовом каждой операции стек содержит нужное ей количество операндов, деление на ноль и переполнение не возникают, и, кроме того, в результате выполнения всех операций на стеке остаётся единственное число.
Формат результата работы программы
В стандартный поток вывода необходимо вывести число, оставшееся на вершине стека в результате выполнения последовательности операций.
Пример работы программы

Ввод:
6
CONST 10
NEG
CONST 20
SUB
CONST 15
MAX
Вывод:
30