elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


  Mostrar Mensajes
Páginas: [1] 2
1  Programación / Programación C/C++ / Re: Pilas de caracteres en C en: 19 Septiembre 2021, 18:59 pm
Hola MAFUS

Pues en teoría se supone que el tmpCad me ayuda a vaciar la cadena principal, dandole valores de '0' para vaciarla según la condición.

Y también quiero ver como poder sustituir la que no se usa con la princpial
2  Programación / Programación C/C++ / Pilas de caracteres en C en: 19 Septiembre 2021, 15:58 pm
Hola buen día a todos, espero me puedan orientar o ayudar con lo siguiente:

Me gustaría saber como puedo implementar el siguiente código:

Código:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#include<locale.h>

#define MAX 50

struct nodo {
    char simbolo;
    struct nodo *sig;
};

struct nodo *raiz=NULL;

void insertar(char x)
{
    struct nodo *nuevo;
    nuevo = malloc(sizeof(struct nodo));
    nuevo->simbolo = x;
    if (raiz == NULL)
    {
        raiz = nuevo;
        nuevo->sig = NULL;
    }
    else
    {
        nuevo->sig = raiz;
        raiz = nuevo;
    }
}


char extraer()
{
    if (raiz != NULL)
    {
        char informacion= raiz->simbolo;
        struct nodo *bor = raiz;
        raiz = raiz->sig;
        free(bor);
        return informacion;
    }
    else
    {
        return -1;
    }
}

void liberar()
{
    struct nodo *reco = raiz;
    struct nodo *bor;
    while (reco != NULL)
    {
        bor = reco;
        reco = reco->sig;
        free(bor);
    }
}

int vacia()
{
    if (raiz == NULL)
        return 1;
    else
        return 0;
}

void cargarCadena(char *cadena)
{
    printf("Ingrese la cadena: ");
    gets(cadena);
}

int verificarCaracteres(char *cadena)
{
    int i, j=0;
    char tmpCad[MAX];
    
    for (i=0;i<strlen(cadena);i++)
    {
        if (cadena[i]=='.') 
        {
            exit( 0 );
    		return 0;
        }
        else
        {
            if (cadena[i]=='!')
            {
                tmpCad[j] = cadena[i];
                
                tmpCad[j] = '\0';

				puts(tmpCad);
				return 0;
                
            }
            //
        }
        //j++;
    }
    if (vacia())
    {
        return 1;
    }
    else
    {
        return 0;
    }
}


int main()
{	

	setlocale(LC_ALL, "spanish");
	
    char cadena[MAX];
    char tmpCad[MAX];
    
    cargarCadena(cadena);
    if (verificarCaracteres(cadena))
    {
        printf("Proceso finalizado con éxito");
    }
    else
    {
        printf("La cadena esta vacia");
        
		
    }
    liberar();
    getch();
    return 0;
}

Se supone debe cumplir lo siguiente:
Citar
Si el carácter es ‘@’, eliminar la última palabra. Por ejemplo, si se tiene la cadena “cadena de caracteres yu378”, la última palabra es “yu378”.
Si el carácter es ‘,’, se elimina el último carácter.
Si el carácter es ‘!’ se eliminan todos los caracteres que se hayan introducido.
Si el carácter es ‘.’ se termina el programa.
Por cada operación realizada se deben mostrar los caracteres que queden

En la función VerificarCaracteres se supone ya hace lo de:
Citar
Si el carácter es ‘!’ se eliminan todos los caracteres que se hayan introducido.
Si el carácter es ‘.’ se termina el programa.
Pero no se si lo este aplicando bien, aunque el programa no me arroja advertencias o errores.

Y si me pudieran ayudar u orientar con lo demás se los agradecería bastante...
3  Programación / Programación C/C++ / Re: Código de inventario en C en: 25 Noviembre 2020, 05:46 am
Gracias K-YreX, ya hice cambios basado en tu valiosa ayuda

Quedando así:

Código
  1. void menuOrdenDescrp()
  2. {
  3. 	Producto *productos;
  4. 	int numeroProductos;
  5. 	int pos,i,j;
  6. 	char min[MAX];
  7. 	struct producto temp;
  8.  
  9. 	system("cls");
  10. 	tituloPrincipal();
  11. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  12.  
  13. 	if (numeroProductos == 0) {
  14. 		printf("\n\tEl archivo está vacío!!\n");
  15. 		system("pause>nul");
  16.  
  17. 	} else {
  18. 		/* Se recorre el vector dinámico de productos */
  19.  
  20. 		for (i = 0; i<numeroProductos-1; i++) 
  21. 		{
  22. 			strcpy(min, productos[i].descripcion);
  23. 			pos=i;
  24. 			for (j=i+1; j<numeroProductos-1; j++)
  25. 			    if (strcmp(productos[j].descripcion , min) < 0)
  26. 			    {
  27. 			    	strcpy(min, productos[j].descripcion);
  28. 			    	pos=j;
  29. 				}
  30.  
  31. 			}
  32. 			temp=productos[i];
  33. 			productos[i]=productos[pos];
  34. 			productos[pos]=temp;
  35.  
  36. 			printf("\n\tDatos ordenados:\n");
  37. 			for(i=0; i<numeroProductos; i++)
  38. 			{
  39. 				printf("\n\t%s\n",productos[i].descripcion);
  40. 			}
  41. 		}	
  43. }
  44.  

