Fecha y hora actual: Jueves 22 Ago 2019 14:23
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Programando desde 0: 22- Otra aplicación de conocimientos.

Responder al Tema Ir a página 123Siguiente

Índice del Foro > Programación en general > Programando desde 0: 22- Otra aplicación de conocimientos.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 11 Ago 2011 22:40

Título del mensaje: Programando desde 0: 22- Otra aplicación de conocimientos.

Responder citando

Les traigo un nuevo reto como extensión al anterior para reafirmar lo dado en la última lección más lo dado en todas las anteriores. Se que nadie lo asumirá, pero por lo menos lo tendrán disponible. Todo aquel interesado puede preguntarme lo que quiera, lo guiaré en el proceso.

BASE PRODUCTOS – Parte 2

Añadiremos dos funcionalidades más a nuestro programa: Captura de Errores y una Lista Variable de Elementos a almacenar. Para esto tendrán que modificar bastante su código, lo cual puede ser bastante complicado y les mostrará la realidad de trabajar con un código ya hecho. Si no utilizaron buenos comentarios estarán en problemas ya que tendrán que rememorar lo que hace su programa e incluso con ellos tendrán que acomodar su cabeza nuevamente a una lógica puntual. Cada programa es un mundo, tiene sus problemas y complicaciones, su estructura; y para cada uno deben adecuar su mente. Imaginen lo que es trabajar con el código de otra persona cuya cabeza funciona de una forma totalmente diferente a la nuestra, cuya lógica nos hace rompernos la cabeza en el intento por comprendela. Pues ese es el mundo de la programación, de la creación de software, y créanme, lo que yo les he mostrado en este curso no es absolutamente nada. En próximas entregas iremos sumergiéndonos más en un mundo donde la magia es posible, donde la imaginación es prácticamente el único límite, donde el ingenio es la mejor herramienta, donde la paciencia es la mejor virtud. Sin embargo nada será sencillo, necesitarán sentarse a pensar horas cómo lograr tal o cual cosa, analizar una y otra vez dónde cornos está el error que hace a nuestro programa tirarnos cualquier cosa en un caso concreto ¡¡¡¡PERO SI EN TODOS LOS DEMÁS CASOS FUNCIONA!!!

Muchas veces pensarán que no hay solución, que necesitan alguna otra herramienta, sin embargo este manual ha apuntado a que ustedes puedan lograr grandes soluciones con herramientas básicas planteandoles problemas que a priori parecen imposibles de realizar. PASCAL tiene muchas cosas más que nosotros ni hemos nombrado y que en ciertos aspectos solucionarían muchos problemas de forma casi automática. Lenguajes superiores lograrán con dos palabras resolver lo que a ustedes les ha llevado diez o más líneas de código y horas de rompedero de cabeza, pero así se aprende y así, con esos lenguajes superiores, lograrán resolver cosas que tal vez otras personas no podrían. Bien, vayamos a nuestra taréa.

Nuestro programa deberá tiranos el mensaje “ERROR: Dato inesperado, ingrese un dato válido” para cualquier caso en el que ingresemos algo inadecuado en cualquier entrada. Siempre que se muestre el mensaje de error el programa deberá quedar a la espera de un nuevo ingreso para el mismo dato. Detallaré aquí los posibles errores en las entradas y daré ejemplos de ejecuciones:

Nombre: El nombre de un producto debe estar formado únicamente por números y/o letras mayúsculas y/o minúsculas. Cualquier otro carácter se tomará como inválido.
ID: El ID debe ser un número entero positivo, o sea, un natural. Si el dato ingresado no se corresponde con un número entero positivo o directamente no es un número lo consideraremos como error. Para el ID también deberemos corroborar que no se repita en todos los ingresos anteriores, ya que eso también sería un error.
Stock: Debe ser un número entero positivo. Tiene las mismas restricciones que el ID con la excepción de que Stock sí puede repetirse.
Precio: Este dato debe ser un número real positivo, en caso de ser negativo o no ser un número lo consideraremos como error. Este dato les traerá problemas de captura ya que leer la entrada como carácter y luego pasarla a real no es tan sencillo como pasarla a entero.
Categoría: Para este dato solo debemos corroborar que lo ingresado se corresponda con una de las opciones mostradas en pantalla, de lo contrario será un error. Esto se aplicará a todas las pantallas de nuestro programa en las que el usuario deba elegir una de varias opciones.

Para controlar el nombre ingresado deben implementar una función como la siguiente:

Código:
FUNCTION NombreCorrecto(nombre: CadenaChar): Boolean;


donde CadenaChar será un tipo global declarado de la siguiente manera:

Código:
CONST
   MaxLargoNombre: 20;

TYPE
   CadenaChar= RECORD
      nombre: Array[1..MaxLargoNombre] of Char;
      tope: 0..MaxLargoNombre;
   END;

La función NombreCorrecto devolverá TRUE si la cadena ingresada cumple las condiciones de más arriba, FALSE en caso contrario.

Para corroborar que la entrada corresponde a un entero positivo deben utilizar la siguiente función:

Código:
FUNCTION EsEnteroPositivo(numero: CadenaChar): Boolean


la cual devolverá TRUE si la entrada es un entero positivo o 0. Esto lo usarán para ID y para Stock, y tal vez para algún otro caso más donde ustedes crean que sea pertinente. No admitimos el signo de + en la entrada.

Del mismo modo comprobaremos si la entrada se corresponde a un real positivo:

Código:
FUNCITION EsRealPositivo(numero: CadenaChar): Boolean;


la cual obviamente devolverá TRUE si la entrada es un real positivo o FALSE en caso contrario. Recuerden que tomamos como real positivo que contenga números y/o una sola coma. No admitimos el signo de + en la entrada. De este modo, entradas correctas serían las siguientes:

• 1 Recordar que los números enteros son reales.
• 10
• 10,0
• ,12 equivale a 0,12 por lo cual es correcto.
• 1325,123

Entradas incorrectas serían:

• +1
• +1,23
• -1,23
• -0
• +0
• 12,12,3
• ,0,1
• 12,-1

Para obtener el valor entero de una entrada correcta deben implementar la función siguiente:

Código:
FUNCTION StringToInt(numero: CadenaChar): Integer;


la cual devolverá dicho valor. Esta función recibe una cadena de caracteres correcta, por lo cual la verificación de error debe hacerse antes de su llamada.
Del mismo modo implementarán una función para obtener el valor real de una cadena de caracteres correctos:

Código:
FUNCTION RealToInt(numero: CadenaChar): Real;


Esta función, como dije antes, les traerá problemas porque no es lo mismo pasar una cadena de caracteres a un valor entero que a un valor real. Les explicaré la lógica que se me ocurrió a mí para su implementación:

Un número real está constituido de dos partes, la que está antes de la coma y la que está después, o sea, la parte entera y la parte real. Por ejemplo:

• 1 : Parte entera 1, parte real 0.
• 1,000: Parte entera 1, parte real 0.
• 01,0: Parte entera 1, parte real 0.
• 12,52: Parte entera 12, parte real 52.

