Ejercicios de

Aplicación

Programación
Lógica

1
1. Ejercicios de aplicación
1) Implementar un algoritmo que permita cargar números en una matriz de
3 filas y 4 columnas. La suma de los valores de cada fila se debe almacenar
en un arreglo unidimensional denominado fila y la suma de los valores de
cada columna se debe almacenar en un arreglo unidimensional
denominado columna. El algoritmo debe mostrar el contenido de los
arreglos unidimensionales.

algoritmo matriz_suma_filas_columnas
tipo
array[1...3][1…4] de real: matriz
array[1...3] de real: vector_3
array[1...4] de real: vector_4
var
entero: i, j
real: sumaFilas, sumaColumnas
matriz: datos
vector_3: filas
vector_4: columnas
inicio
mostrar("Carga de matriz...")
mostrar("")
para i  1 hasta 3 hacer
para j  1 hasta 4 hacer
mostrar("Ingrese un número para la posición [",i,",",j,"]")
leer(datos[i,j])
fin-para
mostrar("")
fin-para

// Suma de los valores por cada fila

para i  1 hasta 3 hacer
sumaFilas  0
para j  1 hasta 4 hacer
sumaFilas  sumaFilas + datos[i,j]
fin-para
filas[i]  sumaFilas
fin-para

// Suma de los valores por cada columna

para j  1 hasta 4 hacer
sumaColumnas  0
para i  1 hasta 3 hacer
sumaColumnas  sumaColumnas + datos[i,j]
fin-para
columnas[j]  sumaColumnas
fin-para

// Mostrar arreglo con la suma de cada fila

2
 mostrar("Contenido arreglo con suma de cada fila")
para i  1 hasta 3 hacer
mostrar Sin Saltar (" ", filas[i])
fin-para

mostrar("")

// Mostrar arreglo con la suma de cada columna

mostrar("Contenido arreglo con suma de cada columna")
para j  1 hasta 4 hacer
mostrar Sin Saltar (" ", columnas[j])
fin-para
fin

2) Implementar un algoritmo que permita cargar una matriz de 4 filas y 4

columnas de números enteros. El algoritmo debe guardar los elementos de
la diagonal principal en un arreglo unidimensional y mostrar su contenido.

algoritmo matriz_diagonal_principal
tipo
array[1...4][1…4] de real: matriz
array[1...4] de real: vector_4
var
entero: i, j
matriz: datos
vector_4: diagonal
inicio
mostrar("Carga de matriz...")
mostrar("")
para i  1 hasta 4 hacer
para j  1 hasta 4 hacer
mostrar("Ingrese un número para la posición [",i,",",j,"]")
leer(datos[i,j])
fin-para
mostrar("")
fin-para

// Guardando elementos de la diagonal principal en otro arreglo unidimensional

para i  1 hasta 4 hacer
diagonal[i]  datos[i,i]
fin-para

mostrar("Contenido arreglo con elementos de la diagonal principal")

para i  1 hasta 4 hacer
mostrar Sin Saltar (" ", diagonal[i])
fin-para
fin

3) Implementar un algoritmo que permita cargar N valores de

temperaturas en un arreglo. El algoritmo debe guardar en otro arreglo las

3
temperaturas que superen el promedio. Mostrar el contenido de ambos
arreglos.

algoritmo arreglo_temperaturas_copiar
tipo
array[1...50] de real: arreglo
var
entero: i, indice_destino, N
real: suma, promedio
arreglo: origen, destino
inicio
repetir
mostrar("Ingrese la cantidad de temperaturas que va cargar (menor a 50)")
leer(N)
hasta-que N > 0 y N < 50

mostrar("Ingrese los valores de ", N, " temperaturas")

para i  1 hasta N hacer
leer(origen[i])
fin-para

suma  0
para i  1 hasta N hacer
suma  suma + origen[i]
fin-para
promedio  suma/N
mostrar("")
mostrar("El promedio de las temperaturas ingresadas es ", promedio)

mostrar("")
mostrar("Copiando temperaturas que superan el promedio en nuevo arreglo destino...")
indice_destino  0
para i  1 hasta N hacer
si (origen[i] > promedio) entonces
indice_destino  indice_destino + 1
destino[indice_destino]  origen[i]
fin-si
fin-para

mostrar("")
mostrar("Mostrando arreglo con temperaturas de origen...")
para i  1 hasta N hacer
mostrar(origen[i])
fin-para

mostrar("")
mostrar("Mostrando arreglo con temperaturas que superan el promedio...")
para i  1 hasta indice_destino hacer
mostrar(destino[i])
fin-para
fin

4
4) Implementar un algoritmo que permita cargar N valores de nombres en
un arreglo. El algoritmo debe permitir al usuario ingresar un nombre para
buscarlo en el listado.

algoritmo arreglo_nombres
tipo
array[1...50] de real: arreglo
var
entero: i, N
cadena: nombreBuscar
logico: bandera
arreglo: nombres
inicio
repetir
mostrar("Ingrese la cantidad de nombres que va cargar (menor a 50)")
leer(N)
hasta-que N > 0 y N < 50

mostrar("")
mostrar("Ingrese ", N, " nombres para cargar el arreglo...")
para i  1 hasta N hacer
leer(nombres[i])
fin-para

repetir
mostrar("")
mostrar("Ingrese el nombre que desea buscar. Si desea finalizar ingrese salir")
leer(nombreBuscar)
nombreBuscar  Minusculas(nombreBuscar)

bandera  falso
si nombreBuscar != "salir" entonces
para i  1 hasta N hacer
si nombres[i] == nombreBuscar entonces
bandera  verdadero
fin-si
fin-para

si bandera entonces
mostrar("El nombre ", nombreBuscar, " se encuentra en el listado")
si-no
mostrar("El nombre ", nombreBuscar, " no se encuentra en el listado")
fin-si
si-no
mostrar("")
mostrar("Gracias por utilizar el programa!")
fin-si

hasta-que nombreBuscar = "salir"

fin