fork download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #define MAX 10
  6.  
  7. int contas_validas = 0;
  8. int contas_invalidas = 0;
  9. int movimentos_validos = 0;
  10. int movimentos_invalidos =0;
  11.  
  12. typedef struct conta {
  13.     char saldo[1000000];
  14.     char limite_saldo[1000000];
  15.     char id[11];
  16. } Conta;
  17.  
  18. typedef struct movimento {
  19.     int tipo_movimento;
  20.     int opcao;
  21. } Movimento;
  22.  
  23. int validar_id(char* id){
  24.  
  25.     if (id[3] == '-' && id[9] == '-' && id[11] == '\0'){
  26.  
  27. 			int i = 0;
  28.  
  29. 			for(i = 0; i < 11; i++){
  30. 				if(i != 3 && i != 9){
  31. 					if(isdigit(id[i]) == 0){
  32. 						return 0;
  33. 					}
  34. 				}
  35. 			}
  36. 	}
  37. 	else{
  38. 		return 0;
  39. 	}
  40. 	return 1;
  41. }
  42.  
  43. int validar_id2 (char* id) {
  44.  
  45.     int componente_a = ((id[0]-'0')+ (id[1]-'0')+(id[2]-'0'));
  46.     int componente_b = ((id[4]-'0')+ (id[5]-'0')+(id[6]-'0')+(id[7]-'0')+(id[8]-'0'));
  47.     int componente_c = (id[10]-'0');
  48.  
  49.     int soma1 = componente_a;
  50.     int soma2 = componente_a + componente_b;
  51.     int resto = soma2 % soma1;
  52.  
  53.     if (resto == componente_c) {
  54.         return 1;
  55.     }
  56. 	else {
  57.         return 0;
  58.     }
  59. }
  60.  
  61. int validar_saldo(char *str) {
  62. 	fprintf(stderr, "DEBUG: valor passado: [%s]\n", str);
  63.     if (*str == '-') str++;
  64.     if (!isdigit((unsigned char)*str)) return 0; /* empty strings return false */
  65.     while (*str) {
  66.         if (!isdigit((unsigned char)*str)) return 0;
  67.         str++;
  68.     }
  69.     return 1;
  70. }
  71.  
  72. int is_valid_n_chars(char * string, size_t size, char * chars) {
  73.   int sindex = 0, cindex = 0;
  74.  
  75.   // ciclo de validação da string dada
  76.   while(sindex < size && string[sindex] != '\0') {
  77.     // pesquisa do caracter iterado na lista de caracteres válidos
  78.     for (cindex = 0;
  79.          chars[cindex] != '\0' && string[sindex] != chars[cindex];
  80.          cindex++) /* void */;
  81.  
  82.     // verificação se o caracter foi encontrado
  83.     if (chars[cindex] == '\0')
  84.       return 0;
  85.  
  86.     // incremento da iteração
  87.     sindex++;
  88.   }
  89.  
  90.   // é válido se chegou ao fim da string com todos os caracteres validados
  91.   // (verificação de string[sindex] == '\0' mas sindex < size)
  92.   return sindex == size;
  93. }
  94.  
  95. int is_valid_chars(char * string, char * chars) {
  96.   return is_valid_n_chars(string, strlen(string), chars);
  97. }
  98.  
  99. int is_valid_n_number(char * string, size_t size) {
  100.   return is_valid_n_chars(string, size, "0123456789");
  101. }
  102.  
  103. int is_valid_number(char * string) {
  104.   return is_valid_n_number(string, strlen(string));
  105. }
  106.  
  107. int validar_movimento (char * mov){
  108.     if (mov[0] == 0){
  109.         printf ("Transferencia.\n");
  110.     }
  111. 	else if (mov[0] == 1){
  112.         printf ("Deposito.\n");
  113.     }
  114. 	else if (mov[0] == 2){
  115.         printf ("Levantamento.\n");
  116.     }
  117. 	else{
  118.         return 0;
  119.     }
  120.     return 0;
  121. }
  122.  
  123. void transferencia ( Conta*  a , char id[] , char id2[] , char valor[] ){
  124. 	int i=0;
  125. 	int j=0;
  126. 	int valor1;
  127. 	int valor2;
  128.  
  129. 	for ( i; i<contas_validas ; i++){
  130. 		if(strcmp( a[i].id , id ) == 0)
  131. 			break;
  132. 	}
  133.  
  134. 	for ( j ; j<contas_validas ; j++){
  135. 		if(strcmp( a[j].id , id2) == 0)
  136. 			break;
  137. 	}
  138.  
  139. 	valor1 = atoi(a[i].saldo);
  140. 	valor1 -= atoi(valor);
  141. 	valor2 = atoi(a[j].saldo);
  142. 	valor2 += atoi(valor);
  143.  
  144. 	snprintf( a[i].saldo , sizeof(a[i].saldo) , "%d" , valor1);
  145. 	snprintf( a[j].saldo , sizeof(a[j].saldo) , "%d" , valor2);
  146. }
  147.  
  148. void deposito ( Conta* a , char id[] , char valor[] ){
  149. 	int valor1;
  150. 	int i=0;
  151.  
  152. 	for ( i ; i<contas_validas ; i++ ){
  153. 		if(strcmp( a[i].id , id ) == 0)
  154. 		break;
  155. 	}
  156.  
  157. 	valor1 = atoi(a[i].saldo);
  158. 	valor1 += atoi(valor);
  159. 	snprintf( a[i].saldo , sizeof(a[i].saldo) , "%d" , valor1);
  160. }
  161.  
  162. void levantamento ( Conta* a , char id[] , char valor[] ){
  163. 	int valor1;
  164. 	int i=0;
  165.  
  166. 	for ( i ; i<contas_validas ; i++ ){
  167. 		if(strcmp( a[i].id , id ) == 0)
  168. 			break;
  169. 	}
  170.  
  171. 	valor1 = atoi(a[i].saldo);
  172. 	valor1 -= atoi(valor);
  173. 	snprintf( a[i].saldo , sizeof(a[i].saldo) , "%d" , valor1);
  174. }
  175.  
  176. int valida_opcao_mov ( char a[])
  177. {
  178. 	if ( a[0] == '0' || a[0] == '1' || a[0] == '2')
  179. 		return 1;
  180. 	else 
  181. 		return 0;
  182. }
  183.  
  184. void movimentos (Conta* guardar_conta)
  185. {
  186.  
  187.     FILE * fp = fopen ("movimentos.txt", "r");
  188.  
  189.     if (fp != NULL)
  190. 	{
  191.  
  192. 		char temp[255+1];
  193.         char * componentes;
  194.         int contador = 0;
  195. 		char operacao[1];
  196. 		char id_origem[11];
  197. 		char id_destino[11];
  198. 		char valor[1000000];
  199.  
  200.         while (fgets(temp, 255+1, fp) != NULL)
  201. 		{
  202. 			printf ("\n-> %s\n\n", temp);
  203. 			contador = 0;
  204.  
  205. 			int last = strlen (temp);
  206.             if (temp[last-1] == '\n')
  207. 				temp[last-1] = '\0';
  208.  
  209.             componentes = strtok (temp, " ");
  210.  
  211. 			while (componentes != NULL)
  212. 			{
  213.  
  214. 				if (contador == 0 )
  215. 				{
  216. 					strcpy(operacao , componentes);
  217. 					valida_opcao_mov ( operacao );
  218. 				}
  219. 				else if(contador == 1)
  220. 				{
  221. 					strcpy( id_origem , componentes);
  222. 				}
  223. 				else if(contador == 2)
  224. 				{
  225. 					if ( operacao[0] == '0')
  226. 						strcpy(id_destino , componentes);
  227. 					if ( operacao[0] == '1' || operacao[0] == '2' )
  228. 						strcpy( valor , componentes );
  229. 				}
  230. 				else if( contador== 3)
  231. 					{
  232. 						if ( operacao[0] == '0')
  233. 							strcpy( valor , componentes );
  234. 						else
  235. 						{
  236. 							printf( "Movimento invalido\n");
  237. 							movimentos_invalidos++;
  238. 						}
  239. 					}
  240.  
  241. 				componentes = strtok (NULL, " ");
  242. 				contador++;
  243. 			}
  244. 			if ( operacao[0] == '0' )
  245. 				transferencia( guardar_conta , id_origem , id_destino , valor);
  246. 			if ( operacao[0] == '1' )
  247. 				deposito ( guardar_conta , id_origem , valor );
  248. 			if ( operacao[0] == '2' )
  249. 				levantamento( guardar_conta , id_origem , valor );
  250. 		}
  251. 		fclose(fp);
  252. 	}
  253. }
  254.  
  255. void contas (Conta* a){
  256.  
  257. 	FILE* fp = fopen ("contas.txt", "r"); //"r" -> leitura (modo texto) ou "b" -> leitura (modo binario)
  258. 	FILE* fp2 = fopen ("stats.txt", "w");
  259.  
  260.  
  261.     if (fp != NULL){
  262.  
  263. 			char tmpid[11];
  264. 			char tmpsaldo[1000000];
  265. 			char tmplimitecredito[1000000];
  266.             char contas[255+1];
  267.             char* temp_id[11+1];
  268.             char* componentes;
  269.             int contador = 0;
  270.             int val1;
  271.             int val2;
  272.             int val3;
  273.  
  274.             printf ("As contas existentes no ficheiro sao:\n");
  275.  
  276.             while (fgets(contas, 255+1, fp) != NULL)
  277. 			{
  278. 				printf ("\n-> %s\n\n", contas);
  279.                 contador = 0;
  280.  
  281.                 int last = strlen (contas);
  282.                 if (contas[last-1] == '\n')
  283.                     contas[last-1] = '\0';
  284.  
  285. 				componentes = strtok (contas, " ");
  286.  
  287. 				while (componentes != NULL)
  288. 				{
  289.  
  290. 					if (contador == 0)
  291. 					{
  292.  
  293. 						printf ("- ID = %s\n", componentes);
  294. 						strcpy(tmpid , componentes);
  295. 						int valido = validar_id (componentes);
  296. 						int valido2 = validar_id2 (componentes);
  297.  
  298. 						if (valido == 1 && valido2 == 1)
  299. 						{
  300. 							printf ("ID valido!\n");
  301. 							val1 = 1;
  302. 						}
  303. 						else 
  304. 						{
  305. 							printf ("ID invalido!\n");
  306. 							val1 = 0;
  307. 						}
  308. 					}
  309. 					else if (contador == 1)
  310. 					{
  311. 						strcpy(tmpsaldo , componentes);
  312. 						int valido = validar_saldo(componentes);
  313. 						if (valido == 1)
  314. 						{
  315. 							printf ("- Saldo: %s\n", componentes);
  316. 							val2 = 1;
  317. 						}
  318. 						else
  319. 						{
  320. 							printf ("Saldo invalido!\n");
  321. 							val2 = 0;
  322. 						}
  323. 					}
  324. 					else if (contador == 2)
  325. 					{
  326. 						strcpy(tmplimitecredito , componentes);
  327. 						int valido =  is_valid_number(componentes);
  328. 						/* ATENÇÂO AO FACTO DE NÃO HAVER COMPONENTE) */
  329. 						if (valido == 1)
  330. 						{
  331. 							printf ("- Limite de credito: %s\n", componentes);
  332. 							val3 = 1;
  333. 						}
  334. 						else
  335. 						{
  336. 							printf ("Limite de credito invalido!\n");
  337. 							val3 = 0;
  338. 						}
  339. 					}
  340.  
  341. 					componentes = strtok (NULL, " ");
  342. 					contador++;
  343.  
  344. 				}
  345.  
  346. 				if (val1 == 1 && val2 == 1 && val3 == 1)
  347. 				{
  348.  
  349. 						strcpy(a[contas_validas].id , tmpid);
  350. 						strcpy(a[contas_validas].saldo , tmpsaldo);
  351. 						strcpy(a[contas_validas].limite_saldo , tmplimitecredito);
  352. 						contas_validas++;
  353. 						if((contas_validas%MAX)==0)
  354. 						{
  355. 							Conta* ptr;
  356. 							ptr=(Conta*)realloc(a,sizeof(Conta)*(contas_validas+MAX));
  357. 							if(ptr!=NULL)
  358. 							{
  359. 								a=ptr;
  360. 								ptr=NULL;
  361. 							}
  362. 						}
  363. 				}
  364. 				else if (val1 == 0 || val2 == 0 || val3 == 0)
  365. 				{
  366.                     contas_invalidas++;
  367. 				}
  368.             }
  369.  
  370. 			fclose(fp);
  371.  
  372. 			printf ("\nNumero de contas validas: %d\n", contas_validas);
  373. 			printf ("\nNumero de contas invalidas: %d\n", contas_invalidas);
  374.     }
  375.     else{
  376. 		printf ("Erro!\n");
  377.     }
  378. }
  379. /*
  380. int compara_conta (Conta * c1, Conta * c2) {
  381.         if (c1 -> saldo > c2 -> saldo)
  382.             return 1;
  383.         if (c1 -> saldo = c2 -> saldo)
  384.             return 0;
  385.         if (c1 -> saldo < c2 -> saldo)
  386.             return -1;
  387. }
  388. */
  389.  
  390. int main() {
  391.  
  392. 	FILE * fp = fopen("contas-final.txt" , "w+");
  393. 	Conta* guardar_conta=(Conta*)malloc(sizeof(Conta)*MAX);
  394.     contas(guardar_conta);
  395. 	long int somatorioInicial = 0;
  396. 	int i = 0;
  397. 	for ( i  ; i< contas_validas ; i++){
  398.        somatorioInicial += atoi(guardar_conta[i].saldo);
  399. 	}
  400. 	printf("\n%d", somatorioInicial); /* ATENÇÂO AO COMENTÁRIO DE CIMA */
  401.     printf("\n");
  402. 	movimentos(guardar_conta);
  403. 	int n;
  404. 	for ( n=0 ; n<contas_validas ; n++){
  405. 		fprintf(fp , "%s %s %s\n" , guardar_conta[n].id , guardar_conta[n].saldo ,guardar_conta[n].limite_saldo);
  406. 	}
  407. 	fclose(fp);
  408.  
  409.     return 0;
  410. }
Runtime error #stdin #stdout 0s 23336KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/T5QXyM
language:
C (gcc 8.3)
created:
12 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!