#include <stdio.h>
#include <stdlib.h>
#define LENGTH 9999
#include "memory.h"

int Err=0;
void InToPost(char*, char*);
int Priority(char);
long long int PostToInt(char*);
long long int Cal(char, long long int, long long int);
long long
123
1 2 3

1. #include <stdio.h>
2. #include <stdlib.h>
3. #define LENGTH 9999
4. #include "memory.h"
5.  
6. int Err=0;
7. void InToPost(char*, char*);
8. int Priority(char);
9. long long int PostToInt(char*);
10. long long int Cal(char, long long int, long long int);
11.  
12. int main(void)
13. {
14.     char Infix[LENGTH] = {'\0'};
15.     char Postfix[LENGTH]= {'\0'};
16.     int i;
17.     long long int val;
18.  
19.     scanf("%s", Infix);
20.     InToPost(Infix, Postfix);
21.  
22.     if(Err==1)
23.     {
24.         printf("Error!\n");
25.         return 0;
26.     }
27.  
28.     for(i = 0; Postfix[i] != '\0'; i++)
29.     {
30.         printf("%c", Postfix[i]);
31.     }
32.     printf("\n");
33.  
34.     val=PostToInt(Postfix);
35.    
36.     if(Err==1)
37.     {
38.         printf("Error!\n");
39.         return 0;
40.     }
41.    
42.     printf("%lld\n", val);
43.    
44.     return 0;
45. }
46.  
47. void InToPost(char* Infix, char* Postfix)
48. {
49.     char Stack[LENGTH] = {'\0'};
50.     int i, j, Stack_Top;
51.     int temp=0;
52.  
53.     for(i = 0; Infix[i] != '\0'; i++)
54.     {
55.         if(Infix[i]=='(')
56.             temp++;
57.         if(Infix[i]==')')
58.             temp--;  
59.        
60.         if(temp<0)
61.         {
62.             Err = 1;
63.             return;
64.         }
65.     }
66.    
67.     if(temp!=0)
68.     {
69.         Err = 1;
70.         return;
71.     }
72.    
73.     for(i = 0, j = 0, Stack_Top = 0; Infix[i] != '\0'; i++)
74.     {
75.         if(i==0)
76.         {
77.             if(Infix[i]=='-')
78.                 {
79.                     Postfix[j++] = '-';
80.                     i++;
81.                 }
82.             else if(Infix[i]=='+')
83.                 {
84.                     Postfix[j++] = '+';
85.                     i++;
86.                 }
87.             else if(Infix[i]=='*' || Infix[i]=='/' || Infix[i]=='%')
88.                 {
89.                     Err = 1;
90.                     return;
91.                 }
92.         }
93.        
94.         switch(Infix[i])
95.         {
96.             case '(':
97.                 if(Infix[i+1]=='*' || Infix[i+1]=='/' || Infix[i+1]=='%')
98.                 {
99.                     Err = 1;
100.                     return;
101.                 }      
102.                 Stack[++Stack_Top] = Infix[i];
103.                 if(Infix[i+1]=='-')
104.                 {
105.                     Postfix[j++] = '-';
106.                     i++;
107.                 }
108.                 break;
109.                
110.             case '+': case '-': case '*': case '/': case '%':
111.                 if(Infix[i+1]=='*' || Infix[i+1]=='/' || Infix[i+1]=='%' || Infix[i+1]=='\0')
112.                 {
113.                     Err = 1;
114.                     return;
115.                 }
116.                 while(Priority(Stack[Stack_Top]) >= Priority(Infix[i]))
117.                 {
118.                     if(Postfix[j-1]!=' ')
119.                     {
120.                         Postfix[j++] = ' ';
121.                     }
122.                     Postfix[j++] = Stack[Stack_Top--];
123.                 }
124.                 Postfix[j++] = ' ';
125.                 Stack[++Stack_Top] = Infix[i];
126.                 if(Infix[i+1]=='-')
127.                 {
128.                     if(Infix[i+2]=='+' || Infix[i+2]=='-')
129.                     {
130.                         Err=1;
131.                         return;
132.                     }
133.                     Postfix[j++] = '-';
134.                     i++;
135.                 }
136.                 if(Infix[i+1]=='+')
137.                 {
138.                     if(Infix[i+2]=='+' || Infix[i+2]=='-')
139.                     {
140.                         Err=1;
141.                         return;
142.                     }
143.                     i++;
144.                 }              
145.                 break;
146.                
147.             case ')':
148.                 if(Infix[i+1]!='+' && Infix[i+1]!='-' && Infix[i+1]!='*' && Infix[i+1]!='/' && Infix[i+1]!='%' && Infix[i+1]!='\0'&& Infix[i+1]!=')')
149.                     {
150.                         Err = 1;
151.                         return;
152.                     }
153.                 while(Stack[Stack_Top] != '(')
154.                 {
155.                     Postfix[j++] = ' ';
156.                     Postfix[j++] = Stack[Stack_Top--]; 
157.                 }
158.                 Stack_Top--;
159.                 break;
160.                
161.             default:
162.                 if(Infix[i]>57 || Infix[i]<48)
163.                 {
164.                     Err = 1;
165.                     return;
166.                 }              
167.                 Postfix[j++] = Infix[i];
168.         }
169.     }
170.    
171.     while(Stack_Top > 0)
172.     {
173.         Postfix[j++] = ' ';
174.         Postfix[j++] = Stack[Stack_Top--];
175.     }
176. }
177.  
178. int Priority(char op)
179. {
180.     switch(op)
181.     {
182.         case '+': case '-':
183.             return 1;
184.         case '*': case '/': case '%':
185.             return 2;
186.         default:            
187.             return 0;
188.     }
189. }
190.  
191. long long int PostToInt(char* Postfix)
192. {
193.     char temp[9999] = {'\0'};
194.     long long int stack[LENGTH] = {'\0'};
195.     int top, i, j;
196.    
197.     for(top = 0, i = 0; Postfix[i] != '\0'; i++)
198.         switch(Postfix[i])
199.         {
200.             case '+': case '-':
201.                 if(Postfix[i+1]>47 && Postfix[i+1]<58)
202.                 {
203.                     for(j = 0; Postfix[i] != ' '; i++, j++)
204.                     {
205.                         temp[j] = Postfix[i];
206.                     }
207.                     stack[++top] = atoll(temp);
208.                     memset(temp, '\0', sizeof(temp));
209.                     break;
210.                 }
211.                 stack[top - 1] = Cal(Postfix[i], stack[top - 1], stack[top]);
212.                 top--;
213.                 break;
214.                
215.             case '/': case '%':
216.                 if(stack[top]== 0)
217.                 {
218.                     Err=1;
219.                     return 0;
220.                 }
221.                 stack[top - 1] = Cal(Postfix[i], stack[top - 1], stack[top]);
222.                 top--;
223.                 break;
224.                
225.             case '*':
226.                 stack[top - 1] = Cal(Postfix[i], stack[top - 1], stack[top]);
227.                 top--;
228.                 break;
229.                  
230.             case ' ':
231.                 break;
232.                
233.             default:
234.                 for(j = 0; Postfix[i] != ' '; i++, j++)
235.                 {
236.                     temp[j] = Postfix[i];
237.                 }
238.                 stack[++top] = atoll(temp);
239.                 memset(temp, '\0', sizeof(temp));
240.         }
241.        
242.     return stack[top];
243. }
244.  
245. long long int Cal(char op, long long int N1, long long int N2)
246. {
247.     switch(op)
248.     {
249.         case '+':
250.             return N1 + N2;
251.         case '-':
252.             return N1 - N2;
253.         case '*':
254.             return N1 * N2;
255.         case '/':
256.             return N1 / N2;
257.         case '%':
258.             return N1 % N2;
259.     }
260.    
261.     return 0;
262. }