El truco está entonces en obtener estas dos partes por separado como números enteros, de este modo si tenemos el 12,52 tendremos por un lado el 12 y por otro lado el 52, ambas partes como enteros, lo cual es fácil llevar a valor integer con la función StringToInt. Una vez tenemos el entero 12 por un lado y el entero 52 por otro debemos establecer el 52 como el real 0,52 y sumárselo al 12 con lo cual obtenemos 12,52.

12 + 0,52= 12,52.

Para obtener el 0,52 a partir de 52 basta con dividirlo entre 100. De este modo, si nuestra parte real tiene un solo dígito debemos dividirla entre 10, si tiene dos dígitos debemos dividirla entre 100, si tiene tres entre 1000 y así sucesivamente. Por ejemplo:

• 123,146= 123 + 146/1000
• 1,2365= 1 + 2365/10000
• 01,0= 1 + 0/10

Espero que con esto puedan implementar correctamente la función RealToInt.

Para comprobar que la opción de la categoría seleccionada es correcta, o para comprobar que la opción de un menú se corresponde con una de las disponibles deben implementar una función como la siguiente:

Código:
FUNCTION OpcionCorrecta(inicioRango, finRango: char): Boolean;


la cual recibirá en sus parámetros el inicio del rango de opciones y el final del mismo, por ejemplo, viendo un menú como los que tiene nuestro programa:

Código:
Modificar Productos:

1) Todos
2) Según ID
3) Según Nombre
4) Comestibles
5) Frutas y verduras
6) Higiene del hogar
7) Higiene personal
9) Volver al Menú Principal

Opción >>


inicioRango sería '1' y finRango sería '9'. Ahora bien, si son obseravdores deberían preguntarse qué pasa si el usuario ingresa el valor '8'. Pues sería una buena pregunta. Para estos casos debemos modificar nuestro menú de modo que todas las opciones sean consecutivas:

Código:
Modificar Productos:
1) Todos
2) Según ID
3) Según Nombre
4) Comestibles
5) Frutas y verduras
6) Higiene del hogar
7) Higiene personal
8) Volver al Menú Principal

Opción >>

Estas modificaciones deberán hacerlas con todos los menús que haga falta. Asumiremos siempre que inicioRango<finRango.

IMPORTANTE: Para la opción Modificar Productos, en la versión anterior se utilizaban estas funciones:

Código:
FUNCTION BuscarPorID(listaProductos: Productos; ID: integer): integer;
FUNCTION BuscarPorNombre(listaProductos: Productos; nombre: string): integer;
FUNCTION BuscarPorCategoria(listaProductos: Productos; categoria: categorias): integer;


Ahora modificaremos las dos últimas para facilitarles a ustedes el trabajo:

Código:
FUNCTION BuscarPorNombre(listaProductos: Productos; nombre: string; idice: integer): integer;
FUNCTION BuscarPorCategoria(listaProductos: Productos; categoria: categorias; indice: integer): integer;


De este modo, el parámetro indice indicará desde qué posición del arreglo hay que comenzar a buscar. Esto les resuelve un enorme problema ya que aunque lo hayan hecho en la versión anterior, adaptarlo a un arreglo con tope es tan complicado que no vale la pena hacerlo aquí porque el enfoque es otro.

---------------------------------------------------------------------

Finalmente queda por ver el hecho de que la lista de elementos sea variable. Para esto implementaremos un arreglo con tope de la siguiente manera:

Código:
Const
   N= 5;

Type
   Categorias= (comestibles, frutas_verduras, higiene_h, higiene_p);
   TNaturales= 1..MAXINT;

   Elemento= Record
      Nombre: String;
      Stock: TNaturales;
      Precio: Real;
      Categoria: Categorias;
      ID: TNaturales;
   End;

   Productos= Record
      Array[1..N] of Elemento;
      tope: 0..N;
   End;


Como ven, esta definición no cambia a la anterior en casi nada, simplemente implementa el tipo Productos como un arreglo con tope. De este modo nuestro Menú Principal será así:

Código:
MENÚ PRINCIPAL:
1) Ingresar nuevo producto.
2) Ver lista de productos.
3) Modificar productos.
4) Vender.
5) Buscar.
6) Cantidad de productos ingresados.
7) Eliminar producto.
8) Salir.

Opción:

donde cambia la primera opción, ya que ahora no ingresaremos un número de productos preestablecido, sino que podemos ingresar uno o más; y añadimos dos opciones nuevas. Veamos entonces la opción 1 de nuestro menú:

Código:
|-----------Producto 1-----------|

ID >> 1
Nombre >> Azúcar
Stock >> 10
Precio >> 50,5
Categorías: (1) Comestibles
            (2) Frutas y verduras
            (3) Higiene del hogar
            (4) Higiene personal

Ingrese la opción deseada >> 1

Ingresar otro producto (1= SI/2= NO): j
ERROR: Dato inesperado, ingrese un dato válido.
Ingresar otro producto (1= SI/2= NO): 1

|-----------Producto 2-----------|

ID >> 2
Nombre >> Harina
Stock >> 10
Precio >> 42,5
Categorías: (1) Comestibles
            (2) Frutas y verduras
            (3) Higiene del hogar
            (4) Higiene personal

Ingrese la opción deseada >> 0
ERROR: Dato inesperado, ingrese un dato válido.
Ingrese la opción deseada >> 1
Ingresar otro producto (1= SI/2= NO): 2

Con eso volveríamos al Menú Principal. Si el usuario está en el menú principal y selecciona la opción 1, entonces volveremos al ingreso de productos tal como se vio arriba. Imaginen que ya se han ingresado 5 productos, entonces veríamos:

Código:
|-----------Producto 6-----------|

ID >> 6
Nombre >> AzúcarImpalpable
Stock >> 10
Precio >> 55,5
Categorías: (1) Comestibles
            (2) Frutas y verduras
            (3) Higiene del hogar
            (4) Higiene personal

Ingrese la opción deseada >> 1
Ingresar otro producto (1= SI/2= NO): 2

Siempre debemos saber cuantos productos tenemos en nuestra lista.

Veamos ahora la opción 6: Cantidad de productos ingresados:

Simplemente se nos mostrará en pantalla la cantidad de productos en nuestra lista. Por ejemplo:

Código:
Total de productos: 6
Presione ENTER para volver al Menú Principal...


Lo último por ver es la opción Eliminar producto: Se nos mostrará el siguiente menú:

Código:
ELIMINAR PRODUCTO:
1) Eliminar según ID
2) Eliminar Comestibles
3) Eliminar Frutas y Verduras
4) Eliminar Higiene del Hogar
5) Eliminar Higiene Personal
6) Volver al Menú Principal

Opción:

Podemos eliminar un elemento determinado dando su ID, o podemos eliminar toda una categoría completa para agilizar las cosas. Veamos dos ejemplos:

Supongamos que seleccionamos la opción 1, luego se nos pedirá el ID. Supondremos que el usuario ingresa un ID que no existe, lo cual es un error, se pedirá de nuevo el dato, tras lo cual el usuario ingresará un ID correcto.

