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

por | Mar 25, 2024 | Programación | 0 Comentarios

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

Todos los Cursos

¿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

Cómo Iniciarse en Hacking y Ciberseguridad en 2024

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

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

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

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

Como iniciarse en TRY HACK ME – Complete Beginner #1

Como iniciarse en TRY HACK ME – Complete Beginner #1



OSINT #1 Más de 200 Search Tools

OSINT #1 Más de 200 Search Tools



Enviar comentario

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