fork download
copy 
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<ctype.h>
  5. #include <math.h>
  6. struct stack {
  7. 	int alpha;
  8. 	struct stack *nxtPTR;
  9. };
  10.  
  11. typedef struct stack  Stack;
  12.  
  13. typedef  Stack *node;
  14.  
  15. 	struct stack_2 {
  16.  
  17. 	long	double alpha;
  18.  
  19. 	struct stack *nxtPTR_2;
  20. 	};
  21.  
  22. typedef struct stack_2  Stack_2;
  23.  
  24. typedef  Stack_2 *node_2;
  25.  
  26. node   topPTR = NULL;
  27.  
  28. node_2 topPTR_2 = NULL;
  29.  
  30. char check_stack(node data);
  31.  
  32. int isOperator(char c);
  33.  
  34. int precedence(char data_1, char   data_2);
  35.  
  36. void push_stack(node *topPTR, int value);
  37.  
  38. void push_stack_2(node_2 *topPTR_2,  double value);
  39.  
  40. int pop(node *fix) ;
  41.  
  42. double pop_2(node_2 *fix);
  43.  
  44.  
  45. char infix[2][200];
  46.  
  47. double end_line( char ( *data ) [200] );
  48.  
  49. int in_line(char  ( *data ) [200]  , int  lng  );
  50. int main(void) {
  51.  
  52.  
  53. 	sprintf((char *) infix,"(34.31 - 24.313) ^ 25 -  (24+24.31) + 21.31 +(21.63 ^ 3.42) / 24 ^ 31 / 13.63 - 25.31 * (24 ^ 3.21 + (24.42 - 24.35 ^ 5.31)  * (24.14 /  25.31))" );
  54.  
  55.  
  56.  
  57. int  k = strlen( (char * )  infix    );
  58.  double sl = 0;	
  59.  
  60.  
  61.  if (in_line( infix , k ) == 1){
  62.  
  63. 	sl =   end_line(  infix);
  64. 	printf("%.2f\n", sl );
  65.  }
  66.  
  67.  
  68.  
  69.  
  70.  
  71. return 0;
  72. }
  73.  
  74. double end_line( char ( *data ) [200] ){
  75.  
  76. double x = 0 , y = 0, sum = 0,ml = 0    ; 
  77. char	*point =   strtok(  (*data + 200), " " );
  78.  
  79.  
  80. 	while( point   ){
  81.  
  82. 		if(isdigit(  *point ) ){
  83.  
  84. 			ml  = atof( (char *)  point  )  ;
  85. 			push_stack_2( &topPTR_2,ml);
  86.  
  87. 			}	
  88.  
  89. 		else if ( isOperator ( *point ) == 1 ){
  90.  
  91. 			y =	pop_2(&topPTR_2);
  92. 			x = pop_2(&topPTR_2);	 	
  93.  
  94. 		if( *point  == '^' ){
  95.  
  96. 			sum  =  pow(x, y) 	  ;
  97. 			push_stack_2(  &topPTR_2, sum  );
  98. 			}
  99.  
  100.  
  101. 			if( *point  == '*' ){
  102.  
  103.  
  104. 				 push_stack_2(&topPTR_2,    	x * y         );
  105. 			 }
  106.  
  107. 		 	if( *point == '+' ){
  108.  
  109. 				 push_stack_2(&topPTR_2, 	x + y  	 );
  110. 			}
  111.  
  112. 	     	if(  *point == '/' ){
  113.  
  114. 				push_stack_2(&topPTR_2, x / y    );
  115. 			 }
  116.  
  117. 			 if(   *point == '-' ){
  118.  
  119. 						 push_stack_2(&topPTR_2,   x - y     );
  120. 				}
  121. 			}
  122.  
  123. 			point = strtok(NULL , " " ) ;
  124. 				}
  125.  
  126.  
  127. 	return    pop_2(&topPTR_2);
  128. }
  129.  
  130.  
  131. int in_line(char ( *data ) [200] , int  lng ){
  132.  
  133.  
  134. int j = 0  , k = 0 , d = 0;
  135.  
  136.  
  137.  
  138. 	(*(*data + lng  ) ) = ')';
  139.     push_stack(&topPTR, '(');
  140.  
  141.  
  142. 	for (k = 0; check_stack((void *) &topPTR) != 1   ; k++)  {
  143.  
  144. 		if (  isdigit(  	(*(*data + k  ) )  ) ||  	(*(*data + k  ) ) == '.'  ) {
  145.  
  146. 				*(*data + 200 + j++ )   = 	(*(*data + k  ) );
  147.  
  148. 		}
  149.  
  150. 		if (	(*(*data + k  ) ) == '(') {
  151.  
  152. 			push_stack(&topPTR, (*(*infix + k  ) ) ) ;
  153.  
  154. 		}
  155. 			if (isOperator((*(*data + k  ) )  ) == 1) {
  156. 				*(*data + 200 + j++ )  = ' ';
  157. 			for (;         precedence(topPTR->alpha, (*(*data + k  ) )  ) != -1 ; ) {
  158.  
  159. 			*(*data + 200 + j++ )= pop(&topPTR);
  160. 			*(*data + 200 + j++ )  = ' ';	
  161. 		}
  162.  
  163. 			push_stack(&topPTR, 	(*(*data + k  ) ) );
  164. 			push_stack(&topPTR, ' ' );
  165.  
  166. 		}
  167.  
  168. 		if (	(*(*data + k  ) ) == ')') {
  169.  
  170. 		d = pop(&topPTR);
  171. 			for (; d != '('     ; 	d = pop(&topPTR)) {
  172. 					*(*data + 200 + j++ )  = d;
  173.  
  174. 				}
  175. 			}
  176.  
  177. 		else if (isalpha((*(*data + k  ) )   ) ) {
  178. 			puts ("error");
  179. 			return 0;
  180. 		}
  181.  
  182. 		}
  183.  
  184. 	return 1;
  185. 	}
  186.  
  187.  
  188. void push_stack(node *topPTR, int value) {
  189.  
  190. 	node newPTR = malloc(sizeof(Stack));
  191.  
  192. 	if (newPTR != NULL) {
  193.  
  194. 		newPTR->alpha = value;
  195. 		newPTR->nxtPTR = *topPTR;
  196. 		*topPTR = newPTR;
  197.  
  198. 	}
  199. 	else {
  200.  
  201. 		puts("error");
  202. 	}
  203. }
  204.  
  205. void push_stack_2(node_2 *topPTR_2,  double value) {
  206.  
  207. 	node_2 newPTR = malloc(sizeof(Stack_2));
  208.  
  209. 	if (newPTR != NULL) {
  210.  
  211. 		newPTR->alpha = value;
  212. 		newPTR->nxtPTR_2 = (void *)  *topPTR_2;
  213. 		*topPTR_2 = newPTR;
  214.  
  215. 	}
  216. 	else {
  217.  
  218. 		puts("error");
  219. 	}
  220. }
  221.  
  222. int pop(node *fix) {
  223.  
  224. 	int  value = 0;
  225. 	node temp = *fix;
  226. 	value = (*fix)->alpha;
  227. 	*fix = (*fix)->nxtPTR;
  228. 	free(temp);
  229.  
  230. return value;
  231. }
  232.  
  233. double pop_2(node_2 *fix) {
  234.  
  235. 	double  value = 0;
  236. 	node_2 temp = *fix;
  237. 	value = (*fix)->alpha;
  238. 	*fix = (void *)   (*fix)->nxtPTR_2;
  239. 	free(temp);
  240.  
  241. return value;
  242. }
  243.  
  244.  
  245.  
  246. char check_stack(node data) {
  247.  
  248. 	return data->alpha   ==  0  ;
  249.  
  250. }
  251.  
  252. int isOperator(char c) {
  253.  
  254. 	return c == '/' || c == '*' || c == '-' || c == '+' || c == '^' ;
  255.  
  256. }
  257.  
  258. int precedence(char data_1, char  data_2) {
  259.  
  260. 	switch(data_1){
  261. 		case '(':	
  262.  
  263. 		return -1;
  264. 		case '^':
  265.  
  266. 			if(data_2 == '^' ){
  267. 				return    0;
  268. 				} 
  269.  
  270. 	 	case 	'/' : 
  271.         case 	'*':        
  272.  
  273. 			if(data_2 == '^' ){
  274. 					return    -1;
  275. 				} 
  276.  
  277. 			else if( data_2 == '/' || data_2 == '*'     ){
  278. 					return    0;
  279. 					}	
  280.  
  281. 			else if( data_2 == '+' || data_2 == '-'     ){
  282. 						return     1;
  283. 					}
  284. 		case  ' ':
  285. 		case  '+':
  286. 		case  '-':		
  287.  
  288. 		if(data_2 == '^'  || data_2 == '/' || data_2 == '*'        ){
  289. 			return    -1;
  290. 				} 
  291. 		else{
  292. 			return     0;
  293. 		}
  294. 	}
  295. return 0;
  296. }
  297.  
Success #stdin #stdout 0s 4376KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
9925269380023446027632640.00
https://ideone.com/ep4v00
language:
C (gcc 8.3)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!