Como podrán ver, para no eliminar nada y volver al menú principal debe ingresarse la letra M, cualquier otra cosa será un error.

Código:
Ingrese el ID del producto a eliminar o M para volver al menú principal: 12
ERROR: Dato inesperado, ingrese un dato válido.
Ingrese el ID del producto a eliminar o M para volver al Menú Principal: 1
ID: 1
Nombre: Azúcar
Stock: 10
Precio: 50,5
Categoría: Comestibles

Seguro que desea eliminar este producto (S/N): S
Producto eliminado, presione ENTER para volver al Menú Principal...


Veamos ahora un ejemplo en el que se selecciona la categoría comestibles para eliminar los productos:

Código:
¿Seguro que desea eliminar la categoría comestibles? (S/N): S

Eliminados:

Azucar ID: 1
Harina ID: 2
Fideos ID: 5

Presione ENTER para volver al Menú Principal...

Como ven, se mostrará un listado de todos los elementos eliminados. Estarán mostrados en el orden que fueron ingresados. Para cualquiera de estas opciones deberán implementar el siguiente procedimiento:

Código:
PROCEDURE EliminarProducto(VAR Lista: Productos; indice: integer);


donde lista será nuestro listado de elementos e indice será el lugar de la lista donde está el elemento a eliminar.
Cada vez que se elimina un elemento debemos correr todos los siguientes a ese un lugar a la izquierda y reducir el tope un número. Veamos una ilustración:



Allí vemos una lista de elementos donde el arreglo tiene 7 celdas, 5 de las cuales contienen productos, las otras dos no, por lo tanto nuestro tope es 5. En este ejemplo eliminaremos el producto número 3, con lo cual nuestro arreglo quedaría así.



El producto número 3 fue eliminado con lo cual ahora el producto 4 y 5 se corren un lugar hacia la izquierda y el tope se reduce en 1, o sea, Producto 4 estaba en la celda 4 pero ahora está en la celda 3, Producto 5 estaba en la celda 5 pero ahora está en la 4, y donde estaba Producto 5 no hay nada que nos interese, por lo tanto corremos nuestro tope hacia la última celda que contiene información.

Nuestro procedimiento debe hacer justamente esta tarea cada vez que se elimina un elemento de nuestra lista.
Si por ejemplo se eliminaran todos los Productos menos el Producto 5 entonces quedaría así, donde TOPE= 1:



Si se eliminara todo, nuestro TOPE sería 0 y nuestro arreglo estaría “vacío”, y lo pongo entre comillas porque en realidad las celdas siguen conteniendo información solo que a nosotros no nos importa en absoluto y la tratamos como nula o vacía, de eso se trata la implementación de Arreglos con Tope.

Si se intenta eliminar productos cuando ya no existe nada para eliminar el programa debe darnos el mensaje “La lista de elementos está vacía”. Hasta aquí llegamos por ahora con nuestro proyecto. La siguiente parte de este tutorial trata el último tema y, a mi gusto, el más interesante, con lo cual modificaremos por última vez nuestro programa de modo que quede “perfecto” y utilice solo los recursos que necesita para funcionar, pero ya veremos esto.

Deben intentar realizar todo lo que detallo aquí antes de continuar, no importa cuanto tiempo les lleve, cuantas veces se tranquen, si tienen que escribirme a mí o buscar más info en Internet, deben lograr hacerlo. No hay nada aquí que no puedan hacer con lo que saben hasta ahora, es más, todo está pensado para que lo hagan justamente con estas herramientas. Si han logrado resolver la mayoría de los ejercicios anteriores más este programa, entonces han aprendido lo básico de la programación de forma excelente y podrán resolver cualquier tipo de situación que no requiera estructuras mucho más complejas que estas que hemos visto más las que veremos a continuación. Existe una herramienta de implementación de funciones llamada RECURSIÓN, sin embargo no la veremos en esta entrega.

Saludos.



Ultima edición por Kyshuo Ayame el Lunes 24 Oct 2011 17:52; editado 1 vez
Volver arriba
Ver perfil del usuario Enviar mensaje privado
pirdy
Usuario Inquieto


Registrado: 11 Feb 2010
Mensajes: 137

Mensaje Publicado: Jueves 11 Ago 2011 23:12

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Muchas gracias.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
juan alejandro
Usuario Iniciado


Registrado: 07 Ene 2011
Mensajes: 43
Ubicación: Bogotá - Colombia

Mensaje Publicado: Viernes 12 Ago 2011 00:43

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Uff se ve espectacular gracias kyshuo!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Viernes 02 Dic 2011 03:02

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Apenas casi termino el primer ejercicio relacionado con productos, esta es una nueva oportunidad que nos da Kyshuo para explorar lo aprendido, creo que me llevará gran parte de diciembre XD .... es todo un RETO como dice él mismo, y me gusta eso,voy aprendiendo que son los retos lo que nos hace grandes programadores compañeros!
Mil Gracias Kyshuo!!! Ok

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Sábado 10 Dic 2011 21:14

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Profe tengo una pequeña duda, sucede que se declara la constante global N=5, sin embargo usted da un ejemplo donde se ingresa un sexto elemento en la lista; que se debería hacer si se llega a productos.tope=N y se intenta ingresar a su vez un nuevo producto a la lista? Debería programar una captura de error o agregarlo de algún modo?
Gracias Kyshuo!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Domingo 11 Dic 2011 01:04

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Eso es decisión del programador. Si se llega al tope pues la lista está llena y por ende no se puede agregar más nada.

¿Qué sería lo más adecuado? Pues dependerá de lo que te hayan pedido. Si quién quería el programa prefiere recibir un mensaje de aviso pues entonces pon un mensaje de aviso, si quisiera que se borrara un elemento para agregar el nuevo pues entonces así será....

Para este caso, lo mejor es un mensaje de aviso estilo:

"No es posible cargar más productos al sistema hasta que al menos uno sea eliminado."

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Domingo 11 Dic 2011 02:58

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

entendido, muchas gracias Kyshuo!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Domingo 11 Dic 2011 23:19

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Profe, y en la declaración que señala la flecha en el código siguiente (que corresponde a la declaración del tipo Productos) ¿no es necesario declarar un nombre para el campo array? o ¿se puede dejar así?, la duda la tengo debido a que hasta el momento siempre he visto nombre para cada campo de un registro:
Código:

Elemento= Record
      Nombre: String;
      Stock: TNaturales;
      Precio: Real;
      Categoria: Categorias;
      ID: TNaturales;
   End;

   Productos= Record
      Array[1..N] of Elemento; <-----
      tope: 0..N;
   End;

Si se deja asi sería mas fácil acceder a los campos del registro Elemento, sin embargo la duda está presente.
Muchas gracias Kyshuo!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 12 Dic 2011 01:16

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Toda la razón, ha sido un error de tipeo... Nuevamente me has pillado jaja...

Gracias por tu atención amigo...

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Lunes 12 Dic 2011 08:37

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