El único detalle que tengo ahora es que al ingresar por ejemplo:
-Dosis
-Botella
-Caja
Me los ordena a la inversa por decirlo de alguna manera, quedando así:  :-\
-Dosis
-Caja
-Botella
Cuando debiera ser:
-botella
-caja
-dosis  :(
4  Programación / Programación C/C++ / Re: Código de inventario en C en: 21 Noviembre 2020, 20:36 pm
Gracias estimado K-YreX. Ya intente poner el código para ordenar las descripciones y laboratorios alfabéticamente y respectivamente pero aún me marca error  :-\
Lo puse así utilizando strcmp:

Código
  1. void menuOrdenDescrp()
  2. {
  3. 	Producto *productos;
  4. 	int numeroProductos;
  5. 	int i,j,pos;
  6. 	char min[MAX];
  7. 	struct producto temp;
  8.  
  9. 	system("cls");
  10. 	tituloPrincipal();
  11. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  12.  
  13. 	if (numeroProductos == 0) {
  14. 		printf("\n\tEl archivo está vacío!!\n");
  15. 		system("pause>nul");
  16.  
  17. 	} else {
  18. 		/* Se recorre el vector dinámico de productos */
  19.  
  20. 		for (int i = 0; i < numeroProductos-1; i++) 
  21. 		{
  22. 			strcpy(min, productos[i].descripcion);
  23. 			pos=i;
  24. 			for (int j=i+1; j < numeroProductos; j++)
  25. 			    if (strcmp(productos[j].descripcion , min) < 0)
  26. 			    {
  27. 			    	strcpy(min, productos[j].descripcion);
  28. 			    	pos=j;
  29. 				}
  30. 				temp=productos[i];
  31. 				productos[i]=productos[pos];
  32. 				productos[pos]=temp;
  33. 			}
  34.  
  35. 			printf("Datos ordenados:");
  36. 			for(i=0; i<numeroProductos; i++)
  37. 			{
  38. 				printf("%s",productos[i].descripción);
  39. 			}
  40. 		}	
  41. 		system("pause>nul");
  42. }
  43.  
5  Programación / Scripting / Re: Graficar Tiro Parabólico en: 20 Noviembre 2020, 15:46 pm
Eres muy amable tincopasan, apesar de que siempre te doy molestias  :-(

Y créeme que si lo intento por eso no me canso de buscar, pero si muchas gracias por tu consejo y sabiduría  :-[

Y si no es molestia, podrías recomendarme algún libro, o canal de youtube para seguir aprendiendo más???
6  Programación / Programación C/C++ / Re: Código de inventario en C en: 19 Noviembre 2020, 21:23 pm
Muchas Gracias por no ignorarme xandrewx

Claro entiendo, y agradezco bastante el consejo
Y si trataré de poner la parte dónde existe la confusión para que no sea tan tedioso  :laugh:
7  Programación / Programación C/C++ / Código de inventario en C en: 19 Noviembre 2020, 04:13 am
Amigos necesito de su poderosa ayuda, este es mi código pero aún me faltan 3 acciones o menús, los cuales serían:
-Muestra el laboratorio de un producto buscándolo por su descripción, en este ya hice unos cambios que de hecho están en el menú "buscarDescripcion"; pero no me da el resultado que espero :(
-Ordenar alfabéticamente los productos por su descripción, utilizando método de selección
-Ordenar alfabéticamente los productos por laboratorio, utilizando método de inserción

POR FAVOR, CUALQUIER AYUDA O COMENTARIO ES BIENVENIDO  :(  :-(
ESPERO NO ME IGNOREN...
ESTE ES EL CÓDIGO:

Código
  1.  
  2.  
  3.  
  4.  
  5. #include <stdio.h>	
  6. #include <string.h>
  7. #include <stdlib.h>	
  8. #include <locale.h> 
  9.  
  10. #define MAX 80
  11. #define VALOR_CENTINELA -1
  12.  
  13. /* Estructuras */
  14. struct producto {
  15. 	int codigo;
  16. 	char nombre[MAX];
  17. 	char descripcion[MAX];
  18. 	char laboratorio[MAX];
  19. 	float costo;
  20. 	float precio;
  21. 	int cantidad;
  22. };
  23.  
  24. typedef struct producto Producto;
  25.  
  26. /* Opciones del Menú */
  27. void menuPrincipal();
  28. void menuInsertar();
  29. void menuBuscarClave();
  30. void menuBuscarDescripcion();
  31. void menuUtilidad();
  32. void menuMuestras();
  33. void menuEliminar();
  34. void menuMostrar();
  35. void menuModificar();
  36. void menuEliminarFisica();
  37. void menuStockMinimo();
  38.  
  39. /* Funciones para manejar el archivo directamente */
  40. Producto *obtenerProductos(int *n); /* Obtiene un vector dinámico de productos */
  41. char existeProducto(int codigoProducto, Producto *producto); /* Busca si existe el producto en el archivo de productos */
  42. char existeProducto2(char descripcionProducto, Producto *producto);
  43. char insertarProducto(Producto producto); /* Inserta el producto al final del archivo */
  44. char eliminarProducto(int codigoProducto); /* Eliminar el producto de código codigoProducto del archivo */
  45. char eliminacionFisica(); /* Realiza la eliminación física de registros inválidos del archivo de productos */
  46. char modificarProducto(Producto producto); /* Modifica el producto en el archivo */
  47. char guardarReporte(); /* Genera un archivo TXT con el reporte de los productos */
  48.  
  49. /* Función de lectura de cadenas */
  50. int leecad(char *cad, int n);
  51.  
  52. /* Titular del programa */
  53. void tituloPrincipal();
  54.  
  55. char linea[MAX];
  56.  
  57. int main()
  58. {
  59. 	setlocale(LC_ALL, "spanish"); /* Permite imprimir caracteres con tilde */
  60. 	menuPrincipal();
  61.  
  62. 	return 0;
  63. }
  64.  
  65. void menuPrincipal()
  66. {
  67. 	char repite = 1;
  68. 	int opcion = -1;
  69. 	/* Cuando el usuario ingresa texto en lugar de ingresar una opción. El programa no modifica
  70. 	el valor de opcion. En ese caso, no se debe de ingresar a ninguno de los case, por eso se está
  71. 	inicializando la variable opcion con un valor que no permita ejecutar ningún case. Simplemente,
  72. 	volver a interar y pedir nuevamente la opción. */
  73.  
  74. 	do {
  75.  
  76. 		system( "COLOR 2" );//con esto sólo cambiamos el color de nuestra fuente
  77. 		system("cls");
  78.  
  79. 		tituloPrincipal();
  80.  
  81. 		printf("\n\t\t\t\t\t\tMENÚ PRINCIPAL\n");
  82. 		printf("\n\t\t[1] Insertar nuevo producto\n");
  83. 		printf("\t\t[2] Eliminar un producto\n");
  84. 		printf("\t\t[3] Modificar un producto\n");
  85. 		printf("\t\t[4] Lista ligada de productos con menor stock\n");
  86. 		printf("\t\t[5] Muestra: \n");
  87. 		printf("\t\t[6] Mostrar listado de productos (generar reporte)\n");
  88. 		printf("\t\t[7] Salir\n");
  89. 		printf("\n\t\tQué deseas hacer?: [ ]\b\b");
  90.  
  91. 		/* Lectura segura de un entero */
  92. 		leecad(linea, MAX);
  93. 		sscanf(linea, "%d", &opcion);
  94.  
  95. 		switch (opcion) {
  96.  
  97. 			case 1:
  98. 				menuInsertar();
  99. 				break;
  100.  
  101. 			case 2:
  102. 				menuEliminar();
  103. 				break;
  104.  
  105. 			case 3:
  106. 				menuModificar();
  107. 				break;
  108.  
  109. 			case 4:
  110. 				menuStockMinimo();
  111. 				break;
  112.  
  113. 			case 5:
  114. 				menuMuestras();
  115. 				break;
  116.  
  117. 			case 6:
  118. 				menuMostrar();
  119. 				break;
  120.  
  121. 			case 7:
  122. 				repite = 0;
  123. 				break;
  124. 		}
  125.  
  126. 	} while (repite);
  127. }
  128.  
  129. void menuMuestras()
  130. {
  131. 	char repite = 1;
  132. 	int opcion = -1;
  133.  
  134. 	do {
  135. 		system("cls");
  136.  
  137. 		tituloPrincipal();
  138.  
  139. 		printf("\n\t\t\t\t\t\tMENÚ QUE MUESTRA: \n");
  140. 		printf("\n\t\t[1] Info de un producto (por clave)\n");
  141. 		printf("\t\t[2] Laboratorio que elabora/distribuye un producto (con descripción)\n");
  142. 		printf("\t\t[3] Utilidad total del inventario\n");
  143. 		printf("\t\t[4] Volver al Menú Principal\n");
  144. 		printf("\n\t\tQué deseas hacer?: [ ]\b\b");
  145.  
  146. 		/* Lectura segura de un entero */
  147. 		leecad(linea, MAX);
  148. 		sscanf(linea, "%d", &opcion);
  149.  
  150. 		switch (opcion) {
  151.  
  152. 			case 1:
  153. 				menuBuscarClave();
  154. 				break;
  155.  
  156. 			case 2:
  157. 				menuBuscarDescripcion();
  158. 				break;
  159.  
  160. 			case 3:
  161. 				menuUtilidad();
  162. 				break;
  163.  
  164. 			case 4:
  165. 				repite = 0;
  166. 				break;
  167. 		}
  168.  
  169. 	} while (repite);
  170. }
  171.  
  172. void menuInsertar()
  173. {
  174. 	Producto producto;
  175. 	int codigoProducto = 0;
  176. 	char repite = 1;
  177. 	char respuesta[MAX];
  178.  
  179. 	do {
  180. 		system("cls");
  181. 		tituloPrincipal();
  182. 		printf("\n\n\t\t\t    SISTEMA DE INGRESO DE PRODUCTOS \n");
  183.  
  184. 		/* Se pide el código del producto a insertar */
  185. 		printf("\n\tCódigo de producto: ");
  186. 		leecad(linea, MAX);
  187. 		sscanf(linea, "%d", &codigoProducto);
  188.  
  189. 		/* Se verifica que el producto no haya sido almacenado anteriormente */
  190. 		if (!existeProducto(codigoProducto, &producto)) {
  191.  
  192. 			producto.codigo = codigoProducto;
  193.  
  194. 			/* Se piden los demás datos del producto a insertar */
  195. 			printf("\tNombre del producto: ");
  196. 			leecad(producto.nombre, MAX);
  197.  
  198. 			printf("\tDescripción del producto: ");
  199. 			leecad(producto.descripcion, MAX);
  200.  
  201. 			printf("\tLaboratorio: ");
  202. 			leecad(producto.laboratorio, MAX);
  203.  
  204. 			printf("\tCosto de compra ($): ");
  205. 			leecad(linea, MAX);
  206. 			sscanf(linea, "%f", &producto.costo);
  207.  
  208. 			printf("\tCosto de venta ($): ");
  209. 			leecad(linea, MAX);
  210. 			sscanf(linea, "%f", &producto.precio);
  211.  
  212. 			printf("\tCantidad: ");
  213. 			leecad(linea, MAX);
  214. 			sscanf(linea, "%d", &producto.cantidad);
  215.  
  216. 			/* Se inserta el producto en el archivo */
  217. 			if (insertarProducto(producto)) {
  218. 				printf("\n\tEl producto fue insertado correctamente\n");
  219.  
  220. 			} else {
  221. 				printf("\n\tOcurrió un error al intentar insertar el producto\n");
  222. 				printf("\tInténtelo mas tarde\n");
  223. 			}
  224. 		} else {
  225. 			/* El producto ya existe, no puede ser insertado. */
  226. 			printf("\n\tEl producto de código %d ya existe.\n", codigoProducto);
  227. 			printf("\tNo puede ingresar dos productos distintos con el mismo código.\n");
  228. 		}
  229.  
  230. 		printf("\n\tDesea seguir ingresando productos? [S/N]: ");
  231. 		leecad(respuesta, MAX);
  232.  
  233. 		if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  234. 			repite = 0;
  235. 		}
  236.  
  237. 	} while (repite);
  238. }
  239.  
  240. void menuBuscarClave()
  241. {
  242. 	Producto producto;
  243. 	int codigoProducto;
  244. 	char repite = 1;
  245. 	char respuesta[MAX];
  246.  
  247. 	do {
  248. 		system("cls");
  249. 		tituloPrincipal();
  250. 		printf("\n\t\t\t==> BUSCAR PRODUCTO POR CÓDIGO <==\n");
  251.  
  252. 		/* Se pide el código del producto a buscar */
  253. 		printf("\n\tCódigo de producto: ");
  254. 		leecad(linea, MAX);
  255. 		sscanf(linea, "%d", &codigoProducto);
  256.  
  257. 		/* Se verifica que el producto a buscar, exista */
  258. 		if (existeProducto(codigoProducto, &producto)) {
  259.  
  260. 			/* Se muestran los datos del producto */
  261. 			printf("\n\tCódigo del producto: %d\n", producto.codigo);
  262. 			printf("\tNombre del producto: %s\n", producto.nombre);			
  263. 			printf("\tCosto del producto: %.1f $\n", producto.costo);
  264. 			printf("\tPrecio del producto: %.1f $\n", producto.precio);
  265. 			printf("\tCantidad: %d\n", producto.cantidad);
  266.  
  267. 		} else {
  268. 			/* El producto no existe */
  269. 			printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  270. 		}
  271.  
  272. 		printf("\n\tDesea seguir buscando algún producto? [S/N]: ");
  273. 		leecad(respuesta, MAX);
  274.  
  275. 		if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  276. 			repite = 0;
  277. 		}
  278.  
  279. 	} while (repite);
  280. }
  281.  
  282. void menuBuscarDescripcion()
  283. {
  284. 	Producto producto;
  285. 	char descripcionProducto;
  286. 	char repite = 1;
  287. 	char respuesta[MAX];
  288.  
  289. 	do {
  290. 		system("cls");
  291. 		tituloPrincipal();
  292. 		printf("\n\t\t\t BUSCAR PRODUCTO POR DESCRIPCIÓN \n");
  293.  
  294. 		/* Se pide la descripción del producto a buscar */
  295. 		printf("\tDescripción del producto: ");
  296. 		leecad(producto.descripcion, MAX);
  297.  
  298. 		/* Se verifica que el producto a buscar, exista */
  299. 		if (existeProducto2(descripcionProducto, &producto)) {
  300.  
  301. 			// Se muestran los datos del producto
  302. 			printf("\n\tLaboratorio que elabora/distribuye el producto: %s\n", producto.laboratorio);
  303.  
  304.  
  305. 		} else {
  306. 			// El producto no existe
  307. 			printf("\n\tEl producto de descripción %s no existe.\n", producto.descripcion);
  308. 		}
  309.  
  310. 		printf("\n\tDesea seguir buscando algún producto? [S/N]: ");
  311. 		leecad(respuesta, MAX);
  312.  
  313. 		if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  314. 			repite = 0;
  315. 		}
  316.  
  317. 	} while (repite);
  318. } 
  319.  
  320. void menuUtilidad()
  321. {
  322. 	Producto *productos;
  323. 	int numeroProductos;
  324. 	int i;
  325. 	float costoTotal;
  326. 	float precioTotal;
  327. 	float utilidadTotal;
  328. 	int cantidadTotal;
  329. 	char respuesta[MAX];
  330.  
  331. 	system("cls");
  332. 	tituloPrincipal();
  333. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  334.  
  335. 	if (numeroProductos == 0) {
  336. 		printf("\n\tEl archivo está vacío!!\n");
  337. 		system("pause>nul");
  338.  
  339. 	} else {
  340. 		printf("\n\n\t\t        PRODUCTOS INGRESADOS EN INVENTARIO    \n");
  341. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  342. 		printf("%8s\t%-12s%15s%15s%15s%15s%10s\n", "CÓDIGO", "NOMBRE", "DESCRIPCIÓN", "LABORATORIO", "COSTO C. $", "COSTO V. $", "UNIDADES");
  343. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  344.  
  345. 		/* Se recorre el vector dinámico de productos */
  346. 		costoTotal = 0;
  347. 		precioTotal = 0;
  348. 		cantidadTotal = 0;
  349. 		for (i = 0; i < numeroProductos; i++) {
  350. 			if (productos[i].codigo != VALOR_CENTINELA) {
  351. 				printf("%7d \t%-15s %-15s %-8s%15.1f%15.1f%8d\n", productos[i].codigo, productos[i].nombre, productos[i].descripcion, productos[i].laboratorio, productos[i].costo, productos[i].precio, productos[i].cantidad);
  352. 				costoTotal += productos[i].costo;
  353. 				precioTotal += productos[i].precio;
  354. 				cantidadTotal += productos[i].cantidad;
  355. 			}
  356. 		}
  357. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  358. 		printf("\t\t\t                         TOTAL: %15.1f%15.1f%8d\n", costoTotal, precioTotal, cantidadTotal);
  359.  
  360. 		utilidadTotal = (precioTotal - costoTotal)*cantidadTotal;
  361. 		printf("\n>>> Utilidad Total de Inventario: $ %.2f \n\n",utilidadTotal);
  362.  
  363. 		system("pause>nul");
  364. 	}
  365. }
  366.  
  367. void menuEliminar()
  368. {
  369. 	Producto producto;
  370. 	int codigoProducto;
  371. 	char repite = 1;
  372. 	char respuesta[MAX];
  373.  
  374. 	do {
  375. 		system("cls");
  376. 		tituloPrincipal();
  377. 		printf("\n\t\t\t    ELIMINAR UN PRODUCTO POR CÓDIGO    \n");
  378.  
  379. 		/* Se pide el código del producto a eliminar */
  380. 		printf("\n\tCódigo de producto: ");
  381. 		leecad(linea, MAX);
  382. 		sscanf(linea, "%d", &codigoProducto);
  383.  
  384. 		/* Se verifica que el producto a buscar, exista */
  385. 		if (existeProducto(codigoProducto, &producto)) {
  386.  
  387. 			/* Se muestran los datos del producto */
  388. 			printf("\n\tCódigo del producto: %d\n", producto.codigo);
  389. 			printf("\tNombre del producto: %s\n", producto.nombre);			
  390. 			printf("\tCosto del producto: %.1f $\n", producto.costo);
  391. 			printf("\tPrecio del producto: %.1f $\n", producto.precio);
  392. 			printf("\tCantidad: %d\n", producto.cantidad);
  393.  
  394. 			printf("\n\tSeguro que desea eliminar el producto? [S/N]: ");
  395. 			leecad(respuesta, MAX);
  396. 			if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  397. 				if (eliminarProducto(codigoProducto)) {
  398. 					printf("\n\tProducto eliminado satisfactoriamente.\n");
  399. 				} else {
  400. 					printf("\n\tEl producto no pudo ser eliminado\n");
  401. 				}
  402. 			}
  403.  
  404. 		} else {
  405. 			/* El producto no existe */
  406. 			printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  407. 		}
  408.  
  409. 		printf("\n\tDesea eliminar otro producto? [S/N]: ");
  410. 		leecad(respuesta, MAX);
  411.  
  412. 		if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  413. 			repite = 0;
  414. 		}
  415.  
  416. 	} while (repite);
  417. }
  418.  
  419. void menuMostrar()
  420. {
  421. 	Producto *productos;
  422. 	int numeroProductos;
  423. 	int i;
  424. 	float costoTotal;
  425. 	float precioTotal;
  426. 	int cantidadTotal;
  427. 	char respuesta[MAX];
  428.  
  429. 	system("cls");
  430. 	tituloPrincipal();
  431. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  432.  
  433. 	if (numeroProductos == 0) {
  434. 		printf("\n\tEl archivo está vacío!!\n");
  435. 		system("pause>nul");
  436.  
  437. 	} else {
  438. 		printf("\n\n\t\t        PRODUCTOS INGRESADOS EN INVENTARIO    \n");
  439. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  440. 		printf("%8s\t%-12s%15s%15s%15s%15s%10s\n", "CÓDIGO", "NOMBRE", "DESCRIPCIÓN", "LABORATORIO", "COSTO C. $", "COSTO V. $", "UNIDADES");
  441. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  442.  
  443. 		/* Se recorre el vector dinámico de productos */
  444. 		costoTotal = 0;
  445. 		precioTotal = 0;
  446. 		cantidadTotal = 0;
  447. 		for (i = 0; i < numeroProductos; i++) {
  448. 			if (productos[i].codigo != VALOR_CENTINELA) {
  449. 				printf("%7d \t%-15s %-15s %-8s%15.1f%15.1f%8d\n", productos[i].codigo, productos[i].nombre, productos[i].descripcion, productos[i].laboratorio, productos[i].costo, productos[i].precio, productos[i].cantidad);
  450. 				costoTotal += productos[i].costo;
  451. 				precioTotal += productos[i].precio;
  452. 				cantidadTotal += productos[i].cantidad;
  453. 			}
  454. 		}
  455. 		printf(" -------------------------------------------------------------------------------------------------------------\n");
  456. 		printf("\t\t\t                         TOTAL: %15.1f%15.1f%8d\n", costoTotal, precioTotal, cantidadTotal);
  457.  
  458. 		printf("\n\tDesea guardar el reporte en un archivo de texto? [S/N]: ");
  459. 		leecad(respuesta, MAX);
  460.  
  461. 		if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  462. 			if (guardarReporte()) {
  463. 				printf("\n\tEl reporte fue guardado con éxito\n");
  464. 			} else {
  465. 				printf("\n\tOcurrió un error al guardar el reporte\n");
  466. 			}
  467.  
  468. 			system("pause>nul");
  469. 		}
  470. 	}
  471. }
  472.  
  473. void menuModificar()
  474. {
  475. 	Producto producto;
  476. 	int codigoProducto;
  477. 	char repite = 1;
  478. 	char respuesta[MAX];
  479.  
  480. 	do {
  481. 		system("cls");
  482. 		tituloPrincipal();
  483. 		printf("\n\t\t\t\t\t    MODIFICAR UN PRODUCTO   \n");
  484.  
  485. 		/* Se pide el código del producto a modificar */
  486. 		printf("\n\tCódigo de producto: ");
  487. 		leecad(linea, MAX);
  488. 		sscanf(linea, "%d", &codigoProducto);
  489.  
  490. 		/* Se verifica que el producto a buscar exista */
  491. 		if (existeProducto(codigoProducto, &producto)) {
  492.  
  493. 			/* Se muestran los datos del producto */
  494. 			printf("\n\tNombre del producto: %s\n", producto.nombre);
  495. 			printf("\tDescripción: %s\n", producto.descripcion);
  496. 			printf("\tLaboratorio: %s\n", producto.laboratorio);
  497. 			printf("\tCosto de compra del producto ($): %.1f\n", producto.costo);
  498. 			printf("\tCosto de venta del producto ($): %.1f\n", producto.precio);
  499. 			printf("\tCantidad: %d\n", producto.cantidad);
  500.  
  501. 			printf("\n\tElija los datos a modificar\n");
  502.  
  503. 			/* Modificación del nombre del producto */
  504. 			printf("\n\tNombre del producto actual: %s\n", producto.nombre);
  505.  
  506. 			/* Modificación del costo del producto */
  507. 			printf("\n\tCosto de compra del producto actual: %.1f\n", producto.costo);
  508. 			printf("\tDesea modificar el costo de compra del producto? [S/N]: ");
  509. 			leecad(respuesta, MAX);
  510. 			if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  511. 				printf("\tNuevo costo de compra del producto: ");
  512. 				leecad(linea, MAX);
  513. 				sscanf(linea, "%f", &producto.costo);
  514. 			}
  515.  
  516. 			/* Modificación del precio del producto */
  517. 			printf("\n\tCosto de venta del producto actual: %.1f\n", producto.precio);
  518. 			printf("\tDesea modificar el costo de venta del producto? [S/N]: ");
  519. 			leecad(respuesta, MAX);
  520. 			if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  521. 				printf("\tNuevo costo de venta del producto: ");
  522. 				leecad(linea, MAX);
  523. 				sscanf(linea, "%f", &producto.precio);
  524. 			}
  525.  
  526. 			/* Modificación de la cantidad del producto */
  527. 			printf("\n\tCantidad del producto actual: %d\n", producto.cantidad);
  528. 			printf("\tDesea modificar las existencias del producto? [S/N]: ");
  529. 			leecad(respuesta, MAX);
  530. 			if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  531. 				printf("\tNueva cantidad del producto: ");
  532. 				leecad(linea, MAX);
  533. 				sscanf(linea, "%d", &producto.cantidad);
  534. 			}
  535.  
  536. 			printf("\n\tEstá seguro que desea modificar los datos del producto? [S/N]: ");
  537. 			leecad(respuesta, MAX);
  538.  
  539. 			if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  540. 				/* Se modifica el producto en el archivo */
  541. 				if (modificarProducto(producto)) {
  542. 					printf("\n\tEl producto fue modificado correctamente\n");
  543.  
  544. 				} else {
  545. 					printf("\n\tOcurrió un error al intentar modificar el producto\n");
  546. 					printf("\tInténtelo mas tarde\n");
  547. 				}
  548. 			}
  549. 		} else {
  550. 			/* El producto no existe */
  551. 			printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  552. 		}
  553.  
  554. 		printf("\n\tDesea modificar algún otro producto? [S/N]: ");
  555. 		leecad(respuesta, MAX);
  556.  
  557. 		if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  558. 			repite = 0;
  559. 		}
  560.  
  561. 	} while (repite);
  562. }
  563.  
  564. void menuEliminarFisica()
  565. {
  566. 	char respuesta[MAX];
  567.  
  568.  
  569. 	system("cls");
  570. 	tituloPrincipal();
  571. 	printf("\n\t\t==> ELIMINAR FÍSICAMENTE REGISTROS DEL ARCHIVO <==\n");
  572.  
  573. 	/* Se pide el código del producto a eliminar */
  574. 	printf("\n\tSeguro que desea proceder con la eliminación física? [S/N]: ");
  575. 	leecad(respuesta, MAX);
  576.  
  577. 	if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  578. 		if (eliminacionFisica()) {
  579. 			printf("\n\tLa eliminación física se realizó con éxito.\n");
  580. 		} else {
  581. 			printf("\n\tOcurrió algún error en la eliminación física.\n");
  582. 		}
  583.  
  584. 		system("pause>nul");
  585. 	}
  586. }
  587.  
  588. void menuStockMinimo()
  589. {
  590. 	Producto *productos;
  591. 	int numeroProductos;
  592. 	int i;
  593. 	int aux=0;
  594. 	int minimo=3;
  595. 	char respuesta[MAX];
  596.  
  597. 	system("cls");
  598. 	tituloPrincipal();
  599. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  600.  
  601. 	if (numeroProductos == 0) {
  602. 		printf("\n\tEl archivo está vacío!!\n");
  603. 		system("pause>nul");
  604.     }
  605.  
  606. 	for (i = 0; i < numeroProductos; i++){
  607. 		if (productos[i].cantidad <= minimo) {
  608. 	 	    printf("\nEl producto:\n\n");
  609. 	 	    printf("%8s\t%-12s%15s%15s%15s%15s\n", "CÓDIGO", "NOMBRE", "DESCRIPCIÓN", "LABORATORIO", "COSTO C. $", "COSTO V. $");
  610. 	 	    printf("%7d \t%-15s %-15s %-8s%15.1f%15.1f\n", productos[i].codigo, productos[i].nombre, productos[i].descripcion, productos[i].laboratorio, productos[i].costo, productos[i].precio);
  611. 	 	    printf("\nSe encuentra en niveles por debajo del mínimo permitido de existencias, deberías considerar adquirir más unidades\n");
  612. 		}
  613. 		aux++;
  614.  
  615. 		if(aux>4){
  616. 		    printf("\n\tYa he revisado tus existencias y no hay nada por debajo del mínimo\n");
  617. 	    }else{
  618. 		    printf("\n\t \n");
  619. 	    }
  620. 	}
  621.  
  622.  
  623. 	system("pause>nul");
  624.  
  625. }
  626.  
  627. Producto *obtenerProductos(int *n)
  628. {
  629. 	FILE *archivo;
  630. 	Producto producto;
  631. 	Producto *productos; /* Vector dinámico de productos */
  632. 	int i;
  633.  
  634. 	/* Abre el archivo en modo lectura */
  635. 	archivo = fopen("productos.dat", "rb");
  636.  
  637. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  638. 		*n = 0; /* No se pudo abrir. Se considera n  */
  639. 		productos = NULL;
  640.  
  641. 	} else {
  642.  
  643. 		fseek(archivo, 0, SEEK_END); /* Posiciona el cursor al final del archivo */
  644. 		*n = ftell(archivo) / sizeof(Producto); /* # de productos almacenados en el archivo. (# de registros) */
  645. 		productos = (Producto *)malloc((*n) * sizeof(Producto)); /* Se reserva memoria para todos los productos almacenados en el archivo */
  646.  
  647. 		/* Se recorre el archivo secuencialmente */
  648. 		fseek(archivo, 0, SEEK_SET); /* Posiciona el cursor al principio del archivo */
  649. 		fread(&producto, sizeof(producto), 1, archivo);
  650. 		i = 0;
  651. 		while (!feof(archivo)) {
  652. 			productos[i++] = producto;
  653. 			fread(&producto, sizeof(producto), 1, archivo);
  654. 		}
  655.  
  656. 		/* Cierra el archivo */
  657. 		fclose(archivo);
  658. 	}
  659.  
  660. 	return productos;
  661. }
  662.  
  663. char existeProducto(int codigoProducto, Producto *producto)
  664. {
  665. 	FILE *archivo;
  666. 	char existe;
  667.  
  668. 	/* Abre el archivo en modo lectura */
  669. 	archivo = fopen("productos.dat", "rb");
  670.  
  671. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  672. 		existe = 0;
  673.  
  674. 	} else {
  675. 		existe = 0;
  676.  
  677. 		/* Se busca el producto cuyo código coincida con codigoProducto */
  678. 		fread(&(*producto), sizeof(*producto), 1, archivo);
  679. 		while (!feof(archivo)) {
  680. 			if ((*producto).codigo == codigoProducto) {
  681. 				existe = 1;
  682. 				break;
  683. 			}
  684. 			fread(&(*producto), sizeof(*producto), 1, archivo);
  685. 		}
  686.  
  687. 		/* Cierra el archivo */
  688. 		fclose(archivo);
  689. 	}
  690.  
  691. 	return existe;
  692. }
  693.  
  694. char existeProducto2(char descripcionProducto, Producto *producto)//
  695. {
  696. 	FILE *archivo;
  697. 	char existe;
  698.  
  699. 	/* Abre el archivo en modo lectura */
  700. 	archivo = fopen("productos.dat", "rb");
  701.  
  702. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  703. 		existe = 0;
  704.  
  705. 	} else {
  706. 		existe = 0;
  707.  
  708. 		/* Se busca el producto cuyo código coincida con codigoProducto */
  709. 		fread(&(*producto), sizeof(*producto), 1, archivo);
  710. 		while (!feof(archivo)) {
  711. 			if ((*producto).descripcion == descripcionProducto) {
  712. 				existe = 1;
  713. 				break;
  714. 			}
  715. 			fread(&(*producto), sizeof(*producto), 1, archivo);
  716. 		}
  717.  
  718. 		/* Cierra el archivo */
  719. 		fclose(archivo);
  720. 	}
  721.  
  722. 	return existe;
  723. }
  724.  
  725. char insertarProducto(Producto producto)
  726. {
  727. 	FILE *archivo;
  728. 	char insercion;
  729.  
  730. 	/* Abre el archivo para agregar datos al final */
  731. 	archivo = fopen("productos.dat", "ab");	/* Añade datos al final. Si el archivo no existe, es creado */
  732.  
  733. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  734. 		insercion = 0;
  735.  
  736. 	} else {
  737. 		fwrite(&producto, sizeof(producto), 1, archivo);
  738. 		insercion = 1;
  739.  
  740. 		/* Cierra el archivo */
  741. 		fclose(archivo);
  742. 	}
  743.  
  744. 	return insercion;
  745. }
  746.  
  747. /* ELiminación lógica de un registro */
  748. char eliminarProducto(int codigoProducto)
  749. {
  750. 	FILE *archivo;
  751. 	FILE *auxiliar;
  752. 	Producto producto;
  753. 	char elimina;
  754.  
  755. 	/* Abre el archivo para leer */
  756. 	archivo = fopen("productos.dat", "r+b");	/* Modo lectura/escritura. Si el archivo no existe, es creado */
  757.  
  758. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  759. 		elimina = 0;
  760.  
  761. 	} else {
  762. 		/* Se busca el registro que se quiere borrar. Cuando se encuentra, se sitúa en esa posición mediante la 
  763. 		función fseek y luego se modifica el campo clave de ese registro mediante algún valor centinela, eso se logra 
  764. 		con fwrite. Hasta allí se ha logrado una eliminación LÓGICA. Porque el registro sigue ocupando espacio en el archivo físico */
  765.  
  766. 		elimina = 0;
  767. 		fread(&producto, sizeof(producto), 1, archivo);
  768. 		while (!feof(archivo)) {
  769. 			if (producto.codigo == codigoProducto) {
  770. 				fseek(archivo, ftell(archivo) - sizeof(producto), SEEK_SET);
  771. 				producto.codigo = VALOR_CENTINELA;
  772. 				fwrite(&producto, sizeof(producto), 1, archivo);
  773. 				elimina = 1;
  774. 				break;
  775. 			}
  776. 			fread(&producto, sizeof(producto), 1, archivo);
  777. 		}
  778.  
  779. 		/* Cierra el archivo */
  780. 		fclose(archivo);
  781. 	}
  782.  
  783. 	return elimina;
  784. }
  785.  
  786. char eliminacionFisica()
  787. {
  788. 	FILE *archivo;
  789. 	FILE *temporal;
  790. 	Producto producto;
  791. 	char elimina = 0;
  792.  
  793. 	archivo = fopen("productos.dat", "rb");
  794. 	temporal = fopen("temporal.dat", "wb");
  795.  
  796. 	if (archivo == NULL || temporal == NULL) {
  797. 		elimina = 0;
  798. 	} else {
  799. 		/* Se copia en el archivo temporal los registros válidos */
  800. 		fread(&producto, sizeof(producto), 1, archivo);
  801. 		while (!feof(archivo)) {
  802. 			if (producto.codigo != VALOR_CENTINELA) {
  803. 				fwrite(&producto, sizeof(producto), 1, temporal);
  804. 			}
  805. 			fread(&producto, sizeof(producto), 1, archivo);
  806. 		}
  807. 		/* Se cierran los archivos antes de borrar y renombrar */
  808. 		fclose(archivo);
  809. 		fclose(temporal);
  810.  
  811. 		remove("productos.dat");
  812. 		rename("temporal.dat", "productos.dat");
  813.  
  814. 		elimina = 1;
  815. 	}
  816.  
  817. 	return elimina;
  818. }
  819.  
  820. char modificarProducto(Producto producto)
  821. {
  822. 	FILE *archivo;
  823. 	char modifica;
  824. 	Producto producto2;
  825.  
  826. 	/* Abre el archivo para lectura/escritura */
  827. 	archivo = fopen("productos.dat", "rb+");
  828.  
  829. 	if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  830. 		modifica = 0;
  831.  
  832. 	} else {
  833. 		modifica = 0;
  834. 		fread(&producto2, sizeof(producto2), 1, archivo);
  835. 		while (!feof(archivo)) {
  836. 			if (producto2.codigo == producto.codigo) {
  837. 				fseek(archivo, ftell(archivo) - sizeof(producto), SEEK_SET);
  838. 				fwrite(&producto, sizeof(producto), 1, archivo);
  839. 				modifica = 1;
  840. 				break;
  841. 			}
  842. 			fread(&producto2, sizeof(producto2), 1, archivo);
  843. 		}
  844.  
  845. 		fclose(archivo);
  846. 	}
  847.  
  848. 	/* Cierra el archivo */
  849. 	return modifica;
  850. }
  851.  
  852. char guardarReporte()
  853. {
  854. 	FILE *archivo;
  855. 	char guardado;
  856. 	Producto *productos;
  857. 	int numeroProductos;
  858. 	int i;
  859. 	float costoTotal;
  860. 	float precioTotal;
  861. 	int cantidadTotal;
  862.  
  863. 	productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  864.  
  865. 	if (numeroProductos == 0) {
  866. 		guardado = 0;
  867.  
  868. 	} else {
  869. 		/* Abre el archivo en modo texto para escritura */
  870. 		archivo = fopen("reporte.txt", "w");
  871.  
  872. 		if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  873. 			guardado = 0;
  874.  
  875. 		} else {
  876. 			fprintf(archivo, "\n\t\t    ==> LISTADO DE PRODUCTOS REGISTRADOS <==\n");
  877. 			fprintf(archivo, " ------------------------------------------------------------------------------\n");
  878. 			fprintf(archivo, "%8s\t%-20s%15s%15s%10s\n", "CODIGO", "NOMBRE", "COSTO $", "PRECIO $", "CANTIDAD");
  879. 			fprintf(archivo, " ------------------------------------------------------------------------------\n");
  880.  
  881. 			/* Se recorre el vector dinámico de productos */
  882. 			costoTotal = 0;
  883. 			precioTotal = 0;
  884. 			cantidadTotal = 0;
  885. 			for (i = 0; i < numeroProductos; i++) {
  886. 				if (productos[i].codigo != VALOR_CENTINELA) {
  887. 					fprintf(archivo, "%7d \t%-20.20s%15.1f%15.1f%8d\n", productos[i].codigo, productos[i].nombre, productos[i].costo, productos[i].precio, productos[i].cantidad);
  888. 					costoTotal += productos[i].costo;
  889. 					precioTotal += productos[i].precio;
  890. 					cantidadTotal += productos[i].cantidad;
  891. 				}
  892. 			}
  893. 			fprintf(archivo, " ------------------------------------------------------------------------------\n");
  894. 			fprintf(archivo, "\t\t\t      TOTAL: %15.1f%15.1f%8d", costoTotal, precioTotal, cantidadTotal);
  895.  
  896. 			guardado = 1;
  897.  
  898. 			/* Cierra el archivo */
  899. 			fclose(archivo);
  900. 		}
  901. 	}
  902.  
  903. 	return guardado;
  904. }
  905.  
  906. int leecad(char *cad, int n)
  907. {
  908. 	int i, c;
  909.  
  910. 	/* Hay que verificar si el buffer está limpio o si hay un '\n'
  911. 	  dejado por scanf y, en ese caso, limpiarlo:
  912. 	*/
  913.  
  914. 	/* 1 COMPROBACIÓN DE DATOS INICIALES EN EL BUFFER */
  915.  
  916. 	/* Empezamos leyendo el primer caracter que haya en la entrada. Si es
  917. 	  EOF, significa que no hay nada por leer, así que cerramos la cadena,
  918. 	  dejándola "vacía" y salimos de la función retornando un valor de 0
  919. 	  o falso, para indicar que hubo un error */
  920. 	c = getchar();
  921. 	if (c == EOF) {
  922. 		cad[0] = '\0';
  923. 		return 0;
  924. 	}
  925.  
  926. 	/* Si el valor leído es '\n', significa que había un caracter de nueva línea
  927. 	dejado por un scanf o función similar. Simplemente inicializamos i a 0,
  928. 	para indicar que los siguientes caracteres que leamos iremos asignando a
  929. 	partir del primer caracter de la cadena. */
  930. 	if (c == '\n') {
  931. 		i = 0;
  932. 	} else {
  933. 	/* Si no había un '\n', significa que el caracter que leímos es el primer
  934. 	  caracter de la cadena introducida. En este caso, lo guardamos en la
  935. 	  posición 0 de cad, e inicializamos i a 1, porque en este caso, como ya
  936. 	  tenemos el primer caracter de la cadena, continuaremos agregando 
  937. 	  caracteres a partir del segundo.
  938.  
  939. 	*/
  940. 		cad[0] = c;
  941. 		i = 1;
  942. 	}
  943.  
  944. 	/* 2. LECTURA DE LA CADENA */
  945.  
  946. 	/* El for empieza con un ; porque estamos omitiendo la inicialización del contador,
  947. 	ya que fue inicializado en el punto anterior.
  948. 	Este código lee un caracter a la vez,lo agrega a cad, y se repite hasta que
  949. 	se encuentre un fin de línea, fin de archivo, o haya leído la cantidad máxima
  950. 	de caracteres que se le indicó. Luego, cierra la cadena agregando un '\0'
  951. 	al final. Todo esto es muy similar a la forma en que los compiladores suelen
  952. 	implementar la función fgets, sólo que en lugar de getchar usan getc o fgetc
  953. 	*/
  954. 	for (; i < n - 1 && (c = getchar()) != EOF && c != '\n'; i++) {
  955. 		cad[i] = c;
  956. 	}
  957. 	cad[i] = '\0';
  958.  
  959. 	/*3. LIMPIEZA DEL BUFFER */
  960.  
  961. 	/* Finalmente limpiamos el buffer si es necesario */
  962. 	if (c != '\n' && c != EOF) /* es un caracter */
  963. 		while ((c = getchar()) != '\n' && c != EOF);
  964.  
  965. 	/* La variable c contiene el último caracter leído. Recordemos que había 3 formas
  966. 	de salir del for: que hayamos encontrando un '\n', un EOF, o que hayamos llegado
  967. 	al máximo de caracteres que debemos leer. Si se da cualquiera de los dos
  968. 	primeros casos, significa que leímos todo lo que había en el buffer, por lo que
  969. 	no hay nada que limpiar. En el tercer caso, el usuario escribió más caracteres
  970. 	de los debidos, que aún están en el buffer, por lo que hay que quitarlos, para
  971. 	lo cual usamos el método que vimos poco más arriba
  972. 	*/
  973.  
  974. 	return 1;
  975. }
  976.  
  977. void tituloPrincipal()
  978. {
  979. 	int i;
  980. 	printf("\n                                                                           \n");//
  981. 	printf("\t\t\t                FARMACIAS DEL NORTE S.A de C.V\n");
  982. 	printf("\t\t\t                 Tú salud nuestro premio!\n");
  983.  
  984. 	i = 0;
  985. 	putchar('\n');
  986. 	for (; i < 110; i++) {
  987. 		putchar('*');
  988. 	}
  989. }
  990.  
