UTN – FRM – Ing.

en Sistemas de Información
Algoritmos y Estructuras de Datos
Ciclo lectivo 2020- Trabajos Prácticos
Clase N°7- UT5- Página 1 de 4

CLASE Nº 7 : Resolución de problemas con variables dimensionadas

Tema: ARREGLOS (UT5)

OBJETIVO: Que los alumnos construyan pseudocódigos a partir de las nociones de arreglos de una y dos
dimensiones; aprendiendo a manipular los elementos del mismo.

Recordemos
PASOS PARA LA RESOLUCIÓN DE UN PROBLEMA:
I- Delimitación del problema: aspectos que acotan el problema o determinan las condiciones del contexto que lo
delimitan. Explicación breve de lo que el grupo ha entendido sobre lo que debe hacer el algoritmo.

 Elaborado por Susana Oviedo, Adriana José y Eugenia Alfonso 

II- Análisis del problema:
Entradas: todo aquello que se necesita exista o esté disponible (elementos físicos o información), considerándose
indispensable para hallar por lo menos una solución.
Proceso: pasos necesarios para que, a partir de las entradas, se obtengan las salidas deseadas.
Salidas: resultado/s esperado/s que debe proveer la solución.

III- Diseño del Algoritmo: desarrollar en pseudocódigo el algoritmo que resuelve el enunciado, incluyendo
comentarios que indiquen los momentos: ingreso de datos, proceso, salida o mostrar resultados.

IV- Prueba: se simula el funcionamiento del algoritmo con datos propios para validar la correcta operación del
algoritmo. Elija un conjunto de valores para los datos de entrada del algoritmo realizado en pseudocódigo, y
realice la prueba de escritorio para corroborar si dicho algoritmo es una solución al problema planteado

V-Codificación: codificar el algoritmo en programa, o sea convertir las acciones del algoritmo en instrucciones de
algún lenguaje de programación, como por ej. C

VI-Implantación del programa: Una vez correcto el programa, se instala y se pone a funcionar, entrando en
operación o producción.

Consigna 1: EJERCICIO
Se desea saber el piloto ganador de una carrera en la cual hay 15 pilotos, sus posiciones y puntos está dada por el
tiempo que utilice en la carrera, más los tiempos adicionales por infracciones.

Pilotos Delimitación del problema:

Debo ingresar los nombres de los pilotos que participan en la carrera?
1 Hamilton
2 Verstappen R: Si, debo ingresarle todos los nombres de los pilotos.
3 Vettel Tengo los tiempos de cada piloto? R:SI de la primera carrera
4 Leclerc Tengo el tiempo penalizado de cada piloto? R:SI de la primera carrera
5 Sainz Análisis del problema:
6 Gasly ENTRADA:
7 Raikkonen Pilotos[15]: CADENA
8 Bottas Nombre de los Pilotos, es una variable dimensionada para poder cargar los nombres de
9 Norris los 15 pilotos.
10 Ricciardo Tiempos[15,3]:ENTERO
11 Russell
Tiempo en segundos utilizados por piloto en la primera carrera.
12 Albon
PROCESO:
13 Perez
Debemos ingresar los nombres de los pilotos e ir guardándolos en cada posición de
14 Hulkenberg
15 Magnussen nuestra variable dimensionada Pilotos.
Cargar por piloto los tiempos utilizados y los tiempos penalizados, calcular el tiempo total
como la suma de los tiempos anteriores.
SALIDA:
Mostrar el piloto que utilizó el menor tiempo, o sea ganó la carrera.
 UTN – FRM – Ing. en Sistemas de Información
Algoritmos y Estructuras de Datos
Ciclo lectivo 2020- Trabajos Prácticos
Clase N°7- UT5- Página 2 de 4

Segundos Segundos Total

Penalizados Segundos
Tiempos (Por carrera, por piloto se
registran los tiempos ocupados y
penalizados, en segundos. Se deja una
columna para calcular la suma de ambos
tiempos )

 Elaborado por Susana Oviedo, Adriana José y Eugenia Alfonso 

Diseño del algoritmo en PSEUDOCODIGO

PROGRAMA Carrera
//Subprogramas

PROCEDIMIENTO CargarPilotos (PorRef. Pilotos[15]:CADENA)

VAR I:ENTERO
//Uso de estructura repetitiva para posicionarse en cada campo de la variable dimensionada
VARIAR I DESDE 1 HASTA 15 //Ingreso el nombre de cada piloto
REPETIR
ESCRIBIR(“Ingrese nombre del piloto nro.“, I)
LEER(Pilotos[I])
HASTA QUE (Longitud(Pilotos[I])>0)
FINVARIAR
FINPROCEDIMIENTO

PROCEDIMIENTO CargoTiempos (Pilotos [15], Por.Ref. Tiempos[15,3]:ENTERO)

VAR pil: ENTERO
//Utilizo una estructura repetitiva para recorrer la variable dimensionada
VARIAR pil DESDE 1 HASTA 15
ESCRIBIR (“Ingrese los segundos utilizados del piloto nro.”, pil)
REPETIR
LEER(Tiempos[pil,1])
HASTA QUE (Tiempos[pil,1]>0)
ESCRIBIR (“Ingrese los segundos penalizados del piloto nro.”, pil)
REPETIR
LEER(Tiempos[pil,2])
HASTA QUE (Tiempos[pil,2]>0)
Tiempos[pil,3]=Tiempos[pil,1]+Tiempos[pil,2]
FIN VARIAR
FINPROCEDIMIENTO

PROCEDIMIENTO Ganador(Pilotos[15]:CADENA, Tiempos[15,3]: ENTERO)