entonces si quiero acceder al nombre de un elemento, por ejemplo, sería algo como lo que sigue?:
Código:
listaproductos.lista[i].nombre

suponiendo que he declarado listaproductos como variable del tipo productos y se le ha asignado al campo array of Elemento el nombre lista...

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Jueves 15 Dic 2011 21:38

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

bueno después de un par de dias de vacaciones regreso jeje... ya casi termino el ejercicio, al menos una primera parte la de redactar los nuevos procedimientos y funciones, declarar nuevamente el tipo productos y demás.... creo que la parte más ardua será la de implementarlos al antiguo código (la primera parte) porque supongo que deberé modificar la forma en que se accede y se escribe en los campos del registro,eso implica tambien modificar los antiguos procedimientos y funciones ... bueno ya iré contando como me va Fumao EXCELENTE EJERCICIO!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Domingo 18 Dic 2011 23:57

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

listooo!! jejej me llevó casi 1000 lineas pero lo terminé!
MIL GRACIAS A KYSHUO! y cualquier ayuda que pueda brindar, la solución estará a su disposición amigos...
ahora el momento del proyecto final! Super

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 19 Dic 2011 16:13

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Estimado amigo Floyd, si quieres publica aquí tu solución y luego yo la pondré en en las soluciones de ejercicios resueltos.

Gracias por tu excelente trabajo...

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Martes 03 Ene 2012 22:26

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Buen nuevo año a todos los compañeros del curso!!!

Este ejercicio es de acuerdo a mi experiencia el que hasta el momento ha sido el más relevante en cuanto a programación estructurada, ya que es en él donde se ratifica todo tooodooo lo dado hasta aqui; creo que no se le escapa nada; incluso tuve que repasar la sintaxis de algunas estructuras,pequeños detalles de las primeras lecciones que habia olvidado,etc. Es el mejor ejercicio hasta la pressente lección (RECOMENDADÍSIMO!)
En particular este código tiene una pequeña falencia,mínima pero importante que luego comentaré...
Este es el código:

Código:
PROGRAM Bdatos_productos;
uses crt;
const
N=5;
MaxLargoNombre=20;

type
 categorias=(comestibles,frutas_verduras,higiene_h,higiene_p);
 TNaturales=0..maxint;

 elemento= record
    nombre: string;
    stock: TNaturales;
    Precio: real;
    categoria: categorias;
    ID: Tnaturales;
    end;
 productos= record
 lista: array[1..N] of elemento;
 tope: 0..N;
 end;

 CadenaChar=RECORD
 nombre: Array[1..MaxLargoNombre] of Char;
 tope: 0..MaxLargoNombre;
 end;

 Var
 j,aux: integer;
 opcion: char;
 nom: string;
 INIRANGO,FINRANGO: CHAR;
 baseproductos: productos;
 cadena: cadenachar;

 //MENU PRINCIPAL
 PROCEDURE menuprincipal(VAR listaproductos:productos);
 //*****************************************************
  FUNCTION OpcionCorrecta(inicioRango, finRango: char): Boolean;
  begin
  opcioncorrecta:=((ord(iniciorango)<=ord(opcion))  and (ord(opcion)<=ord(finrango)) );
  end;
 //*****************************************************
 FUNCTION IDRepetido(listaproductos:productos;entero:integer):boolean;
 var i:integer;
 Begin
 i:=1;
 while (i<=listaproductos.tope) and (entero<>listaproductos.lista[i].ID)
 DO i:=i+1;
 IDrepetido:=(i<=listaproductos.tope);
 end;
//*******************************************************
  FUNCTION EsEnteroPositivo(numero: CadenaChar):boolean;
  var i: integer;

  begin
  i:=1;
  while (i<=numero.tope) and ( (48<=ord(numero.nombre[i])) and (ord(numero.nombre[i])<=57) )
  DO i:=i+1;

  EsEnteroPositivo:= (i>numero.tope);
  end;
//********************************************+
  FUNCTION StringToInt(numero:CadenaChar):integer;  {MAXINT = 32767}

  var cont,i: integer;

   function pot(exponente: integer): integer;
    var i,acumulador:integer;
    begin
     acumulador:=1;
     for i:=1 to exponente do
     acumulador:= 10*acumulador;
     pot:=acumulador;
    end;

  begin

  cont:=0;
  for i:=1 to numero.tope do
  cont:=((ord(numero.nombre[i])-48)*pot(numero.tope-i))+cont;

  StringToInt:=cont;
  end;
 //*******************************************
 FUNCTION nombrecorrecto(name:CadenaChar):Boolean;

 var i: integer;

 begin

 i:=1;
 while(i<=name.tope) and ( ( (48<=ord(name.nombre[i])) and (ord(name.nombre[i])<=57) )
                          or( (65<=ord(name.nombre[i])) and (ord(name.nombre[i])<=90) )
                          or( (97<=ord(name.nombre[i])) and (ord(name.nombre[i])<=122))
                          ) DO
 i:=i+1;

 nombrecorrecto:= (i>name.tope);
 end;
//********************************************
 FUNCTION EsRealPositivo(numero: CadenaChar):boolean;

 var
 i,contcoma: integer;

 begin
 i:=1; contcoma:=0;

 while (i<=numero.tope) and
 (((48<=ord(numero.nombre[i])) and (ord(numero.nombre[i])<=57)) or (ord(numero.nombre[i])= 44))

 DO  begin
 i:=i+1;
 if ord(numero.nombre[i-1])= 44 then
 contcoma:=contcoma+1;
    end;

 EsRealPositivo:= ( (i>numero.tope) and (contcoma<2) );

 end;
//**********************************************
 FUNCTION StringToReal(numero:CadenaChar):real;

 Var ind,j,cont: integer;
    cont2: real;
   Function pot(exponente: integer): integer;
    var i,acumulador:integer;
    begin
     acumulador:=1;
     for i:=1 to exponente do
     acumulador:= 10*acumulador;
     pot:=acumulador;
    end;

 begin
 ind:=1;
 while ( (ind<=numero.tope) and ( ord(numero.nombre[ind])<>44 ) )do
 ind:=ind+1;

 if ind<=numero.tope then           {ind es numero de caracteres de parte entera}
 begin
 cont:=0;
 ind:=ind-1;
 for j:=1 to ind do
 cont:=((ord(numero.nombre[j])-48)*pot(ind-j))+cont;

 ind:=ind+2;                          {saltamos a parte decimal y se obtiene decimal}
 cont2:=0;
 for j:=ind to numero.tope do
 cont2:=((ord(numero.nombre[j])-48)*pot(numero.tope-j))+cont2; {obtenemos entero}
 cont2:=cont2/(pot(numero.tope-ind+1));                           {pasamos a decimal}
 StringToReal:= cont+cont2;
 end
 else                                                        {si no tiene parte decimal...}
 begin
 stringtoreal:=stringtoint(numero);                         {...tonces solo parte entera}
 end;

 end;