8  Programación / Scripting / Graficar Tiro Parabólico en: 18 Noviembre 2020, 19:08 pm
Amigos tengo el siguiente código:

Código
  1. from math import pi, tan, cos, sin
  2. from math import radians
  3. import numpy as np
  4. from matplotlib.pylab import *
  5. import matplotlib.pyplot as plt
  6. from math import *
  7. from sympy import *
  8. from sympy.plotting import *
  9. from time import *
  10. from scipy import *
  11.  
  12. while True:
  13.     try:
  14.         vi = float(input("Introduzca la velocidad inicial en (m/s) : "))
  15.         break
  16.     except ValueError:
  17.         print("Cantidad Incorrecta")
  18. print("m/s =",vi)
  19.  
  20. while True:
  21.     try:
  22.         angulo = int(input("Introduzca el ángulo en grados: "))
  23.         break
  24.     except ValueError:
  25.         print("\nCantidad Incorrecta\n")
  26. print(angulo,"°")#no es necesario, lo uso para que vayamos viendo el resultado
  27.  
  28. while True:
  29.     try:
  30.         g = float(input("Introduzca el valor de gravedad en m/s^2: "))
  31.         break
  32.     except ValueError:
  33.         print("\nCantidad Incorrecta\n")
  34. print("\ng =",g)
  35.  
  36. grados = ((angulo*pi)/180)
  37. print ("\ngrados =",grados)
  38.  
  39. while True:
  40.     try:
  41.         xo = float(input("Posición horizontal inicial [x0]: "))
  42.         break
  43.     except ValueError:
  44.         print("\nCantidad Incorrecta\n")
  45.  
  46. while True:
  47.     try:
  48.         yo = float(input("Posición vertical inicial [y0]: "))
  49.         break
  50.     except ValueError:
  51.         print("\nCantidad Incorrecta\n")
  52.  
  53.  
  54. a = tan(grados)
  55. b = ((g)/((2*vi*2)*cos(grados)*2))
  56. print()
  57. ymax=(vi**2)*(np.sin(grados)*sin(grados))/(2*g)
  58. xmax=(vi**2)*(np.sin(2*grados))/(g)
  59. vho = vi*(cos(radians(angulo)))
  60. vver = vi*(sin(radians(angulo)))
  61. print("Un proyectil lanzado con una velocidad inicial de Vo=",vi,"m/s y un ángulo de &#945;=",angulo,"°,")
  62. print("iniciará su trayectoria con una velocidad horizontal de vxO: ",format(vho,".3f"),"m/s,")
  63. print("y una velocidad vertical de vyO: ",format(vver,".3f"),"m/s.")
  64. print()
  65. print("Los parámetros más relevantes de su trayectoria son:")
  66.  
  67. tmax=(vi*sin(grados))/(g)
  68. tv=2*(tmax)
  69. print()
  70. print(str("La altura máxima  alcanzada por el proyectil es: Ymax")+" = "+str(ymax)+" m")
  71. print()
  72. print(str("El alcance máximo horizontal  del proyectil es: Xmax")+" = "+str(xmax)+" m")
  73. print()
  74. print("La altura máxima (m) alcanzada por el proyectil es: Ymax =",format(ymax,".2f"))
  75. print()
  76. print("El alcance máximo horizontal(m) del proyectil es: Xmax =",format(xmax," .2f"))
  77. print()
  78. print("El tiempo máximo t1max (s) que alcanza el proyectil para el ángulo &#946; es: t1max =",format(tmax,".2f"))
  79. print()
  80. print("El tiempo de vuelo t1v(s) que alcanza el proyectil para el angulo &#946; es: t1v =",format(tv,".2f"))
  81. print("----------------------------------------------------------------------")
  82. print("----------------------------------------------------------------------")
  83.  
  84. # Definimos la ecuación de la trayectoria
  85. def f(x):
  86.     return(a*x-b*x**2)
  87. x=np.linspace(0,xmax,500)
  88.  
  89. # añadimos el subtitulo
  90. plt.suptitle("CINEMATICA",fontsize=20,color="red")
  91.  
  92. #añadimos las etiquetas de los ejes
  93. xlabel("xmax",fontsize=20,color="red")                                      
  94. ylabel("ymax",fontsize=20,color="blue")
  95. #añadimos texto
  96. plt.text(((np.argmax(f(x)))/2),np.max(f(x))+1,"vi=",fontsize=10)
  97. plt.text(((np.argmax(f(x)))/2)+11,np.max(f(x))+1,(str(vi)+"m/s"),fontsize=10)
  98.  
  99. # Añadimos la rejilla en la gráfica
  100. plt.grid(True)                                                              
  101. plt.grid(color = '0.5', linestyle = '--', linewidth = 1)
  102. # Añadimos los ejes 
  103. # plt.axis("tight")
  104.  
  105. # dibujamos y ponemos etiquetas a la gráfica
  106. plt.text(3,1,angulo,fontsize=10)
  107. plt.plot(x, f(x), "red", linewidth = 2, label = (str(angulo)+"º"))
  108.  


