Bienvenidos a este nuevo capítulo de este Curso Gratis de Programación #16 Arrays, Vectores y Matrices
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
ARREGLOS MULTIDIMENSIONALES
Los arreglos multidimensionales tienen dos o mas índices los cuales son usados para especificar un elemento particular en el array. La declaración de un array multidimensional es similar a la de un array de una dimensión.
- int al [32] Array de una dimensión
- int b [16] [16] Array de dos dimensiones
- int c [12][10][12] Array de tres dimensiones
Arrays multidimensionales
Sabemos que un array representa un conjunto de variables del mismo tipo de datos. Cuando el tipo de datos del array es, en sí mismo, un array, hablamos de arrays multidimensionales. En el lenguaje de programación Pascal, esto se observa claramente al momento de declarar una variable de tipo array. Veamos:
// define un array de enteros
var a:array[1..3] of integer;
// define un array de arrays de enteros
var b:array[1..3] of array[1..5] of integer;
// define un array de arrays de arrays de enteros
var c:array[1..3] of array[1..5] of array[1..4] of integer;.
Vectores
Se denominan vectores a los arreglos que poseen una sola dimensión y por lo tanto un sólo número de índice. Si se requiere un algoritmo que nos muestre de todas las ventas mensuales de un determinado año, cuales meses estuvieron por debajo del promedio de venta mensual. Tenemos que tener todas las ventas mensuales ingresadas para poder promediarlas, son 12 meses en un año entonces ahí encontraremos la cantidad de variables que necesitamos. Utilizando al metodología Top-Down, pensemos el algoritmo por partes:
1. Carga de los 12 totales de ventas.
2. Cálculo del promedio
3. Búsqueda y muestra de los que están por debajo del promedio.
Debemos definir las variables que vamos a utilizar:
Carga de un vector: Esta tarea es bastante simple, hay que realizar un ciclo iterativo para cargar los 12 valores. Cada índice en el algoritmo corresponde a un mes, así que aprovecharemos para denominar mes a la variable contadora.
Procesamiento del vector cargado: Ahora nos toca revisar los datos cargados acumularlos y contarlos par aobtener el promedio. La verdad que sería innecesario contarlos pues ya sabemos que son 12, pero si habrá que acumularlos para poder obtener el promedio.
Búsqueda y muestra del vector: Una vez que conocemos el promedio anual, podemos volver a revisar las ventas mensuales para determinar cuales están por debajo del promedio.
Así queda el programa completo.
y el diagrama de flujo:
se puede ir acumulando a medida que se va cargando el vector, entonces el algoritmo quedaría un poco más reducido:
y el diagrama de flujo:
En Pselnt para definir los arreglos se toma la palabra Dimensión:
Dimension <identificador> [<maxl>,…,<maxn>];
El ‘identificador’ debe ser una variable del tipo a transformar en arreglo y los parámetros ‘max’ representan la longitud de cada dimensión.
Definir ArregloDeNumeros Como Numerico;
Dimension ArregLoDeNumeros[10]; // 1 Dim
Asignación manual
Desde el momento en que declaramos un arreglo todas las posiciones de éste se encuentran nulas, sin valor. Para otorgarles un valor es tan fácil como hacer referencia al indice entre [ ] y asignar el valor:
ArregloDeNumeros[0] <- 1;
ArregloDeNumeros[1] <- 2;
ArregloDeNumeros[2] <- 3;
Lectura y escritura manual
También utilizando índices podemos hacer una lectura por teclado:
- Leer ArregloDeNumeros[0];
- Leer ArregloDeNumeros[1];
- Leer ArregloDeNumeros[2];
O una escritura por pantalla:
- Escribir ArregloDeNumeros[0];
- Escribir ArregloDeNumeros[1];
- Escribir ArregloDeNumeros[2];
Recorrer secuencialmente arreglos
Trabajar manualmente con arreglos no es muy eficiente. Por suerte hay una iteración que nos viene de perlas. Es el bucle Para. Utilizando el bucle Para podemos recorrer las posiciones de un arreglo utilizando su contador como índice.
Para i<-0 Hasta 5 Hacer
Arreglo[i];
FinPara Sólo necesitamos conocer la longitud del arreglo.
Ejercicio 1
ingresar 10 números enteros por teclado, los guarde en un arreglo unidimensional, para luego recorrerlo y mostrar los valores que ocupan las posiciones pares.
Ejercicio 2
Algoritmo que permita ingresar 10 números enteros por teclado, los guarde en un arreglo unidimensional, para luego recorrerlo y mostrar los valores positivos que sean pares.
Ejercicio 3
Algoritmo que permita ingresar 10 números enteros por teclado, los guarde en un arreglo unidimensional, para luego recorrerlo y guarde los valores positivos en otro arreglo conla misma estructura. Se debe mostrar el contenido del segundo arreglo.
Ejercicio 4
Algoritmo que permita ingresar 10 caracteres por teclado, los guarde en un arreglo unidimensional, para luego recorrerlo y muestre la cantidad de letras mayúsculas.
Ejercicio 5
Diagrama:
Ejercicio 6
Ejercicio 7
Arreglos Bidimensionales
A veces es mejor organizarla en forma de tabla o matriz con dos subíndices: uno para recorrer las filas y otro para recorrer las columnas. Un arreglo bidimensional es un vector de vectores cuya representación gráfica puede ser representada mediante una tabla. La figura representa un arreglo bidimensional cuya primera dimensión contiene tres elementos que almacenan nuevos arreglos de cuatro elementos(segunda dimensión).
La figura representa el mismo arreglo definido anteriormente, pero para su representación se utiliza una matriz:
Cada elemento de un arreglo bidimensional se referencia con un mismo nombre y dos subíndices. En notación estándar el primer subíndice hace referencia a las filas y el segundo a las columnas del arreglo.
Si el arreglo bidimensional de la Figura 2 se llama tabla, entonces tabla[2,3] es el elemento que ocupa la posición de la segunda fila y tercera columna, cuyo valor es 1. En pseudocódigo, los arreglos bidimensionales se declaran de la siguiente forma:
Algoritmo declaracion_arreglo_bidimensional
tipo
Array[limite inferior filas…limite superior filas] [limite inferior columna…limite superior columna] de <tipo de dato>: <nombre estructura arreglo>
Var
<nombre estructura arreglo>:<nombre variable de tipo arreglo>
inicio Si queremos almacenar las calificaciones de los alumnos en tres materia se podría construir un arreglo bidimensional para representar una tabla en la cual las filas hacen referencia a cada alumno y las columnas hacen referencia a cada una de las materias:
en la columna 1, se indican las calificaciones de matemáticas; en la columna 2,lascalificacionesde lengua, y en la columna 3,lascalificacionesde historia.
Si se hace una lectura horizontal, se puede decir que el alumno de la fila 1 tiene 6 en matemáticas,8 en lengua y 9 en historia. Si se quiere referenciar la nota del cuarto alumno en historia, se indica con la expresión notas[4][3]. Para recorrer arreglos bidimensionales, es necesario tener dos estructuras repetitivas anidadas. Las estructuras que mejor se adaptan a estos casos son las estructuras desde/fin-desde. Por ejemplo, para leer datos desde el teclado, guardarlos en un arreglo bidimensional y luego recorrerlo para mostrarlos elementos en pantalla, se puede utilizar el siguiente pseudocódigo:
Ejercicio 9
Algoritmo recorrer_arreglo bidimensional
tipo
array[1...5][1...3] de entero: lista
var
lista: notas
entero: i, j
Incio
// cargar arreglo bidimensional
desde i <- 1 hasta 5 hacer
desde j <- 1 hasta 3 hacer
leer(notas[i,j])
fin-desde
fin-desde
// recorrer y mostrar elementos del arreglo bidimensional
desde i <-1 hasta 5 hacer
desde j<- 1 hasta 3 hacer
Mostrar(notas[i,j]
fin-desde
fin-desde
fin La estructura repetitiva desde externa recorre las filas y,para cada una de ellas, la estructura desdeinterna recorre cada una de las columnas.
Los arreglos de 2 dimensiones se pueden interpretar como filas apiladas una sobre la otra:
Se entienden como filas y columnas. Encontramos un índice para las filas y también un indice para las columnas que combinados dan la posición de cada celda.
Dimensión ArregloDosDimensiones[2,q];
Ejercicio 10
ingresarlas notas de 10 alumnos en las materias de física y matemáticas correspondientes a un curso. Se desea mostrar el promedio general del curso y por materia.
algoritmo arreglo_promedio_curso
tipo
Array[1…10][1…2 ]de real: tabla_notas
Var
entero: cantidadAlumnos, i, j
real : sumaNotasCurso, sumaNotasFisica, sumaNotasMatematicas, promedioNotasCurso, promedioNotasFisica, promedioNotasMatematicas
tabla notas: notas
inicio
cantidadAlumnos <-10
mostrar("Carga de notas…")
mostrar("")
para i<- 1 hasta cantidadAlumnos hacer
mostrar("lngrese las notas del alumno ", i)
para j <-1 hasta 2 hacer
Si j==l entonces
mostrar("Física: ")
Si-no
mostrar("Matemáticas: ")
fin-si
leer notas[i,j]
fin-para
mostrar("")
fin-para
// Cálculo de promedios
sumaNotasCurso <-0
sumaNotasFisica <-0
sumaNotasMatematicas <-0
para i <-1 hasta cantidadAlumnos hacer
sumaNotasCurso <- sumaNotasCurso + notas[i,1] + notas[i,2]
sumaNotasFisica <- sumaNotasFisica + notas[i,1]
sumaNotasMatematicas <- sumaNotasMatematicas + notas[i,2]
fin-para
promedioNotasCurso <- sumaNotasCurso / (cantidadAlumnos*2)
promedioNotasFisica <- sumaNotasFisica / cantidadAlumnos
promedioNotasMatematicas <- sumaNotasMatematjcas / cantidadAlumnos
mostrar("promedio de notas del curso: ", promedioNotasCurso)
mostrar("promedio de notas de Física: promedioNotasFisica)
mostrar("promedio de notas de Matemáticas: ", promedioNotasMatematicas)
fin
Ejercicio 11
cargar una tabla con temperaturas. La tabla debe tener 5 filas correspondientes a 5 días y 3 columnas correspondientes a 3momentos del día. El algoritmo debe mostrar la temperatura mínima y máxima de la tabla completa.
algoritmo matriz_temperaturas
Tipo
Array[1…5][1…3] de real: tabla_5x3
Var
entero: i, j
real: tempMin, tempMax
tabla 5x3: temperaturas
lnicio
mostrar("Carga de temperaturas... ")
Mostrar("")
para Í <— 1 hasta 5 hacer
Para j <- 1 hasta 3 hacer
Mostrar("ingrese la temperatura ",j, "del dia",i)
Leer(temperatura[i,j])
fin-para
Mostrar("")
fin-para
tempMin <- temperaturas[1,1]
tempMax <- temperaturas[1,1]
para Í <- 1 hasta 5 hacer
Para j <— 1 hasta 3 hacer
si temperaturas[i,j]< tempMin entonces
tempMin <—temperaturas[i,j]
fin-si
si temperaturas[i,j] >tempMax entonces
tempMax <—temperaturas[i,j]
fin-si
fin-para
fin -para
temperatura mínima registrada es: tempMin)
temperatura máxima registrada es: ", tempMax)
fin
Ejercicio 12
cargar una matriz de M × N números enteros y muestre la cantidad de números positivos.
algoritmo matriz _ cantidad_positivos
tipo
Array[1…50][1…50] de entero: matriz
Var
entero: filas, columnas, cantidadpositivos, i, j
matriz: datos
inicio
Mostrar("ingrese la cantidad de filas que tendrá la matriz (menor a 50)")
leer(filas)
Mostrar("ingrese la cantidad de columnas que tendrá la matriz (menor a 50)")
leer(columnas)
Mostrar("carga de matriz…")
Mostrar("")
para i <-1 hasta filas hacer
para j <- 1 hasta columnas hacer
mostrar( "Ingrese el valor para la posición [",i, ",",j,"]")
Leer(matriz[i,j])
fin-para
Mostrar("")
fin-para
cantidadPositÍvos <- 0
para i <— 1 hasta filas hacer
para j <— 1 hasta columnas hacer
si (matriz[i,j] > 0 entonces
cantidadPositivos <- cantidadPositivos + 1
fin-si
fin-para
fin-para
mostrar("La cantidad de números positivos en la matriz es: ", cantidadpositivos)
fin
Ejercicio 13
cargar dos matrices de 3 ×3. El algoritmo debe realizar la suma de ambas matrices y mostrar la matriz resultante.
algoritmo suma_matrices
tipo
Array[1…3][1…3] de entero: matriz
Var
entero: i, j
matriz: matriz1, matriz2, matizSuma
Inicio
Mostrar("carga de matriz1…")
Mostrar("")
para i <-1 hasta 3 hacer
para j <- 1 hasta 3 hacer
mostrar( "Ingrese el valor para la posición [",i, ",",j,"]")
Leer(matriz1[i,j])
fin-para
Mostrar("")
fin-para
Mostrar("carga de matriz 2…")
Mostrar("")
para i <-1 hasta 3 hacer
para j <- 1 hasta 3 hacer
mostrar( "Ingrese el valor para la posición [",i, ",",j,"]")
Leer(matriz2[i,j])
fin-para
Mostrar("")
fin-para
//Suma matrices
para i <-1 hasta 3 hacer
para j <- 1 hasta 3 hacer
matrizSuma1[i,j] <- matriz1[i,j + matriz2[i,j]]
fin-para
fin-para
mostrar("Matriz resultante (matriz1 + matriz2)")
para i <- 1 hasta 3 hacer
Para j <- 1 hasta 3 hacer
mostrar sin saltar ("", matrizSuma[i,j) // función "sin saltar" utilizada en El programa PSEINT para Evitar El salto de línea cuando SE imprime un por pantalla
fin-para
Mostrar("")
fin-para
Fin
Ejercicio 14
guardar 16 caracteres tomados desde el teclado en un arreglo bidimensional de 4×4.El algoritmo solicitará al usuario el ingreso de un número de fila y el programa debe mostrar todos los elementos de dicha fila.
algoritmo matriz mostrar_fila
tipo
array[1...4][1...4] de caracter: matriz
var
entero: i, j, fila
matriz: datos
Inicio:
mostrar("Carga de matriz... ")
mostrar("")
para Í <— hasta 4 hacer
Para j <- 1 hasta 4 hacer
Mostrar("Ingrese el valor para la posición [",i, ", ",j, "j")
Leer(datos[i,j])
fin-para
mostrar("")
fin-para
repetir
Mostrar(" ingrese la fila que desea mostrar (entre 1 y 4)")
leer(fila)
hasta-que fila >= 1 y fila <= 4
Mostrad("")
mostrar("Mostrando contenido de la fila "fila)
para Í <— hasta 4 hacer
mostrar sin saltar ("", datos[fila,i])
fin-para
fin
Ejercicio 15
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 Jilas_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
Mostrat("carga de matriz…")
Mostrar("")
para i <- 1 hasta 3 hacer
Para j <- 1 hasta 4 hacer
Mostar("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 fila
para i <- 1 hasta 4 hacer
sumaColumnas <- 0
para j <- 1 hasta 3 hacer
sumaColumnas <- sumaColumnas + datos[i,j]
fin-para
filas[j] <-sumaColumnas
fin-para
Mostrar("Contenido arreglo con suma de coda fila")
para Í <- 1hasta 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
Ejercicio 16
cargar una matriz de 4filas 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 Í <— 1 hasta 4 hacer
Para j 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 Í <— 1 hasta 4 hacer
Diagonal[i] <- diagonal[i,j]
fin-para
mostrar("Contenido arreglo con elementos de la diagonal principal")
para Í <— 1 hasta 4 hacer
mostrar Sin Saltar (" 2, diagonal[i])
fin-para
fin
Ejercicio 17
cargar N valores de temperaturas en un arreglo. El algoritmo debe guardar en otro arreglo las temperaturas que superen el promedio. Mostrar el contenido de ambos arreglos.
algoritmo arreglo _ temperaturas _ copiar
Tipo
array[1...50j de real: arreglo
var
entero: i, indice destino, N
real : suma, promedio
arreglo: origen, destino
inicio
repetir
mostrar("lngrese la cantidad de temperaturas que va cargar (menor a 50)")
leer(N)
hasta-que N >0 y N < 50
mostrar("lngrese los valores de ", N, " temperaturas")
para Í <- 1 hasta N hacer
Leer(origen[i])
fin-para
suma <- 0
para Í <- 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 Í <— 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
Ejercicio 18
cargar N valores de nombres en un arreglo. El algoritmo debe permitir al usuario ingresar un nombre para buscarlo en el listado.
detengas, sigue avanzando
Aquí tienes un propósito para este 2024 que debes considerar seriamente: si has querido mejorar tus habilidades en hacking, Ciberseguridad y programación ahora es definitivamente el momento de dar el siguiente paso. ¡Desarrolla tus habilidades aprovechando nuestros cursos a un precio increíble y avanza en tu carrera!
Python Practicando. Desde 0 hasta Desarrollador en Python
Aprende Python, donde iniciamos desde 0, sin conocimientos previos hasta desarrollar aplicaciones con mucha practica!
Calificación: 4,6 de 5 (20.833 calificaciones) 249.493 estudiantes Creado por Alvaro Chirou • 1.800.000+ Enrollments Worldwide, Walter Coto || +450,000 Estudiantes Español.
Lo que aprenderás
- Ejercitar la lógica de programación
- Comprender cómo la vida cotidiana puede ser fácilitada o simulada con código
- Aprender programación desde cero
- Usar Visual Studio Code como Editor de Código
- Conocer y aprender el lenguaje de programación Python
- Ser un programador desde cero, sin conocimiento en otro lenguaje o con algo previo
- Mejorar las habilidades de programación, mejorar procesos y fácilitar la comprensión de código
- Preparar un entorno dónde programar en Python
- Operaciones aritméticas y jerarquía de Python
- Manejo de cadenas en Python
- Digitar datos por teclado con Python
- Mostrar Datos por Pantalla al usuario en Python
- Operadores Relacionales de Python
- Operadores Lógicos de Python
- Condicionales en Python
- Estructuras de Datos: Listas, Tuplas y Diccionarios
- Iteraciones y bucles repetitivos de Python
- Segmentar Código y hacerlo más eficaz con las Funciones en Python
- Gestionar posibles errores que puedan dar tus programas
- Programación Orientada a Objetos
- HTML y CSS
- Selenium Web Driver con Python
- Ejercitar todo lo Aprendido con Ejercicios
Este curso incluye:
- 25,5 horas de vídeo bajo demanda
- 21 artículos
- 148 recursos descargables
- Acceso en dispositivos móviles y TV
- Certificado de finalización
Python es Hoy uno de los lenguajes más utilizados por Excelencia.
Esto se debe por su simpleza al momento de Desarrollar aplicaciones.
Por su capacidad de procesamiento a altas velocidades con grandes volúmenes de información.
Es un increíble lenguaje con el cual si no sabes programar, podrás aprender.
Y si ya sabes desarrollar, te aconsejo aprenderlo ya que en el mercado cada vez se solicitan más desarrolladores en Python.
Aspirar al trabajo que desean, o mejorar sus ingresos con un aumento de salario.
Python se utiliza para muchisimas cosas como:
- Machine Learning
- Data Science
- Inteligencia Artificial.
- Y mucho más!
En este curso te acompañare en el proceso por el cual aprenderás las bases del lenguaje, para luego determinar qué camino quieres seguir.
Te invito que me acompañes a conocer este Gran Lenguaje!
Aprende con nuestros más de 100 cursos que tenemos disponibles para vos
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Sobre los autores
Álvaro Chirou
Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 1.800.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma. Puedes serguirme en mis redes:
- Telegram
- TikTok
- YouTube
Laprovittera Carlos
Soy Laprovittera Carlos. Con más de 20 años de experiencia en IT brindo Educación y Consultoría en Seguridad de la Información para profesionales, bancos y empresas. Puedes saber más de mi y de mis servicios en mi sitio web: laprovittera.com y seguirme en mis redes:
- Telegram
¿Quieres iniciarte en hacking y ciberseguridad pero no sabes por dónde empezar? Inicia leyendo nuestra guia gratuita: https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/ que te lleva de 0 a 100. Desde los fundamentos más básicos, pasando por cursos, recursos y certificaciones hasta cómo obtener tu primer empleo.
SIGUE APRENDIENDO GRATIS CON NUESTRAS GUIAS
Cómo Iniciarse en Hacking y Ciberseguridad en 2024
Curso Gratis Linux – Capitulo 1 – Introducción a Linux
Curso Gratis de Redes – Capitulo 1 – Tipos de redes y servicios
Como iniciarse en TRY HACK ME – Complete Beginner #1
OSINT #1 Más de 200 Search Tools