//******************************************************************+
 procedure leercadena(var cadena:cadenachar);
   begin
   cadena.tope:=0;
     repeat
    cadena.tope:=cadena.tope+1;
    read(cadena.nombre[cadena.tope]);
    until (eoln) or (cadena.tope=MaxLargoNombre);
   end;
//********************************************************************
   FUNCTION BuscarPorCategoria(listaproductos:productos;categoria:categorias;indice:integer):integer;

 begin
 while (indice<=listaproductos.tope) and (categoria<>listaproductos.lista[indice].categoria)
 DO indice:=indice+1;

 if indice <= listaproductos.tope then
 buscarporcategoria:=indice
 else
 buscarporcategoria:=0;
 end;
 //***************************************************
 //procedimiento para ingresar datos de un producto
 Procedure IngresoDatosProducto(VAR listaproductos: productos; indice:integer);
  var i: integer;
      cadena: cadenachar;
   //*********
 Begin
 if indice<>0 then
  begin
 Repeat
 write('ID >> ');
 leercadena(cadena);
 readln;
 if EsEnteroPositivo(cadena) then
  begin
  i:=stringtoint(cadena);
  if not IDrepetido(listaproductos,i) then
  listaproductos.lista[indice].ID := i
  else writeln('ERROR: ID repetido');
  end
 else
 writeln('Error: Dato inesperado,ingrese un dato válido');
 Until listaproductos.lista[indice].ID=i;

 write('Nombre >> ');
 readln(listaproductos.lista[indice].nombre);
 Repeat
 write('Precio >> ');
 leercadena(cadena);
 readln;
 if EsRealPositivo(cadena) then
 listaproductos.lista[indice].precio:=stringtoreal(cadena)
 else
 writeln('Error: Dato inesperado,ingrese un dato válido');
 Until  EsRealPositivo(cadena);

 repeat
 write('stock >> ');
 leercadena(cadena);
 readln;
 if EsEnteroPositivo(cadena) then
 listaproductos.lista[indice].stock := stringtoint(cadena)
 else
 writeln('Error: Dato inesperado,ingrese un dato válido');
 Until EsEnteroPositivo(cadena);

   Repeat
 writeln('Categorías: (1) Comestibles');
 writeln('            (2) Frutas y verduras');
 writeln('            (3) Higiene del hogar');
 writeln('            (4) Higiene personal');
 write('ingrese la opcion deseada >> ');
 readln(opcion);
 inirango:='1';  finrango:='4';
 if opcioncorrecta(inirango,finrango) then
 begin
 i:=ord(opcion)-49;
 listaproductos.lista[indice].categoria:= categorias(i);
 end
 else
 writeln('opcion incorrecta');
   Until opcioncorrecta(inirango,finrango);

 end //end if superior
 else
 writeln('.');
 end;
 //*****************************************
 procedure MostrarDatosProducto(listaproductos:productos; indice:integer);
 begin
 if indice<>0 then
  begin
  writeln;
  writeln('ID: ',listaproductos.lista[indice].id);
  writeln('NOMBRE: ',listaproductos.lista[indice].nombre);
  writeln('Stock: ',listaproductos.lista[indice].stock);
  writeln('Precio: ',listaproductos.lista[indice].precio:2:2);
  write('Categoría: ');
  case listaproductos.lista[indice].categoria of
  comestibles: writeln('comestibles');
  frutas_verduras: writeln('frutas y verduras');
  higiene_h: writeln('Higiene del hogar');
  higiene_p: writeln('Higiene personal');
  end;
  writeln;
  writeln;
  end
  else
  begin
  writeln;
  write('No existen productos para mostrar');
  end;
 end;
 //********************************************
 //opcion 2 del menu principal
 procedure MostrarListaProductos(ListaProductos: Productos; opcion:char);
 begin
 writeln;
 aux:=0;
 case opcion of
 '0': begin
      writeln('Lista de elementos seleccionados (TODOS):');
      writeln;
      if listaproductos.tope=0 then
      writeln('La lista está vacía');
      aux:=1;
      for j:=1 to listaproductos.tope do
      writeln(listaproductos.lista[j].nombre,' ID: ',listaproductos.lista[j].ID);
      writeln;
      end;
 '1': begin
      writeln('Lista de elementos seleccionados (COMESTIBLES)');
      writeln;
      for j:=1 to listaproductos.tope do
      if listaproductos.lista[j].categoria = comestibles then
         begin aux:=aux+1;
         writeln(listaproductos.lista[j].nombre,' ID: ',listaproductos.lista[j].ID);
         end;
      end;
 '2': begin
      writeln('Lista de elementos seleccionados (FRUTAS Y VERDURAS)');
      writeln;
      for j:=1 to listaproductos.tope do
      if listaproductos.lista[j].categoria = frutas_verduras then
         begin aux:=aux+1;
         writeln(listaproductos.lista[j].nombre,' ID: ',listaproductos.lista[j].ID);
         end;
      end;
 '3': begin
      writeln('Lista de elementos seleccionados (HIGIENE DEL HOGAR)');
      writeln;
      for j:=1 to listaproductos.tope do
      if listaproductos.lista[j].categoria = higiene_h then
         begin aux:=aux+1;
         writeln(listaproductos.lista[j].nombre,' ID: ',listaproductos.lista[j].ID);
         end;
      end;
 '4': begin
      writeln('Lista de elementos seleccionados (HIGIENE PERSONAL)');
      writeln;
      for j:=1 to listaproductos.tope do
      if listaproductos.lista[j].categoria = higiene_p then
         begin aux:=aux+1;
         writeln(listaproductos.lista[j].nombre,' ID: ',listaproductos.lista[j].ID);
         end;
      end;
 '5': writeln;
  end; // end del case
  if aux=0 then writeln('No hay existencia de productos.');
 end; // end de procedure