Que quisiera me arrojara algo así



Me pudieran orientar por favor  ;D
9  Programación / Programación C/C++ / Re: Amigos como podría pasar el siguiente código a funciones? ya me confundí un poco en: 21 Octubre 2020, 19:05 pm
Ohhhhh  :o

creo que ya vi por donde entonces establecer esos parámetros  ;D

Muchas gracias por la explicación, y si o voy a trabajar así  ::)
10  Programación / Programación C/C++ / Amigos como podría pasar el siguiente código a funciones? ya me confundí un poco en: 21 Octubre 2020, 17:59 pm
Código
  1. #include <stdio.h>
  2.  
  3. #include <stdlib.h>
  4.  
  5. int main() 
  6.  
  7. { 
  8.  
  9.      int mat[50][50];
  10.  
  11.      int n, i, j, esIdentidad = 1;
  12.  
  13.      printf("Tamanio: ");
  14.  
  15.      scanf("%d", &n);
  16.  
  17.      for(i = 0; i < n; i++)
  18.  
  19.           for(j = 0; j < n; j++)
  20.  
  21.           {
  22.  
  23.                printf( "Matriz[%d][%d]: ", i, j );
  24.  
  25.                scanf( "%d", &mat[i][j] );
  26.  
  27.                if( (mat[i][j] != 0 && i != j) ||
  28.  
  29.                (mat[i][j] != 1 && i == j))
  30.  
  31.                     esIdentidad = 0;
  32.  
  33.           }
  34.  
  35.      for(i = 0; i < n; i++)
  36.  
  37.      {
  38.  
  39.           for(j = 0; j < n; j++)
  40.  
  41.                printf("%d ", mat[i][j]);
  42.  
  43.           printf("\n");
  44.  
  45.      }
  46.  
  47.      if(esIdentidad)
  48.  
  49.           printf( "Es matriz identidad.\n");
  50.  
  51.      else
  52.  
  53.           printf( "No es matriz identidad.\n");
  54.  
  55.  
  56.  
  57.      system("pause");
  58.  
  59.      return 0;
  60.  
  61. }
Páginas: [1] 2
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines