Hoy es un dia importante, porque tengo el segundo examente de la asignatura Informatica…
- User
Hoy es un dia importante, porque tengo el segundo examente de la asignatura Informatica 1. Te acordas cuando te pedia ayuda con Pseint?
- Assistant
¡Claro que sí! Espero que te haya ido bien con el estudio y que te sientas preparado para el examen. Si necesitas un repaso rápido o resolver alguna duda de última hora sobre Pseint o cualquier otro tema, aquí estoy para ayudarte. ¡Mucho éxito en tu examen de Informática 1!
- User
Si, necesito que me ayudes porque hoy te voy a estar haciendo varias consultas. Por favor quiero que hoy tomes el rol del mejor programador de PSeInt
- Assistant
¡Por supuesto! Estoy aquí para ayudarte con todo lo que necesites sobre PSeInt. No dudes en hacerme todas las preguntas que necesites para que puedas tener éxito en tu examen. ¡Vamos a por ello! ¿Cuál es tu primera consulta?
- User
Necesito que tomes como perfil de PSeInt los siguientes parametros:
version=20230211 force_init_vars=0 force_define_vars=1 force_semicolon=1 allow_concatenation=0 enable_string_functions=1 word_operators=1 base_zero_arrays=0 allow_dinamyc_dimensions=0 allow_resize_arrays=0 overload_equal=1 enable_user_functions=1 lazy_syntax=0 coloquial_conditions=0 integer_only_switch=0 deduce_negative_for_step=1 use_nassi_shneiderman=1 use_alternative_io_shapes=1 allow_accents=1 prefer_algoritmo=1 prefer_funcion=1 allow_repeat_while=0 allow_for_each=0 prefer_repeat_while=0 protect_for_counter=0
- Assistant
¡Entendido! Configurar el entorno de PSeInt con esos parámetros establece una serie de reglas que determinan cómo se estructurarán y ejecutarán los algoritmos. Estas configuraciones afectarán cosas como el manejo de variables, el uso de funciones, y la estética de los diagramas, entre otros aspectos.
Aquí te dejo un breve resumen de lo que significa cada uno de estos parámetros:
- version=20230211: Estás utilizando una versión específica de PSeInt, que puede tener ligeras diferencias en funcionalidad con otras versiones.
- force_init_vars=0: No es obligatorio inicializar las variables al momento de declararlas.
- force_define_vars=1: Es obligatorio definir las variables antes de usarlas.
- force_semicolon=1: Requiere el uso de punto y coma al final de las líneas.
- allow_concatenation=0: No permite la concatenación de cadenas por defecto.
- enable_string_functions=1: Permite el uso de funciones de manejo de cadenas.
- word_operators=1: Los operadores se pueden escribir con palabras (por ejemplo, "y" en lugar de "&&").
- base_zero_arrays=0: Los arreglos son indexados empezando desde 1.
- allow_dynamic_dimensions=0: No permite usar dimensiones dinámicas en los arreglos.
- allow_resize_arrays=0: No se permite redimensionar arreglos después de la declaración.
- overload_equal=1: Se sobrecarga el operador igual.
- enable_user_functions=1: Se permite la creación y uso de funciones definidas por el usuario.
- lazy_syntax=0: Exige una sintaxis más estricta para las construcciones.
- coloquial_conditions=0: No permite condiciones coloquiales.
- integer_only_switch=0: El "Segun" no se limita solo a enteros.
- deduce_negative_for_step=1: Deduce el paso negativo en los bucles "Para".
- use_nassi_shneiderman=1: Utiliza los diagramas de Nassi-Shneiderman para la representación gráfica.
- use_alternative_io_shapes=1: Utiliza formas alternativas para las entradas/salidas en los diagramas.
- allow_accents=1: Permite el uso de acentos en las identificaciones.
- prefer_algoritmo=1: Prefiere usar la palabra clave "Algoritmo" en lugar de "Proceso".
- prefer_funcion=1: Prefiere "Función" en lugar de "Subproceso".
- allow_repeat_while=0: No permite el uso de la estructura "Repetir... Mientras".
- allow_for_each=0: No permite el uso de la estructura "Para Cada".
- prefer_repeat_while=0: No prefiere la estructura "Repetir Mientras".
- protect_for_counter=0: No protege la variable contadora en bucles "Para".
Si tienes alguna pregunta sobre cómo algunos de estos parámetros pueden afectar tus algoritmos o necesitas ejemplos específicos, no dudes en preguntar.
- User
Si me permitis, te voy a pegar un ejemplo de EXAMEN para que te acuerdes que funciones utilizar, vectores, y comandos para hacer de este el mejor parcial:
//Una conocida cadena de librer as de la Ciudad de Haedo cuenta con 10 vendedores identificados por su nombre, que atienden a los clientes, cobrando un 5% del importe de los libros vendidos como comisi n. //En un paso previo, ingresar los nombres de los 10 vendedores.
//Se puede solicitar a cualquiera de los vendedores los productos que vende la librer a y por cada venta se solicita (validar los datos ingresados por teclado con FUNCIONES): // // ? Nombre del vendedor (alfanum rico). // ? N mero de factura (entero, mayor a cero). //? Tipo de libro vendido (car cter, ?N?: novela, ?C?: c mic, ?T?: texto, ?O?: otros). // ? Cantidad vendida (entero, entre 1 y 20). // ? Precio unitario (real, mayor a cero). //Se considera que cada venta solamente tiene un tipo de libro y que un vendedor puede atender a muchos clientes o a ninguno (si estuvo ausente ese d a). La carga finaliza con un nombre de vendedor igual a "FINVENTAS". //Se pide: // a) Al finalizar la jornada, indicar el n mero de factura que realiz el mayor consumo en importe. // b) El promedio de ventas en importe de cada uno de los vendedores que estuvieron presentes (FUNCI N). // c) Informar el porcentaje vendido de cada uno de los tipos de libro. // d) Listar el nombre del vendedor, cantidad vendida, importe cobrado y comisi n a cobrar de cada vendedor (FUNCI N). Funcion CargarVec(Vec, celem) Definir i Como Entero;Para i=1 Hasta celem Hacer Leer Vec[i]; FinParaFinFuncion //************************************************************************* Funcion dato <- IngrMayorA(lim) Definir dato Como Entero; Definir band Como Logico;
band=Falso; Repetir Si band == Falso Entonces Leer dato; band=Verdadero; SiNo Escribir 'DATO FUERA DE RANGO - Vuelva a ingresar. Debe ser mayor a ', lim; Leer dato; FinSi Hasta Que dato > lim;FinFuncion //************************************************************************* Funcion dato <- IngrDatoValCar(car1, car2, car3, car4) Definir dato Como Caracter; Definir band Como Logico;
band=Falso; Repetir Si band == Falso Entonces Leer dato; band=Verdadero; SiNo Escribir 'DATO FUERA DE RANGO - Vuelva a ingresar. Debe ser igual a ', car1, ', ', car2, ', ', car3, ' o ', car4; Leer dato; FinSi Hasta Que dato == car1 O dato == car2 O dato == car3 O dato == car4;FinFuncion //************************************************************************* Funcion dato <- IngrDatoVal(linf, lsup) Definir dato Como Entero; Definir band Como Logico;
band=Falso; Repetir Si band == Falso Entonces Leer dato; band=Verdadero; SiNo Escribir 'DATO FUERA DE RANGO - Vuelva a ingresar. Debe ser mayor a ', linf, ' y menor a ', lsup; Leer dato; FinSi Hasta Que dato > linf Y dato < lsup;FinFuncion //************************************************************************* Funcion p <- Busqueda(Vec, celem, dato) Definir p, i Como Entero;
p=-1; Mientras p == -1 Y i < celem Hacer Si Vec[i]== dato Entonces p=i; SiNo i=i+1; FinSi FinMientrasFinFuncion //************************************************************************* Funcion MostrarPromVec(Vec1, Vec2, Vec3, celem) Definir i Como Entero;
Para i=1 Hasta celem Hacer Si Vec3[i] <> 0 Entonces Escribir Vec1[i], Vec2[i] / Vec3[i]; FinSi FinParaFinFuncion //************************************************************************* Funcion ListarVecParal(Vec1, Vec2, Vec3, dato, celem) Definir i Como Entero;
Para i=1 Hasta celem Hacer Escribir Vec1[i], Vec2[i] , Vec3[i], Vec3[i]*dato; FinParaFinFuncion //************************************************************************* Funcion s <- SumarVec(Vec, celem) Definir s, i Como Entero;
s=0; Para i=1 hasta celem Hacer s= s + Vec[i]; FinParaFinFuncion //************************************************************************* //************************************************************************* Algoritmo PracticaParcial2_2024 Definir vVendedores, vend, tipo Como Caracter; Definir vCantVend, vCantFact, fact, cantV, pos, maxFact, contN, contC, contT, contO, TotV Como Entero; Definir vImpVend, PUnit, max como real; Definir HayVta Como Logico;
Dimension vVendedores[10], vCantVend[10], vCantFact[10], vImpVend[10]; max=0; contN=0; contC=0; contT=0; contO=0; HayVta= Falso; Escribir 'Ingrese los nombres de los 10 vendedores'; CargarVec(vVendedores, 10); //Carga previa de nombres de vendedores Escribir 'Ingresar ventas...'; Escribir 'Ingrese nombre del vendedor - FINVENTAS para terminar'; Leer vend; Mientras vend <> 'FINVENTAS' Hacer HayVta= Verdadero; Escribir 'Ingrese el n mero de factura - mayor a cero'; fact=IngrMayorA(0); Escribir 'Ingrese el tipo de libro vendido - N, C, T u O'; tipo=IngrDatoValCar('N', 'C', 'T', 'O'); Escribir 'Ingrese cantidad vendida - entre 1 y 20'; cantV=IngrDatoVal(1,20); Escribir 'Ingrese el precio unitario- mayor a cero'; PUnit=IngrMayorA(0); pos=Busqueda(vVendedores, 10, vend); si pos <> -1 Entonces vCantVend[pos]=vCantVend[pos] + cantV; //Carga de vectores vImpVend[pos]=vImpVend[pos] + (cantV*PUnit); vCantFact[pos]=vCantFact[pos] + 1; Si (cantV*PUnit) > max Entonces max= (cantV*PUnit); maxFact= fact; FinSi //Punto a --> Rutina del mayor Segun tipo Hacer 'N': contN= contN+1; 'C': contC= contC+1; 'T': contT= contT+1; De Otro Modo: contO= contO+1; FinSegun SiNo Escribir 'No existe el nombre del vendedor'; FinSi Escribir 'Ingrese nombre del vendedor - FINVENTAS para terminar'; Leer vend; FinMientras Si HayVta Entonces Escribir 'El n mero de factura que m s vendi en importe es: ', maxFact; //Informar punto a Escribir 'VENDEDOR PROMEDIO DE VENTAS'; MostrarPromVec(vVendedores, vImpVend, vCantFact, 10); //punto b TotV=SumarVec(vCantVend, 10); Escribir 'Porcentaje de libros vendido tipo Novela: ', contN/TotV*100; //punto c Escribir 'Porcentaje de libros vendido tipo Comic: ', contC/TotV*100; Escribir 'Porcentaje de libros vendido tipo Texto: ', contT/TotV*100; Escribir 'Porcentaje de libros vendido tipo Otros: ', contO/TotV*100; Escribir 'VENDEDOR CANTIDAD VENDIDA IMPORTE VENDIDO COMISI N'; //punto d ListarVecParal(vVendedores, vCantVend, vImpVend, 0.05, 10); SiNo Escribir 'No hubo ventas'; FinSiFinAlgoritmo
- Assistant
¡Gracias por compartir el ejemplo del examen! Vamos a analizarlo y asegurarnos de que todos los componentes estén en su lugar para que puedas entender cómo funciona el algoritmo y las funciones utilizadas.
Descripción del Algoritmo
El algoritmo está diseñado para manejar las ventas de una librería con 10 vendedores, calculando varias métricas al final del día, como el mayor importe de venta, el promedio de ventas, el porcentaje de libros vendidos por tipo y los detalles de cada vendedor.
Análisis del Código
-
Funciones de Validación:
IngrMayorAvalida que un número ingresado sea mayor que un límite dado.IngrDatoValCarasegura que el dato ingresado sea uno de varios caracteres permitidos.IngrDatoValverifica que un número ingresado se encuentre dentro de un rango.
-
Funciones de Cálculo y Listado:
Busquedaimplementa una búsqueda lineal en un vector para encontrar la posición de un vendedor.MostrarPromVeccalcula y muestra el promedio de ventas de cada vendedor que realizó ventas.ListarVecParalimprime los datos de cada vendedor, incluyendo cantidad vendida, importe vendido, y comisión.SumarVecretorna la suma de los elementos en un vector dado.
-
Flujo del Algoritmo Principal:
- Se ingresan los nombres de los 10 vendedores.
- Se ejecuta un bucle que termina al ingresar "FINVENTAS", en el que se recopila información sobre las ventas, validando los datos ingresados.
- Se calculan las métricas solicitadas (punto a, b, c, d) y se muestran al usuario.
Puntos a Mejorar o Considerar
-
Inicialización de Variables:
- Asegúrate de inicializar todos los vectores con valores cero al principio para evitar errores de cálculo, como sumas inesperadas.
-
Validaciones:
- El algoritmo ya incluye validaciones básicas para los tipos de datos ingresados, pero podrías considerar validar también el formato del número de factura (si tiene un formato específico).
-
Presentación:
- Los nombres y valores impresos deben manejarse para que coincidan con las expectativas de formato para mejorar la legibilidad.
Preguntas
Si tienes preguntas específicas sobre cómo implementar alguna parte del código, modificarlo, o cualquier otra consulta sobre el mismo, por favor, avísame. Estoy aquí para ayudarte a entender los detalles y mejorar donde consideres necesario. ¡Buena suerte con el examen!
-
- User
Tener en cuenta de utilizar las siguientes funciones:
Funcion dato <-IngrDatoValido(limInf, limSup) Definir dato Como Entero;
Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup;FinFuncion
////////////////////////////////////////////
Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Entero;
Repetir Leer dato; Hasta Que dato > lim;FinFuncion
////////////////////////////////////////////
Funcion m <- Minimo(vec, celem) Definir i Como Entero; Definir m Como Real; Definir band Como Logico;
band = Falso; Para i=1 hasta celem Hacer Si band == Falso O vec[i] < m Entonces Si vec[i] <> 0 Entonces m = vec[i]; band = Verdadero; FinSi FinSi FinParaFinFuncion
////////////////////////////////////////////
Funcion M <- Maximo(vec, celem) Definir i Como Entero; Definir M Como Real;
M = vec[1]; Para i=2 hasta celem Hacer Si vec[i] > M Entonces M = vec[i]; FinSi FinParaFinFuncion
////////////////////////////////////////////
Funcion MostrarIndIgualA(Vec, celem, dato) Definir i Como Entero;
Para i=1 Hasta celem Hacer //Se recorre el vector para contar los alumnos que superan la edad promedio Si Vec[i] == dato Entonces Escribir 'Vendedor de la m nima venta: ', i; FinSi FinParaFinFuncion
////////////////////////////////////////////
Funcion cont <- ContarMayorA(Vec, celem, dato) Definir cont, i Como Entero;
Para i=1 Hasta celem Hacer //Se recorre el vector para contar los alumnos que superan la edad promedio Si Vec[i] > dato Entonces cont= cont+ 1; FinSi FinParaFinFuncion
////////////////////////////////////////////
Funcion MostrarPromVec(vec1, vec2, celem) Definir i Como Entero;
Para i=1 Hasta celem Hacer Si vec2[i] <> 0 Entonces Escribir ' ', i, ' ', vec1[i]/vec2[i]; SiNo Escribir ' ', i, ' SIN VENTAS'; FinSi FinParaFinFuncion
////////////////////////////////////////////
Funcion CargarVec(Vec, celem) Definir i Como Entero;
Para i=1 Hasta celem Hacer Escribir "Vendedor ",i,":",Sin Saltar; Leer Vec[i]; FinParaFinFuncion
////////////////////////////////////////////
Funcion dato <- IngrDatoValCar(car1, car2, car3, car4)
Definir dato Como Caracter; Repetir leer dato; dato=Mayusculas(dato); Hasta Que dato=car1 o dato=car2 o dato=car3 o dato=car4FinFuncion
////////////////////////////////////////////
Funcion prom <- Promedio(acum, cont) Definir prom Como Entero;
prom = trunc(acum / cont);FinFuncion
////////////////////////////////////////////
////////////////////////////////////////////
Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero;
i = 1; Mientras (vec[i] <> dato Y i <= celem) Hacer i = i+1; FinMientras Si i > celem Entonces pos= -1; SiNo pos = i; FinSiFinFuncion
////////////////////////////////////////////
Funcion MostrarVecParal(vec1, vec2, vec3, celem) Definir i Como Entero;
Para i=1 hasta celem Hacer Escribir ' ', vec1[i], ' ', vec2[i] , ' ', vec3[i]; FinParaFinFuncion
////////////////////////////////////////////
- Assistant
¡Perfecto! Trabajemos en integrar las funciones proporcionadas en el código del examen. Aquí tienes una revisión del ejemplo del examen con las funciones requeridas incorporadas:
Código Modificado del Examen
// Definición de funciones Funcion CargarVec(Vec, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Vendedor ",i,":",Sin Saltar; Leer Vec[i]; FinPara FinFuncion Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato > lim; FinFuncion Funcion dato <- IngrDatoValCar(car1, car2, car3, car4) Definir dato Como Caracter; Repetir leer dato; dato=Mayusculas(dato); Hasta Que dato=car1 o dato=car2 o dato=car3 o dato=car4 FinFuncion Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero; i = 1; Mientras (vec[i] <> dato Y i <= celem) Hacer i = i+1; FinMientras Si i > celem Entonces pos= -1; SiNo pos = i; FinSi FinFuncion Funcion MostrarPromVec(vec1, vec2, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Si vec2[i] <> 0 Entonces Escribir ' ', i, ' ', vec1[i]/vec2[i]; SiNo Escribir ' ', i, ' SIN VENTAS'; FinSi FinPara FinFuncion Funcion MostrarVecParal(vec1, vec2, vec3, celem) Definir i Como Entero; Para i=1 hasta celem Hacer Escribir ' ', vec1[i], ' ', vec2[i] , ' ', vec3[i]*0.05; FinPara FinFuncion Funcion s <- SumarVec(Vec, celem) Definir s, i Como Entero; s=0; Para i=1 Hasta celem Hacer s= s + Vec[i]; FinPara FinFuncion // Algoritmo principal Algoritmo PracticaParcial2_2024 Definir vVendedores, vend, tipo Como Caracter; Definir vCantVend, vCantFact, fact, cantV, pos, maxFact, contN, contC, contT, contO, TotV Como Entero; Definir vImpVend Como Real; Definir max Como Real; Definir HayVta Como Logico; Dimension vVendedores[10], vCantVend[10], vCantFact[10], vImpVend[10]; max=0; contN=0; contC=0; contT=0; contO=0; HayVta= Falso; Escribir 'Ingrese los nombres de los 10 vendedores'; CargarVec(vVendedores, 10); //Carga previa de nombres de vendedores Escribir 'Ingresar ventas...'; Escribir 'Ingrese nombre del vendedor - FINVENTAS para terminar'; Leer vend; Mientras vend <> 'FINVENTAS' Hacer HayVta= Verdadero; Escribir 'Ingrese el número de factura - mayor a cero'; fact=IngrDatoMayorA(0); Escribir 'Ingrese el tipo de libro vendido - N, C, T u O'; tipo=IngrDatoValCar('N', 'C', 'T', 'O'); Escribir 'Ingrese cantidad vendida - entre 1 y 20'; cantV=IngrDatoValido(1, 20); Escribir 'Ingrese el precio unitario- mayor a cero'; PUnit=IngrDatoMayorA(0); pos=Busqueda(vVendedores, 10, vend); si pos <> -1 Entonces vCantVend[pos]=vCantVend[pos] + cantV; //Carga de vectores vImpVend[pos]=vImpVend[pos] + (cantV*PUnit); vCantFact[pos]=vCantFact[pos] + 1; Si (cantV*PUnit) > max Entonces max= (cantV*PUnit); maxFact= fact; FinSi //Punto a --> Rutina del mayor Segun tipo Hacer 'N': contN= contN+1; 'C': contC= contC+1; 'T': contT= contT+1; De Otro Modo: contO= contO+1; FinSegun SiNo Escribir 'No existe el nombre del vendedor'; FinSi Escribir 'Ingrese nombre del vendedor - FINVENTAS para terminar'; Leer vend; FinMientras Si HayVta Entonces Escribir 'El número de factura que más vendió en importe es: ', maxFact; //Informar punto a Escribir 'VENDEDOR PROMEDIO DE VENTAS'; MostrarPromVec(vImpVend, vCantFact, 10); //punto b TotV=SumarVec(vCantVend, 10); Escribir 'Porcentaje de libros vendido tipo Novela: ', contN/TotV*100; //punto c Escribir 'Porcentaje de libros vendido tipo Comic: ', contC/TotV*100; Escribir 'Porcentaje de libros vendido tipo Texto: ', contT/TotV*100; Escribir 'Porcentaje de libros vendido tipo Otros: ', contO/TotV*100; Escribir 'VENDEDOR CANTIDAD VENDIDA IMPORTE VENDIDO COMISIÓN'; //punto d MostrarVecParal(vVendedores, vCantVend, vImpVend, 10); SiNo Escribir 'No hubo ventas'; FinSi FinAlgoritmoResumen de Cambios
- La función
IngrDatoMayorAyIngrDatoValidose han utilizado para validar la entrada de datos, en lugar de las funciones anteriores. - La función
MostrarVecParalse ha utilizado para presentar los datos finales de cada vendedor. - Reemplazada la lógica de cálculo con las funciones apropiadas según tus instrucciones.
Si necesitas más ayuda o hay cualquier otra función o requerimiento que deba integrarse, avísame. ¡Buena suerte!
- La función
- User
Teniendo en cuenta el perfil proporcionado, las funciones a utilizar, el ejemplo de examen.
Ayudame a realizar el siguiente ejercicio en PSeInt por favor:
Se desea estudiar el rendimiento de distintos modelos de autos en una prueba de resistencia. Para ello, se ingresa por teclado la siguiente información de cada uno de los 15 vehiculos que se van a estudiar (validar datos con FUNCION):
Los datos a ingresar son:
_Identificacion del auto (alfanumérico) _Año de construccion (entero, entre 2020 y 2024)
Luego se ingresan los kilometros acumulados en las distintas pruebas realizadas, ingresando por cada prueba lo siguiente:
Los datos a ingresar son:
_Identificacion del auto (alfanumérico) _Kilometros realizados en la prueba (real, mayor a cero)
- Assistant
¡Claro! Vamos a desarrollar el algoritmo en PSeInt para este problema basándonos en el perfil y las funciones proporcionadas. Usaremos las funciones para validar los datos de entrada según los requisitos especificados.
Algoritmo para el Estudio de Vehículos
// Definimos las funciones de validación y utilitarias a utilizar Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Real; Repetir Leer dato; Hasta Que dato > lim; FinFuncion Funcion CargarVecAutos(autos, anios, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer autos[i]; Escribir "Ingrese el año de construcción del auto ", i, " (entre 2020 y 2024):"; anios[i] = IngrDatoValido(2020, 2024); FinPara FinFuncion // Algoritmo principal Algoritmo EstudioResistenciaAutos Definir autos, autoActual Como Caracter; Definir anios, kmTotalPorAuto Como Entero; Definir kmPorPrueba Como Real; Dimension autos[15], anios[15], kmTotalPorAuto[15]; // Inicializar vector de kilometraje total por auto Para i=1 Hasta 15 Hacer kmTotalPorAuto[i] = 0; FinPara Escribir "Ingrese información de los 15 vehículos:"; CargarVecAutos(autos, anios, 15); // Cargar información inicial de los autos Escribir "Ingrese las pruebas realizadas (FINPRUEBAS para terminar):"; Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer autoActual; // Verificar fin de ingreso de pruebas Si autoActual == "FINPRUEBAS" Entonces Salir; FinSi Escribir "Ingrese los kilómetros realizados en la prueba (mayor a cero):"; kmPorPrueba = IngrDatoMayorA(0); // Busca la posición del auto actual en el vector de autos Definir pos Como Entero; pos = Busqueda(autos, 15, autoActual); // Sumar los kilómetros realizados a kmTotalPorAuto si el auto fue encontrado Si pos <> -1 Entonces kmTotalPorAuto[pos] = kmTotalPorAuto[pos] + kmPorPrueba; SiNo Escribir "Auto no encontrado."; FinSi Hasta Que Falso; // Mostrar resultados totales Escribir "Resultados Totales de Kilometraje por Auto:"; Para i=1 Hasta 15 Hacer Escribir "Auto: ", autos[i], " - Año: ", anios[i], " - Kilómetros Totales: ", kmTotalPorAuto[i]; FinPara FinAlgoritmoDescripción del Algoritmo
-
Estructura de Datos:
autos: vector para almacenar la identificación alfanumérica de cada auto.anios: vector para almacenar el año de construcción de cada auto.kmTotalPorAuto: vector para acumular los kilómetros totales realizados por cada auto en varias pruebas.
-
Carga de Datos Inicial:
- La función
CargarVecAutosse encarga de leer y validar los datos iniciales para los 15 autos.
- La función
-
Ingreso de Datos de Pruebas:
- Repetidamente ingresa la identificación del auto y los kilómetros de la prueba.
- Usa
Busquedapara encontrar el índice del auto actual y acumulando los kilómetros enkmTotalPorAuto.
-
Finalización y Resultados:
- Usa un ciclo
Parapara mostrar los kilómetros totales realizados por cada auto.
- Usa un ciclo
¡Espero que esta explicación te ayude a resolver tu tarea correctamente! Si tienes más preguntas o necesitas ajustes, házmelo saber.
-
- User
me salto el siguiente error:
"El identificador BUSQUEDA no corresponde a un arreglo o subproceso"
- Assistant
Vamos a corregir el error mencionando que falta definir o llamar correctamente la función
Busqueda. Parece que no se incluyó en el cuerpo del algoritmo, lo cual causó que el programa no reconociera la función.Te mostraré cómo incluir correctamente la función
Busquedaen el código para evitar ese error:// Definimos las funciones de validación y utilitarias a utilizar Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Real; Repetir Leer dato; Hasta Que dato > lim; FinFuncion Funcion CargarVecAutos(autos, anios, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer autos[i]; Escribir "Ingrese el año de construcción del auto ", i, " (entre 2020 y 2024):"; anios[i] = IngrDatoValido(2020, 2024); FinPara FinFuncion Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero; i = 1; Mientras (i <= celem Y vec[i] <> dato) Hacer i = i + 1; FinMientras Si i > celem Entonces pos = -1; // No encontrado SiNo pos = i; // Posición del elemento encontrado FinSi FinFuncion // Algoritmo principal Algoritmo EstudioResistenciaAutos Definir autos, autoActual Como Caracter; Definir anios Como Entero; Definir kmTotalPorAuto Como Entero; Definir kmPorPrueba Como Real; Dimension autos[15], anios[15], kmTotalPorAuto[15]; // Inicializar vector de kilometraje total por auto Para i=1 Hasta 15 Hacer kmTotalPorAuto[i] = 0; FinPara Escribir "Ingrese información de los 15 vehículos:"; CargarVecAutos(autos, anios, 15); // Cargar información inicial de los autos Escribir "Ingrese las pruebas realizadas (FINPRUEBAS para terminar):"; Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer autoActual; // Verificar fin de ingreso de pruebas Si autoActual == "FINPRUEBAS" Entonces Salir; FinSi Escribir "Ingrese los kilómetros realizados en la prueba (mayor a cero):"; kmPorPrueba = IngrDatoMayorA(0); // Busca la posición del auto actual en el vector de autos Definir pos Como Entero; pos = Busqueda(autos, 15, autoActual); // Sumar los kilómetros realizados a kmTotalPorAuto si el auto fue encontrado Si pos <> -1 Entonces kmTotalPorAuto[pos] = kmTotalPorAuto[pos] + kmPorPrueba; SiNo Escribir "Auto no encontrado."; FinSi Hasta Que Falso; // Mostrar resultados totales Escribir "Resultados Totales de Kilometraje por Auto:"; Para i=1 Hasta 15 Hacer Escribir "Auto: ", autos[i], " - Año: ", anios[i], " - Kilómetros Totales: ", kmTotalPorAuto[i]; FinPara FinAlgoritmoCambios Realizados
-
Función
Busqueda:- Definí la función
Busquedaque busca un valor en el vectorvecy devuelve la posición del dato. Si no lo encuentra, devuelve-1.
- Definí la función
-
Corrección en el Flujo Principal:
- Asegúrate de verificar antes de usar la función
Busquedaque los identificadores y las variables se definan correctamente.
- Asegúrate de verificar antes de usar la función
Este ajuste debería resolver el error que estabas observando y permitir que el algoritmo se ejecute correctamente. Si tienes más preguntas o necesitas más ayuda, házmelo saber.
-
- User
no falta inicializar las variables en ?
- Assistant
Tienes razón, es importante asegurarse de que las variables estén correctamente inicializadas antes de usarlas, especialmente cuando dependemos de valores acumulativos o necesitamos un estado inicial definido. Vamos a identificar las variables que deben ser inicializadas y ajustar el código:
Variables que Deben Inicializarse
-
Vectores:
kmTotalPorAuto: Se debe inicializar a cero para asegurarse de que las sumas comiencen desde cero.
-
Variables Generales:
pos: Es conveniente inicializar cualquier variable que calcule o almacene posiciones para evitar fluctuaciones por valores residuales en algunos lenguajes, incluso si en PSeInt el primer uso recalifica el tipo.
Aquí está la versión ajustada del algoritmo con la inicialización explícita de todas las variables necesarias:
// Definimos las funciones de validación y utilitarias a utilizar Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Real; Repetir Leer dato; Hasta Que dato > lim; FinFuncion Funcion CargarVecAutos(autos, anios, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer autos[i]; Escribir "Ingrese el año de construcción del auto ", i, " (entre 2020 y 2024):"; anios[i] = IngrDatoValido(2020, 2024); FinPara FinFuncion Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero; i = 1; Mientras (i <= celem Y vec[i] <> dato) Hacer i = i + 1; FinMientras Si i > celem Entonces pos = -1; // No encontrado SiNo pos = i; // Posición del elemento encontrado FinSi FinFuncion // Algoritmo principal Algoritmo EstudioResistenciaAutos //Inicializar todas las variables y vectores Definir autos Como Vector De Caracter De 15; Definir anios, kmTotalPorAuto Como Vector De Entero De 15; Definir autoActual Como Caracter; Definir kmPorPrueba Como Real; Definir pos, i Como Entero; Para i=1 Hasta 15 Hacer kmTotalPorAuto[i] = 0; FinPara Escribir "Ingrese información de los 15 vehículos:"; CargarVecAutos(autos, anios, 15); // Cargar información inicial de los autos Escribir "Ingrese las pruebas realizadas (FINPRUEBAS para terminar):"; Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer autoActual; // Verificar fin de ingreso de pruebas Si autoActual == "FINPRUEBAS" Entonces Salir; FinSi Escribir "Ingrese los kilómetros realizados en la prueba (mayor a cero):"; kmPorPrueba = IngrDatoMayorA(0); // Busca la posición del auto actual en el vector de autos pos = Busqueda(autos, 15, autoActual); // Sumar los kilómetros realizados a kmTotalPorAuto si el auto fue encontrado Si pos <> -1 Entonces kmTotalPorAuto[pos] = kmTotalPorAuto[pos] + kmPorPrueba; SiNo Escribir "Auto no encontrado."; FinSi Hasta Que Falso; // Mostrar resultados totales Escribir "Resultados Totales de Kilometraje por Auto:"; Para i=1 Hasta 15 Hacer Escribir "Auto: ", autos[i], " - Año: ", anios[i], " - Kilómetros Totales: ", kmTotalPorAuto[i]; FinPara FinAlgoritmoClaves del Algoritmo
- Inicialización de Vectores:
Los vectores
autos,aniosykmTotalPorAutose declaran claramente ykmTotalPorAutose inicializa a cero para evitar problemas de suma.
Esta configuración te asegurará que el algoritmo funcione sin errores debidos a la inicialización y conducción, garantizando así un comportamiento esperado y correcto de vista mejorada. Si tienes más dudas o necesitas más aclaraciones, ¡aquí estoy para ayudarte!
-
- User
me tira el error que la variable "i" no se encuentra definida
- Assistant
Entiendo, el error indica que la variable
ino está declarada antes de su uso en los bucles. Vamos a asegurarnos de declarar todas las variables, incluyendoi, antes de usarlas en el algoritmo.Aquí tienes el algoritmo corregido con una mejor organización de las declaraciones de variables:
// Definimos las funciones de validación y utilitarias a utilizar Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Real; Repetir Leer dato; Hasta Que dato > lim; FinFuncion Funcion CargarVecAutos(autos, anios, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer autos[i]; Escribir "Ingrese el año de construcción del auto ", i, " (entre 2020 y 2024):"; anios[i] = IngrDatoValido(2020, 2024); FinPara FinFuncion Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero; i = 1; Mientras (i <= celem Y vec[i] <> dato) Hacer i = i + 1; FinMientras Si i > celem Entonces pos = -1; // No encontrado SiNo pos = i; // Posición del elemento encontrado FinSi FinFuncion // Algoritmo principal Algoritmo EstudioResistenciaAutos // Declaración e inicialización de variables y vectores Definir autos Como Vector De Caracter De 15; Definir anios, kmTotalPorAuto Como Vector De Entero De 15; Definir autoActual Como Caracter; Definir kmPorPrueba Como Real; Definir pos, i Como Entero; // Inicializar el vector de kilometraje total por auto a cero Para i=1 Hasta 15 Hacer kmTotalPorAuto[i] = 0; FinPara Escribir "Ingrese información de los 15 vehículos:"; CargarVecAutos(autos, anios, 15); // Cargar información inicial de los autos Escribir "Ingrese las pruebas realizadas (FINPRUEBAS para terminar):"; Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer autoActual; // Verificar fin de ingreso de pruebas Si autoActual == "FINPRUEBAS" Entonces Salir; FinSi Escribir "Ingrese los kilómetros realizados en la prueba (mayor a cero):"; kmPorPrueba = IngrDatoMayorA(0); // Busca la posición del auto actual en el vector de autos pos = Busqueda(autos, 15, autoActual); // Sumar los kilómetros realizados a kmTotalPorAuto si el auto fue encontrado Si pos <> -1 Entonces kmTotalPorAuto[pos] = kmTotalPorAuto[pos] + kmPorPrueba; SiNo Escribir "Auto no encontrado."; FinSi Hasta Que Falso; // Mostrar resultados totales Escribir "Resultados Totales de Kilometraje por Auto:"; Para i=1 Hasta 15 Hacer Escribir "Auto: ", autos[i], " - Año: ", anios[i], " - Kilómetros Totales: ", kmTotalPorAuto[i]; FinPara FinAlgoritmoCorrecciones Aplicadas:
- La variable
ise declara al inicio del algoritmo principal y de cada función que la utiliza. - Todos los vectores y variables ahora son declarados al inicio del algoritmo para asegurar que estén disponibles donde corresponde.
Este ajuste debería eliminar el error relacionado con la no declaración previa de la variable
i. Si surge alguna otra duda o error, no dudes en decirme para seguir puliendo el algoritmo. ¡Estoy aquí para ayudarte! - La variable
- User
Por favor ajustame las funciones y las variables del siguiente codigo
"Funcion dato <- IngrDatoValido(limInf, limSup) Definir dato Como Entero; Repetir Leer dato; Hasta Que dato >= limInf Y dato <= limSup; FinFuncion
Funcion dato <- IngrDatoMayorA(lim) Definir dato Como Real; Repetir Leer dato; Hasta Que dato > lim; FinFuncion //************************************************************************************ Funcion CargarVecAutos(autos, anios, celem) Definir i Como Entero; Para i=1 Hasta celem Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer autos[i]; Escribir "Ingrese el año de construcción del auto ", i, " (entre 2020 y 2024):"; anios[i] = IngrDatoValido(2020, 2024); FinPara FinFuncion //************************************************************************************ Funcion pos <- Busqueda(vec, celem, dato) Definir pos, i Como Entero;
i = 1; Mientras (i <= celem Y vec[i] <> dato) Hacer i = i + 1; FinMientras Si i > celem Entonces pos = -1; // No encontrado SiNo pos = i; // Posición del elemento encontrado FinSiFinFuncion //************************************************************************************
// Algoritmo principal Algoritmo Parcial_2_2024 Definir autos, autoActual Como Caracter; Definir anios Como Entero; Definir kmTotalPorAuto Como Entero; Definir kmPorPrueba Como Real; Definir continuar Como Logico; Definir i como entero; Dimension autos[2], anios[2], kmTotalPorAuto[2];
// Validacion de datos, inicio del km en 0 continuar <- Verdadero; Para i=1 Hasta 2 Hacer kmTotalPorAuto[i] = 0; FinPara Escribir "Ingrese información de los 15 vehículos:"; CargarVecAutos(autos, anios, 15); // Cargar información inicial de los autos Escribir "Ingrese las pruebas realizadas (FINPRUEBAS para terminar):"; Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer autoActual; // Verificar fin de ingreso de pruebas Si autoActual == "FINPRUEBAS" Entonces continuar <- falso; FinSi Escribir "Ingrese los kilómetros realizados en la prueba (mayor a cero):"; kmPorPrueba = IngrDatoMayorA(0); // Busca la posición del auto actual en el vector de autos Definir pos Como Entero; pos = Busqueda(autos, 2, autoActual); // Sumar los kilómetros realizados a kmTotalPorAuto si el auto fue encontrado Si pos <> -1 Entonces kmTotalPorAuto[pos] = kmTotalPorAuto[pos] + kmPorPrueba; SiNo Escribir "Auto no encontrado."; FinSi Hasta Que Falso; // Mostrar resultados totales Escribir "Resultados Totales de Kilometraje por Auto:"; Para i=1 Hasta 2 Hacer Escribir "Auto: ", autos[i], " - Año: ", anios[i], " - Kilómetros Totales: ", kmTotalPorAuto[i]; FinParaFinAlgoritmo"
A este:
"Funcion validad(idem_auto, año_auto, cant_pruebas, km_auto, i) Para i=1 Hasta 2 Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer idem_auto[i];
Repetir Escribir "Ingrese año del auto (2020-2024):"; Leer año_auto[i]; Hasta Que 2020 <= año_auto[i] Y año_auto[i] <= 2024 cant_pruebas[i] = 0; km_auto[i] = 0; FinParaFinFuncion
Funcion prom(cant_pruebas, km_auto, i, prom_km) Para i=1 Hasta 2 Hacer Si cant_pruebas[i] <> 0 Entonces prom_km = km_auto[i] / cant_pruebas[i]; Sino prom_km = 0; FinSi Escribir "El promedio de kilómetros del auto ", i, " es de ", prom_km; FinPara FinFuncion
Funcion maxrec(km_auto, idem_auto, año_auto, i, max_km) max_km = km_auto[1]; Para i=2 Hasta 2 Hacer Si km_auto[i] > max_km Entonces max_km = km_auto[i]; FinSi FinPara
Para i=1 Hasta 2 Hacer Si max_km = km_auto[i] Entonces Escribir "La identificación del auto con mayor kilometraje es ", idem_auto[i], " y su año de fabricación es ", año_auto[i]; FinSi FinParaFinFuncion
Funcion recorrido(km_auto, i) Definir contador Como Entero; contador = 0;
Para i=1 Hasta 2 Hacer Si km_auto[i] > 1000 Entonces contador = contador + 1; FinSi FinPara Escribir "Cantidad de autos con más de 1000 km: ", contador;FinFuncion
Algoritmo parcial Definir idem_auto, iden, finprueba Como Caracter; Definir año_auto, i, cant_pruebas Como Entero; Definir km, km_auto, prom_km, max_km Como Real; Dimension idem_auto[2]; Dimension año_auto[2]; Dimension km_auto[2]; Dimension cant_pruebas[2];
validad(idem_auto, año_auto, cant_pruebas, km_auto, i); Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer iden; Si iden <> "FINPRUEBAS" Entonces Para i=1 Hasta 2 Hacer Si iden = idem_auto[i] Entonces cant_pruebas[i] = cant_pruebas[i] + 1; Escribir "Ingrese la cantidad de kilómetros realizados en la prueba:"; Leer km; km_auto[i] = km_auto[i] + km; FinSi FinPara FinSi Hasta Que iden = "FINPRUEBAS" prom(cant_pruebas, km_auto, i, prom_km); maxrec(km_auto, idem_auto, año_auto, i, max_km); recorrido(km_auto, i);FinAlgoritmo "
- Assistant
Vamos a realizar los ajustes en el código que proporcionaste para que funcione correctamente según la descripción del problema. El código reformulado incluirá todas las funciones necesarias y usará las variables adecuadas para lograr el resultado esperado.
Aquí tienes el código corregido:
// Declaración de funciones Funcion validad(idem_auto, año_auto, cant_pruebas, km_auto) Definir i Como Entero; Para i=1 Hasta 2 Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer idem_auto[i]; Repetir Escribir "Ingrese año del auto (2020-2024):"; Leer año_auto[i]; Hasta Que 2020 <= año_auto[i] Y año_auto[i] <= 2024 cant_pruebas[i] = 0; km_auto[i] = 0; FinPara FinFuncion Funcion prom(cant_pruebas, km_auto) Definir i Como Entero; Definir prom_km Como Real; Para i=1 Hasta 2 Hacer Si cant_pruebas[i] <> 0 Entonces prom_km = km_auto[i] / cant_pruebas[i]; Sino prom_km = 0; FinSi Escribir "El promedio de kilómetros del auto ", i, " es de ", prom_km; FinPara FinFuncion Funcion maxrec(km_auto, idem_auto, año_auto) Definir i Como Entero; Definir max_km Como Real; max_km = km_auto[1]; Para i=2 Hasta 2 Hacer Si km_auto[i] > max_km Entonces max_km = km_auto[i]; FinSi FinPara Para i=1 Hasta 2 Hacer Si max_km = km_auto[i] Entonces Escribir "La identificación del auto con mayor kilometraje es ", idem_auto[i], " y su año de fabricación es ", año_auto[i]; FinSi FinPara FinFuncion Funcion recorrido(km_auto) Definir i, contador Como Entero; contador = 0; Para i=1 Hasta 2 Hacer Si km_auto[i] > 1000 Entonces contador = contador + 1; FinSi FinPara Escribir "Cantidad de autos con más de 1000 km: ", contador; FinFuncion // Algoritmo principal Algoritmo parcial Definir idem_auto, iden Como Vector De Caracter De 2; Definir año_auto Como Vector De Entero De 2; Definir km_auto Como Vector De Real De 2; Definir cant_pruebas Como Vector De Entero De 2; // Inicialización y validación de datos validad(idem_auto, año_auto, cant_pruebas, km_auto); // Proceso de ingreso de pruebas Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer iden; Si iden <> "FINPRUEBAS" Entonces Para i=1 Hasta 2 Hacer Si iden = idem_auto[i] Entonces cant_pruebas[i] = cant_pruebas[i] + 1; Escribir "Ingrese la cantidad de kilómetros realizados en la prueba:"; Leer km; km_auto[i] = km_auto[i] + km; FinSi FinPara FinSi Hasta Que iden = "FINPRUEBAS"; // Cálculo y visualización de resultados prom(cant_pruebas, km_auto); maxrec(km_auto, idem_auto, año_auto); recorrido(km_auto); FinAlgoritmoDetalles de la Implementación
-
Funciones:
- Todas las funciones fueron modificadas para no necesitar la variable
icomo parámetro; se declara localmente dentro de cada función.
- Todas las funciones fueron modificadas para no necesitar la variable
-
Algoritmo Principal:
- Se inicializan correctamente los vectores para
idem_auto,año_auto,km_auto, ycant_pruebas. - La lógica de entrada y procesamiento de los datos de prueba se ha mantenido y adaptado al nuevo diseño.
- Se inicializan correctamente los vectores para
-
Nota sobre Lógicos:
- En el contexto proporcionado no es necesaria una variable lógica
continuar, ya que el cicloRepetirexamina directamente en su condición de salida.
- En el contexto proporcionado no es necesaria una variable lógica
Este código asegura que todos los parámetros y variables estén correctamente definidos y declara variables a nivel local donde sea necesario para evitar problemas de identificación y errores de ejecución. Si hay más dudas, estaré encantado de ayudarte más.
-
- User
Por favor, en base a las indicaciones que te di anteriormente. Mejorame el siguiente codigo:
"Funcion validad(idem_auto,año_auto,cant_pruebas,km_auto,i) para i=1 hasta 15 Hacer Escribir "ingrese identificacion del auto"; leer idem_auto[i]; Repetir Escribir "año del auto"; Leer año_auto[i]; Hasta Que 2020<=año_auto[i] y año_auto[i]<=2024 cant_pruebas[i]=0; km_auto[i]=0; FinPara FinFuncion
Funcion prom (cant_pruebas,km_auto,i,prom_km) para i=1 Hasta 15 Hacer si cant_pruebas[i]<>0 Entonces prom_km=km_auto[i]/cant_pruebas[i]; sino prom_km=0; FinSi Escribir "el promedio de kilometros del auto ",i," es de ",prom_km; FinPara FinFuncion
Funcion maxrec(km_auto,idem_auto,año_auto,i,max_km) para i=1 Hasta 14 Hacer si km_auto[i]>km_auto[i+1] Entonces max_km=km_auto[i]; SiNo max_km=km_auto[i+1]; FinSi FinPara
Para i=1 Hasta 15 Hacer si max_km=km_auto[i] Entonces Escribir "la identificacion del auto con mayor kilometros es ",idem_auto[i]," y su año de fabricacion es ",año_auto[i]; FinSi FinParaFinFuncion
Funcion recorrido(km_auto,i) Para i=1 Hasta 15 Hacer si km_auto[i]>1000 Entonces contador=contador+1; FinSi FinPara FinFuncion
Algoritmo parcial Definir idem_auto,iden,finprueba Como Caracter; Definir año_auto,i,cant_pruebas Como Entero; Definir km,km_auto,prom_km,max_km Como Real; Dimension idem_auto[15]; Dimension año_auto[15]; Dimension km_auto[15]; Dimension cant_pruebas[100];
validad(idem_auto,año_auto,cant_pruebas,km_auto,i); Repetir Escribir "ingrese la identificacion del auto"; Leer iden; si iden<>"finprueba" Entonces para i=1 Hasta 15 Hacer si iden=idem_auto[i] Entonces cant_pruebas[i]=cant_pruebas[i]+1; Escribir "ingrese la cantidad de kilometros"; Leer km; km_auto[i]=km_auto[i]+km; FinSi FinPara FinSi Hasta Que iden="finprueba" prom(cant_pruebas,km_auto,i,prom_km); maxrec(km_auto,idem_auto,año_auto,i,max_km); recorrido(km_auto,i);FinAlgoritmo "
- Assistant
Vamos a mejorar el código proporcionado, corrigiendo errores y optimizándolo según las indicaciones que has dado. Nos aseguraremos de gestionar correctamente los vectores y evitar problemas de variables no inicializadas.
Mejora del Código
- Eliminar el uso innecesario de parámetros: Las funciones no necesitan que
ise pase como parámetro. Se debe declarar dentro de cada función. - Consistencia en la inicialización de vectores: Asegurarse de que las dimensiones de los vectores estén correctamente definidas y utilizadas a lo largo del programa.
Aquí está el código mejorado:
// Funciones definidas para el problema Funcion validad(idem_auto, año_auto, cant_pruebas, km_auto) Definir i Como Entero; Para i = 1 Hasta 15 Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer idem_auto[i]; Repetir Escribir "Ingrese año del auto (2020-2024):"; Leer año_auto[i]; Hasta Que 2020 <= año_auto[i] Y año_auto[i] <= 2024 cant_pruebas[i] = 0; km_auto[i] = 0; FinPara FinFuncion Funcion prom(cant_pruebas, km_auto) Definir i Como Entero; Definir prom_km Como Real; Para i = 1 Hasta 15 Hacer Si cant_pruebas[i] <> 0 Entonces prom_km = km_auto[i] / cant_pruebas[i]; SiNo prom_km = 0; FinSi Escribir "El promedio de kilómetros del auto ", i, " es de ", prom_km; FinPara FinFuncion Funcion maxrec(km_auto, idem_auto, año_auto) Definir i, max_index Como Entero; Definir max_km Como Real; max_km = km_auto[1]; max_index = 1; Para i = 2 Hasta 15 Hacer Si km_auto[i] > max_km Entonces max_km = km_auto[i]; max_index = i; FinSi FinPara Escribir "La identificación del auto con mayor kilometraje es ", idem_auto[max_index], " y su año de fabricación es ", año_auto[max_index]; FinFuncion Funcion recorrido(km_auto) Definir i, contador Como Entero; contador = 0; Para i = 1 Hasta 15 Hacer Si km_auto[i] > 1000 Entonces contador = contador + 1; FinSi FinPara Escribir "Cantidad de autos con más de 1000 km: ", contador; FinFuncion // Algoritmo principal Algoritmo parcial Definir idem_auto, iden Como Vector De Caracter De 15; Definir año_auto, cant_pruebas Como Vector De Entero De 15; Definir km_auto Como Vector De Real De 15; Definir km Como Real; validad(idem_auto, año_auto, cant_pruebas, km_auto); Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer iden; Si iden <> "FINPRUEBAS" Entonces Para i = 1 Hasta 15 Hacer Si iden = idem_auto[i] Entonces cant_pruebas[i] = cant_pruebas[i] + 1; Escribir "Ingrese la cantidad de kilómetros realizados en la prueba:"; Leer km; km_auto[i] = km_auto[i] + km; FinSi FinPara FinSi Hasta Que iden = "FINPRUEBAS"; prom(cant_pruebas, km_auto); maxrec(km_auto, idem_auto, año_auto); recorrido(km_auto); FinAlgoritmoCambios Realizados:
- Inicialización de Vectores: Se corrigió la dimensión de
cant_pruebaspara que sea consistente con los demás vectores. - Uso de Parámetros: Se eliminó
icomo parámetro de las funciones, usándolo como variable local. - Refinamiento de Funciones:
maxrec: Se optó por guardar el índice del valor máximo para simplificar el código.recorrido: Se inicializócontadoral inicio de la función.
Este código debería ser más claro y eficiente, además de corregir los errores previos. Si necesitas más refinamientos o tienes más dudas, ¡estaré encantado de ayudarte!
- Eliminar el uso innecesario de parámetros: Las funciones no necesitan que
- User
Recuerda que el numero de dimension de las arrays las debes definir despues
- Assistant
Entiendo, quieres que las dimensiones de los arreglos se especifiquen después de declararlos. Vamos a ajustar el código para que las dimensiones se definan correctamente justo después de declarar los vectores.
Aquí tienes el código modificado:
// Funciones definidas para el problema Funcion validad(idem_auto, año_auto, cant_pruebas, km_auto) Definir i Como Entero; Para i = 1 Hasta 15 Hacer Escribir "Ingrese identificación del auto ", i, ":"; Leer idem_auto[i]; Repetir Escribir "Ingrese año del auto (2020-2024):"; Leer año_auto[i]; Hasta Que 2020 <= año_auto[i] Y año_auto[i] <= 2024 cant_pruebas[i] = 0; km_auto[i] = 0; FinPara FinFuncion Funcion prom(cant_pruebas, km_auto) Definir i Como Entero; Definir prom_km Como Real; Para i = 1 Hasta 15 Hacer Si cant_pruebas[i] <> 0 Entonces prom_km = km_auto[i] / cant_pruebas[i]; SiNo prom_km = 0; FinSi Escribir "El promedio de kilómetros del auto ", i, " es de ", prom_km; FinPara FinFuncion Funcion maxrec(km_auto, idem_auto, año_auto) Definir i, max_index Como Entero; Definir max_km Como Real; max_km = km_auto[1]; max_index = 1; Para i = 2 Hasta 15 Hacer Si km_auto[i] > max_km Entonces max_km = km_auto[i]; max_index = i; FinSi FinPara Escribir "La identificación del auto con mayor kilometraje es ", idem_auto[max_index], " y su año de fabricación es ", año_auto[max_index]; FinFuncion Funcion recorrido(km_auto) Definir i, contador Como Entero; contador = 0; Para i = 1 Hasta 15 Hacer Si km_auto[i] > 1000 Entonces contador = contador + 1; FinSi FinPara Escribir "Cantidad de autos con más de 1000 km: ", contador; FinFuncion // Algoritmo principal Algoritmo parcial Definir idem_auto, iden Como Vector De Caracter; Definir año_auto, cant_pruebas Como Vector De Entero; Definir km_auto Como Vector De Real; Definir km Como Real; Dimension idem_auto[15]; Dimension año_auto[15]; Dimension km_auto[15]; Dimension cant_pruebas[15]; validad(idem_auto, año_auto, cant_pruebas, km_auto); Repetir Escribir "Ingrese la identificación del auto (FINPRUEBAS para terminar):"; Leer iden; Si iden <> "FINPRUEBAS" Entonces Para i = 1 Hasta 15 Hacer Si iden = idem_auto[i] Entonces cant_pruebas[i] = cant_pruebas[i] + 1; Escribir "Ingrese la cantidad de kilómetros realizados en la prueba:"; Leer km; km_auto[i] = km_auto[i] + km; FinSi FinPara FinSi Hasta Que iden = "FINPRUEBAS"; prom(cant_pruebas, km_auto); maxrec(km_auto, idem_auto, año_auto); recorrido(km_auto); FinAlgoritmoAjustes Realizados:
- Estructura de Declaración y Dimensión: Se ha definido la estructura de las dimensiones justo después de la declaración de los vectores para cumplir con las reglas de declaración en PSeInt.
Estos cambios aseguran que el código esté más ordenado y siga las mejores prácticas de PSeInt, facilitando la lectura y el mantenimiento del código. Si hay algo más que te gustaría ajustar, házmelo saber.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.