//****************************************************
{procedimiento para opcion '3' del menú ppal.}
PROCEDURE ModificarProductos( VAR ListaProductos: Productos; opcion: char);
 var
 i,j,ind,cont,cont0: integer;
 cat: categorias;
 FUNCTION buscarPorID(listaProductos: productos; ID:integer):integer;
 var
 i: integer;
 begin
 i:=1;
 while (i<=listaproductos.tope) and (ID<>listaProductos.lista[i].ID) do
 i:= i+1;

 if i<=listaproductos.tope then
 buscarPorID:=i
 else
 buscarPorID:=0;
 end;
 //************************************************************************
 FUNCTION BuscarPorNombre(listaproductos: Productos;nombre:String;Indice:integer):integer;
 Begin
 while (indice<=listaproductos.tope) and (nombre<>listaproductos.lista[indice].nombre)
 DO indice:=indice+1;

 if indice<=listaproductos.tope then
 buscarpornombre:=indice
 else
 buscarpornombre:=0;
 end;
 //***************************************************
 procedure modificarcategoria(var listaproductos: productos;indi: integer);
 var jj,ii,cont2,cont02:integer;
 begin
 cat:=categorias(indi-1);
 jj:=1; cont2:=0; cont02:=0; ii:=1;
     REPEAT
     jj:=buscarporcategoria(listaproductos,cat,ii);
       if jj <> 0 then
        begin
        writeln;
        mostrardatosproducto(listaproductos,jj);
        writeln('Ingrese los nuevos datos: ');
        listaproductos.lista[jj].id:=0;
        IngresoDatosProducto(listaproductos,jj);
        ii:=jj+1; cont2:=cont2+1;
        end
        else
        begin
        cont02:=cont02+1; ii:=ii+1;
        end;
        UNTIL (ii>listaproductos.tope) OR
              (cont02>listaproductos.tope);

       if cont02=listaproductos.tope then
       begin
       writeln;
       writeln('No hay datos concordantes con la búsqueda');
       writeln;
       end
       else
       begin
       writeln;
       write('No existen más elementos de la categoria ');
       case indi of
       1: begin
          writeln('Comestibles.');
          writeln;
          writeln('Ha terminado de modificar los elementos con la categoria original Comestibles.');
          end;
       2: begin
          writeln('Frutas y Verduras.');
          writeln;
          writeln('Ha terminado de modificar los elementos con la categoria original Frutas y Verduras.');
          end;
       3: begin
          writeln('Higiene del hogar.');
          writeln;
          writeln('Ha terminado de modificar los elementos con la categoria original Higiene del Hogar.');
          end;
       4: begin
          writeln('Higiene personal.');
          writeln;
          writeln('Ha terminado de modificar los elementos con la categoria original Higiene personal.');
          end;
       end; //end del case
      end;
     end; //end del procedure.
 //***************************************************
  Begin
 case opcion of
 '1':begin
     clrscr;
      writeln('Modificando Productos (TODOS):');
      writeln;
      for  i:=1 to listaproductos.tope do
      begin
      MostrarDatosProducto(ListaProductos,i);
      writeln('Ingrese los nuevos datos:');
      writeln;
      listaproductos.lista[i].id:=0;{se anulan ID´s para evitar error IDrepetido}
      IngresoDatosProducto(ListaProductos,i);
      end;
      writeln('Ha terminado de modificar los productos (TODOS)');
     end;
 '2': begin
      clrscr;
      writeln('Modificando Productos (ID):');
    Repeat
      write('Ingrese el ID del producto a modificar: ');
      leercadena(cadena);
      readln;
      if not EsEnteroPositivo(cadena) then
       writeln('Error: Dato inesperado, Ingrese un dato válido.')
      else
  {*} begin
      i:=stringtoint(cadena);
      j:= BuscarPorID(listaProductos,i);
      MostrarDatosProducto(ListaProductos,j);
      writeln;
      if j<>0 then
       begin
      writeln('Ingrese los nuevos datos: ');
      writeln;
      listaproductos.lista[j].id:=0;
      IngresoDatosProducto(ListaProductos,j);
      writeln;
      if j<>0 then
      writeln('Ha terminado de modificar el producto con ID ',i);
       end;
  {*} end;
    Until EsEnteroPositivo(cadena);
      end;
   '3':begin
       clrscr;
       writeln('Modificando productos (NOMBRE):');
       writeln;
       write('Ingrese el nombre de los productos a modificar: ');
       readln(nom);
       j:=1; cont0:=0; cont:=0; i:=1;

       REPEAT
       j:=buscarpornombre(listaproductos,nom,i);
        if j <> 0 then
        begin
        writeln;
        mostrardatosproducto(listaproductos,j);
        writeln('Ingrese los nuevos datos: ');
        listaproductos.lista[j].id:=0;
        IngresoDatosProducto(listaproductos,j);
        i:=i+1; cont:=cont+1; {cont: contador de nombres hallados}
        end
        else
        begin
        cont0:=cont0+1; i:=i+1; {cont0 cuenta el numero de veces que no...}
        end;                    {...se halló un nombre igual en lista}
       UNTIL (i>listaproductos.tope) OR
             (cont0>listaproductos.tope);

        if (cont0>=1) and (cont=0) then
        begin
        writeln;
        writeln('No hay datos concordantes con la búsqueda');
        writeln;
        end
        else
        begin
        writeln;
        writeln('No existen más elementos con el nombre ',nom);
        writeln;
        write('Ha terminado de modificar los elementos ');
        writeln('con el nombre original ',nom);
        writeln;
        end;
        end; //end '3'.
   '4':begin
        clrscr;
        writeln('Modificando productos (COMESTIBLES):');
        writeln;
        aux:=1;
        modificarcategoria(listaproductos,aux);
        end;// end '4'.
    '5': begin
        clrscr;
        writeln('Modificando productos (FRUTAS Y VERDURAS):');
       writeln;
       aux:=2;
       modificarcategoria(listaproductos,aux);
       end;// end '5'.
    '6':begin
    clrscr;
    writeln('Modificando productos (HIGIENE DEL HOGAR):');
    writeln;
    aux:=3;
    modificarcategoria(listaproductos,aux);
       end;// end '6'.
   '7':begin
    clrscr;
    writeln('Modificando productos (HIGIENE PERSONAL):');
    writeln;
    aux:=4;
    modificarcategoria(listaproductos,aux);
       end;// end '7'.
   '9':writeln;
 end; //end del case
 end; // end del procedimiento
 //********************************************************
 FUNCTION buscarPorID(listaProductos: productos; ID:integer):integer;

 var
 i: integer;

 begin
 i:=1;
 while (i<=listaproductos.tope) and (ID<>listaProductos.lista[i].ID) do
 i:= i+1;

 if i<=listaproductos.tope then
 buscarPorID:=i
 else
 buscarPorID:=0;
 end;