VAR MenorT, MenorInd, Ind: ENTERO
//Utilizo una estructura repetitiva para recorrer la variable dimensionada y buscar el menor tiempo
MenorT=Tiempos[1,3])
MenorInd=1
VARIAR Ind DESDE 2 HASTA 15
SI (Tiempos[Ind,3]) Tiempos[Ind,3])<MenorT) ENTONCES
MenorT= Tiempos[Ind,3])
MenorInd=Ind
UTN – FRM – Ing. en Sistemas de Información
Algoritmos y Estructuras de Datos
Ciclo lectivo 2020- Trabajos Prácticos
Clase N°7- UT5- Página 3 de 4

FIN SI
FIN VARIAR
ESCRIBIR(”El piloto ganador es: “,Pilotos [MenorInd])
FINPROCEDIMIENTO

//PROGRAMA PRINCIPAL
VAR Pilotos[15]:CADENA, Tiempos[15,3]:ENTERO
INICIO
//Llamada a procedimientos para realizar la carga de los datos
CargarPilotos(Pilotos[ ])
CargarTiempos(Pilotos[ ],Tiempos[ , ])
//Busco y Muestro al piloto ganador

 Elaborado por Susana Oviedo, Adriana José y Eugenia Alfonso 

Ganador(Pilotos[ ], Tiempos[ , ])
FINPROGRAMA
-------------------------------------------------------------------------------------------------------------------------------------------------

CODIFICACIÓN

#include <iostream>
#include <string>
using namespace std;

void CargarPilotos(string Pilotos[15]) {

int Ind;
// Utilizo una estructura repetitiva para recorrer la variable dimensionada
for (Ind=0;Ind<=14;Ind++){
do {
cout<<"Ingrese nombre del Piloto n°: "<<Ind+1<<": ";
cin>>Pilotos[Ind];
} while (Pilotos[Ind]==" ");
}
}

void CargarTiempos (string Pilotos [15], int Tiempos[15][3]){

int pil;
cout<<system("cls")<<endl;
//Utilizo una estructura repetitiva para recorrer la variable dimensionada
for(pil=0;pil<=14;pil++){
cout<<"Ingrese los segundos utilizados del piloto nro."<<pil+1<<": ";
do {
cin>>Tiempos[pil][0];
}while (Tiempos[pil][0]<=0) ;
cout<<"Ingrese los segundos penalizados del piloto nro."<<pil+1<<": ";
do {
cin>>Tiempos[pil][1];
} while (Tiempos[pil][1]<0);
Tiempos[pil][2]=Tiempos[pil][0]+Tiempos[pil][1];
}
}

Void Ganador(string Pilotos[15], int Tiempos[15][3]) {

Int MenorT, MenorInd, Ind;
MenorT= Tiempos[1][3];
MenorInd=1;
cout<<system("cls")<<endl;
for (Ind=0;Ind<=14;Ind++){
if (Tiempos [Ind][3]<MenorT){
MenorT= Tiempos [Ind][3];
MenorInd=Ind;
}
}
cout<<”El piloto ganador es: “<<Pilotos [MenorInd])<<endl;
cout<<endl;

}
UTN – FRM – Ing. en Sistemas de Información
Algoritmos y Estructuras de Datos
Ciclo lectivo 2020- Trabajos Prácticos
Clase N°7- UT5- Página 4 de 4

//PROGRAMA PRINCIPAL
int main(int argc, char *argv[]) {
string Pilotos[15]; int Tiempos[15][3];
//llamada a procedimiento para realizar la carga de los datos
cout<<"***************************************************************"<<endl;
cout<<" CARRERA”<<endl;
cout<<"***************************************************************"<<endl;
CargarPilotos(Pilotos);
CargarTiempos(Pilotos, Tiempos);
//muestro resultados
Ganador(Pilotos,Tiempos);
cout<<endl;

return 0;

 Elaborado por Susana Oviedo, Adriana José y Eugenia Alfonso 

}

Consigna 2: Completar lo desarrollado en la Consigna 1; con los subprogramas en pseudocódigo:

1- Realice un ejemplo de datos, de los tiempos de la carrera.
2- Modifique el subprograma de carga de Pilotos validando los datos de entrada para que no se ingrese más
de una vez cada piloto.
3- De que otra forma se puede obtener el ganador? Modifique el subprograma Ganador, utilizando esta otra
forma.
4- Desarrolle un subprograma que informe el porcentaje de pilotos que tuvieron puntos penalizados y los que
no.

 Consigna 3: Responda:
1- ¿Dónde está determinado el tamaño de una variable dimensionada? ¿Ese tamaño se mantiene fijo
durante toda la ejecución del programa?
2- Mencionen las consideraciones que debemos tener en cuenta al usar el subíndice de una variable
dimensionada. Ejemplificar.
3- ¿Se podrían cambiar las estructuras repetitivas por otras, para recorrer la variable dimensionada o
arreglo? ¿Por cuáles? ¿Cómo?

 Consigna 4: A modo de repaso y para afianzar los conocimientos adquiridos durante esta clase, Ud. debe
RENDIR los contenidos Prácticos de la CLASE 7 ( Tarea en casa Nro. 7) en el aula virtual de la cátedra en
forma individual.

 Consigna 5: Para poder realizar la ejercitación la próxima clase es necesario que conozca los siguientes

contenidos: arreglos multidimensionales, definición, subíndice, operaciones. Para acreditar estos conocimientos,
Ud. debe RENDIR los contenidos de Teoría CLASE 8 ( Cuestionario Nro. 8) en la plataforma de la cátedra en
forma individual.