Curso Gratis de Programación #16 Arrays, Vectores y Matrices

Por /

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

https://achirou.com/todos-los-cursos/embed/#?secret=rDgK4OeHpW

¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?

La imagen tiene un atributo ALT vacío; su nombre de archivo es image.png

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:

  • Facebook
  • Twitter
  • LinkedIn
  • Telegram
  • TikTok
  • YouTube
  • Instagram

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:

  • LinkedIn
  • Twitter
  • Telegram
  • Instagram

¿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

https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/embed/#?secret=ljlF7Ux6yw

Curso Gratis Linux – Capitulo 1 – Introducción a Linux

https://achirou.com/curso-gratis-linux-capitulo-1-introduccion-a-linux/embed/#?secret=hTOp45TstZ

Curso Gratis de Redes – Capitulo 1 – Tipos de redes y servicios

https://achirou.com/curso-gratis-de-redes-capitulo-1-tipos-de-redes-y-servicios/embed/#?secret=C2vdQr68ZL

Como iniciarse en TRY HACK ME – Complete Beginner #1

https://achirou.com/como-iniciarse-en-try-hack-me-complete-beginner-1/embed/#?secret=O1sCVJkWbr



OSINT #1 Más de 200 Search Tools

https://achirou.com/mas-de-200-search-tools-para-osint/embed/#?secret=VXqgscVrmY



Dejá un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Scroll al inicio