//**********************************************************
  FUNCTION BuscarPorNombre(listas: productos; nombre: string):integer;
 Var           {para usar en ultima opcion del menu ppal.}
 i: integer;
 begin
 i:=j;
 while (i<=listaproductos.tope) and (listas.lista[i].nombre <> nombre) do
 i:=i+1;

 if i<=listaproductos.tope then
 BuscarPorNombre:=i
 else
 BuscarPorNombre:=0;
 end;
 //*************************************+***************
 procedure mostrarnoms(listaproductos:productos; nom:string);
 var
 cont,cont0,ind: integer;

 begin
 j:=1; cont:=1; cont0:=0;
 repeat
 ind:=BuscarPorNombre(listaproductos,nom);
 if ind<>0 then
  begin
  j:=ind+1;
  writeln;
  MostrarDatosProducto(listaproductos,ind);
  end
  else
  begin
  cont0:=cont0+1; j:=j+1;
  end;
  cont:=cont+1;
  until (j>listaproductos.tope) or (cont>listaproductos.tope);
  if cont0=listaproductos.tope then
  begin
  writeln;
  writeln('No hay nombres que concuerden con la búsqueda');
  writeln;
  end
  else
  writeln('Fin de la lista.');
  writeln;
  end;
 //*********************************************************
 PROCEDURE EliminarProducto(VAR Lista: Productos; indice: integer);
 Var i,j: integer;
 begin
 IF indice=0 then writeln('El producto no existe en la lista')
 ELSE
 begin
 if indice=lista.tope then
 begin
 lista.lista[indice].ID:=0;  {evita error id repetido }
 lista.tope:=lista.tope-1
 end
 else
  begin
  i:=0; j:=lista.tope-1;
  for i:=indice to j do
   begin
  lista.lista[i].nombre:=lista.lista[i+1].nombre;
  lista.lista[i].stock:=lista.lista[i+1].stock;
  lista.lista[i].precio:=lista.lista[i+1].precio;
  lista.lista[i].categoria:=lista.lista[i+1].categoria;
  lista.lista[i].ID:=lista.lista[i+1].ID;   { i+1 = lista.tope }
   end;
  lista.tope:=j; {se disminuye una unidad a tope}
  end;
 end;
 end;
 //*********************************************************
 Procedure eliminarcategoria(var listaproductos:productos; cat: categorias);
     Var opcion: char;
         t:integer;
     begin

     REPEAT
     write('Seguro que desea eliminar la categoría comestibles? (S/N): ');
     readln(opcion);

      case opcion of
     'N','n': begin
              writeln('Se ha cancelado la operación');
              end;

     'S','s': begin
              t:=1;
              t:=buscarporcategoria(listaproductos,cat,t);
               if t=0 then
               writeln('No hay productos de la categoria seleccionada')
               else
        {*}     begin

                writeln('Eliminados:');
                repeat
               write(listaproductos.lista[t].nombre);
               writeln(' ID: ',listaproductos.lista[t].ID);
               eliminarproducto(listaproductos,t);
               t:=buscarporcategoria(listaproductos,cat,t);
               until t=0;
        {*}     end; //else
             end;// 's'
         else writeln('ERROR: Usted no ha elegido una opcion correcta');

         end; //end case 'n','s'...
      UNTIL ( (ord(opcion)=78) or (ord(opcion)=83) or (ord(opcion)=110) or (ord(opcion)=115) );
      write('Presione ENTER para volver al menú principal...');
      readln;

      End; //end procedure

 //*********************************************************
BEGIN
 clrscr;
 IniRango:='1'; FinRango:='8';
 writeln('MENÚ PRINCIPAL:');
 writeln('1) Ingresar nuevo producto.');
 writeln('2) Ver lista de productos.');
 writeln('3) Modificar Productos.');
 writeln('4) Vender.');
 writeln('5) Buscar.');
 writeln('6) Cantidad de productos ingresados');
 writeln('7) Eliminar producto.');
 writeln;
 writeln('8) Salir.');
 writeln;
  Repeat
 write('Opción: ');
 readln(opcion);
 if opcioncorrecta(IniRango,Finrango)=False then
 writeln('ERROR: Dato inesperado, ingrese un dato válido');
  Until opcioncorrecta(IniRango,FinRango);
 case opcion of
 '1': begin
       clrscr;
      IF listaproductos.tope<N then
      begin
       REPEAT
       listaproductos.tope:=listaproductos.tope+1;
       j:=listaproductos.tope;
       writeln;
       writeln('|--------PRODUCTO ',j,'---------|');
       IngresoDatosProducto(listaproductos,j);
       writeln;
       if listaproductos.tope<N then
       begin
       IniRango:='1'; FinRango:='2';
        repeat
        Write('Ingrese otro producto (1=SI /*\ 2=NO): ');
        readln(opcion);
        if opcioncorrecta(Inirango,FinRango)=false then
        writeln('ERROR: Dato inesperado,ingrese un dato válido.');
        until opcioncorrecta(Inirango,FinRango);
       end
       else
       begin
       writeln('La lista de productos está llena');
       write('Presione ENTER para volver al menú principal...');
       readln;
       end;
       UNTIL (opcion='2') or (listaproductos.tope=N);
       end
       Else
       begin
       writeln;
       write('Imposible ingresar nuevo producto ');
       writeln('la lista está llena.');
       writeln('Elimine al menos un producto para nuevo ingreso');
       write('Presione ENTER para volver al menú principal...');
       readln;
       end;
      end;
 '2': begin
      clrscr;
      Inirango:='0'; FinRango:='5';
      writeln('Ver lista de productos:');
      writeln();
      writeln('0) Ver todos');
      writeln('1) Comestibles');
      writeln('2) Frutas y verduras');
      writeln('3) Higiene del hogar');
      writeln('4) Higiene personal');
      writeln();
      writeln('5) Volver al Menú Principal');
      writeln();
      repeat
      write('Opción >> ');
      readln(opcion);
      if opcioncorrecta(IniRango,FinRango)=false then
      writeln('ERROR: Dato inesperado,ingrese un dato válido.');
      until opcioncorrecta(IniRango,FinRango);
      clrscr;
      MostrarListaProductos(ListaProductos,opcion);
      writeln;
      if opcion <> '5' then
       begin
      write('presione ENTER para volver al menú principal...');
      readln;
       end;
      end;// end '2'.
 '3': begin
       clrscr;
       IniRango:='1'; FinRango:='8';
       writeln('Modificar Productos:');
       writeln;
       writeln;
       writeln('1) Todos');
       writeln('2) Según ID');
       writeln('3) Según nombre');
       writeln('4) Comestibles');
       writeln('5) Frutas y Verduras');
       writeln('6) Higiene del Hogar');
       writeln('7) Higiene personal');
       writeln;
       writeln;
       writeln('8) Volver al Menú Principal');
       writeln;
       writeln;
       repeat
       write('Opción >> ');
       readln(opcion);
       if opcioncorrecta(IniRango,FinRango)=false then
       writeln('ERROR: Dato inesperado,ingrese un dato válido.');
       until opcioncorrecta(IniRango,FinRango);
       modificarproductos(listaproductos,opcion);
       if opcion <> '8' then
        begin
       writeln;
       write('presione ENTER para volver al menú principal...');
       readln;
        end;
       end;
 '4': begin
       clrscr;
       writeln;
        Repeat
       write('Ingrese el ID del producto que desea vender: ');
       leercadena(cadena);
       readln;
       if not EsEnteroPositivo(cadena) then
       writeln('ERROR: Dato inesperado,ingrese un dato válido.');
        Until EsEnteroPositivo(cadena);
       aux:=stringtoint(cadena);
       writeln;
       writeln('datos del producto:');
       writeln;
       j:=buscarporid(listaproductos,aux);
       MostrarDatosProducto(listaproductos,j);
       writeln;
       if j<>0 then
        begin
        Repeat
       write('ingrese la cantidad que desea vender: ');
       leercadena(cadena);
       readln;
       if not EsEnteroPositivo(cadena) then
       writeln('ERROR:  Dato inesperado,ingrese un dato válido.');
        Until EsEnteroPositivo(cadena);
       aux:=stringtoint(cadena);
       writeln('Dinero obtenido: ',listaproductos.lista[j].precio*aux:2:2);
       listaproductos.lista[j].stock:=listaproductos.lista[j].stock - aux;
        end;
       write('presione ENTER para volver al menú principal...');
       readln;
      end;//end '4'
 '5': begin
       clrscr;
       Inirango:='1'; Finrango:='3';
       writeln;
       writeln('Buscar productos:');
       writeln;
       writeln('1) Según ID');
       writeln('2) Según Nombre');
       writeln('3) Volver al menú principal');
       Repeat
       write('Opción >> ');
       readln(opcion);
       if opcioncorrecta(IniRango,FinRango)=false then
       writeln('ERROR: Dato inesperado,ingrese un dato válido.');
       until opcioncorrecta(IniRango,FinRango);
       case opcion of
       '1': begin
            writeln('buscando según ID');
            writeln;
            Repeat
            write('Ingrese el ID del producto que desea buscar: ');
            leercadena(cadena);
            readln;
            if not EsEnteroPositivo(cadena) then
            writeln('Error: Dato inesperado');
            Until Esenteropositivo(cadena);
            aux:=stringtoint(cadena);
            aux:=BuscarPorID(listaproductos,aux);
            MostrarDatosProducto(listaproductos,aux);
            writeln;
            write('Presione ENTER para volver al menú principal...');
            readln;
            end;
       '2': begin
            writeln('buscando según NOMBRE:');
            writeln;
            write('Ingrese el nombre del/los producto/s: ');
            readln(nom);
            mostrarnoms(listaproductos,nom);
            write('Presione ENTER para volver al menú principal...');
            readln;
            end;
       '3': writeln;
        end; //end case
       end; //end '5'
 '6': begin
      clrscr;
      writeln;
      writeln('Total de productos: ',listaproductos.tope);
      write('presione ENTER para volver al menú principal...');
      readln;
      end;
 '7': begin
      clrscr;
      writeln;
      writeln('ELIMINAR PRODUCTO:');
      writeln('1) Eliminar según ID');
      writeln('2) Eliminar comestibles');
      writeln('3) Eliminar Frutas y Verduras');
      writeln('4) Elimina Higiene del hogar');
      writeln('5) Eliminar Higiene personal');
      writeln('6) Volver al Menú Principal');
      writeln;
      Inirango:='1'; FinRango:='6';
         repeat
      write('Opción>> ');
      readln(opcion);
      if opcioncorrecta(inirango,finrango)=false then
      writeln('ERROR: Dato inesperado,ingrese un dato válido.');
         until opcioncorrecta(inirango,finrango);
      case opcion of

     '1': begin
     REPEAT
     writeln('Ingrese el ID del producto a eliminar ');
     write(' o M para volver al menú principal: ');
     leercadena(cadena);
      readln;

     if (cadena.tope= 1) and
     ((ord(cadena.nombre[1])=109) or (ord(cadena.nombre[1])=77)) then
       writeln
     else
       begin
         if (esenteropositivo(cadena)) then
         begin
         j:=stringtoint(cadena);
         j:=buscarporId(listaproductos,j);
          if j=0 then
           begin
           writeln('El producto no existe.');
           write('presione ENTER para volver al menú principal...');
           end
          ELSE
          BEGIN
         mostrardatosproducto(listaproductos,j);
         writeln;

     {*}       REpeat
         write('Seguro que desea eliminar este producto? (S/N): ');
         aux:=0;
         readln(opcion);
           case opcion of
           'N','n': begin
                    writeln('Eliminación cancelada');
                    write('presione ENTER para volver al menú principal...');
                    aux:=1;
                    end;
           'S','s': begin
                    aux:=listaproductos.lista[j].ID;
                    EliminarProducto(listaproductos,j);
                    writeln('Se ha eliminado exitosamente el producto con ID ',aux);
                    write('Presione ENTER para volver al menú principal...');
                    aux:=1;
                    end;
            else writeln('ERROR: Dato inesperado,presione ENTER para volver a intentarlo...');
           end; // case
      {*}       UNtil aux=1;
           end; //ELSE j=0.
         readln;
         end    //del if
         else
             begin
             writeln;
             writeln('ERROR: Dato inesperado.');
             writeln;
             end;
       end;  // else
      UNTIL ((ord(cadena.nombre[1])=109) or (ord(cadena.nombre[1])=77))
             OR (esenteropositivo(cadena));
       end; // '1'
     '2':eliminarcategoria(listaproductos,comestibles);
     '3':eliminarcategoria(listaproductos,frutas_verduras);
     '4':eliminarcategoria(listaproductos,higiene_h);
     '5':eliminarcategoria(listaproductos,higiene_p);
      end; // end case
   end; // '7'
 '8': exit;

 end; //end case.

 end; //end menu principal.

 BEGIN
 baseproductos.tope:=0;
 repeat
 menuprincipal(baseproductos);
 until opcion= '8';
 END.


saludos a todos y gracias a Kyshuo!! Ok

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Miércoles 04 Ene 2012 01:06

Título del mensaje: Re: Programando desde 0: 22- Otra aplicación de conocimiento

Responder citando

Bueno, sigo. Antes de describir la falencia arriba mencionada permitanme explicar primero de donde surge.
En la letra del ejercicio dice:
Nombre: El nombre de un producto debe estar formado únicamente por números y/o letras mayúsculas y/o minúsculas. Cualquier otro carácter se tomará como inválido.
Para controlar el nombre ingresado deben implementar una función como la siguiente:

Código:

FUNCTION NombreCorrecto(nombre: CadenaChar): Boolean;

donde CadenaChar será un tipo global declarado de la siguiente manera:

Código:

CONST
   MaxLargoNombre: 20;

TYPE
   CadenaChar= RECORD
      nombre: Array[1..MaxLargoNombre] of Char;
      tope: 0..MaxLargoNombre;
   END;

pues bien como notan en realidad el nombre se almacenará en un arreglo tipo char con tope definido en un registro, y que la función nombre correcto tiene como parámetros una variable tipo cadenaChar.
Adicional a lo anterior, el campo 'nombre' está definido para todo producto como string como lo señala la flecha:
Código:
Elemento= Record
      Nombre: String; <------------
      Stock: TNaturales;
      Precio: Real;
      Categoria: Categorias;
      ID: TNaturales;
   End;


En conjunto, lo anterior implica (asi lo veo yo) pasar un arreglo de caracteres con tope a una variable tipo string.... ahí si me perdí!!
Lo que no logré hacer con el código fué precisamente eso, pasar del arreglo de caracteres a string, por lo tanto esa restricción pedida en la letra del ejercicio no está desarrollada en el programa.
Todo lo demás lo desarrollé, igualmente le hice muchas pruebas al código y acata hasta el momento todo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Responder al Tema Ir a página 123Siguiente
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Buenas desde el sur del sur =)

Maugarni Preséntate a la comunidad 1 Jueves 22 Ago 2019 14:09 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Hola desde bcn

Dav2k6 Preséntate a la comunidad 2 Miércoles 26 Jun 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Existen problemas al descargar musica desde you...

SusanaP Tu PC 2 Martes 26 Mar 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

hola!! los saludo desde argentina

mery Preséntate a la comunidad 2 Jueves 13 Dic 2018 17:28 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Llamada a web service desde form

mrrobot2 Programación Web en general 1 Martes 14 Nov 2017 00:50 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,