Bienvenidos a este nuevo capítulo de este Curso Gratis de Programación #23 Registros. Teoría y ejercicios.
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Un registro es una estructura compuesta por diversos tipos de datos que se agrupan en una misma variable. La utilización de un registro es apropiada cuando se desea manejar datos relacionados sin importar sus tipos, bajo una misma unidad. Si se desea crear un programa que permita calcular el sueldo que pagar a los empleados de una institución, se debe conocer el nombre y apellido junto con el monto para pagar de cada empleado. En el caso de un alumno, se pueden representar sus datos con tipos simples o primitivos bajo una misma unidad, y se tendrían tantas variables simples como datos se necesiten representar del alumno.
Declaración de un registro En pseudocódigo:
Algoritmo declaracion_registro
tipo
registro: nombre _ registro
inicio
«tipo de dato>: «nombre de variable, nombre de variable, etc.>
«tipo de dato>: «nombre de variable, nombre de variable, etc.>
fin -registro
var
nombre_registro: nombre _ variable
Inicio
<sentencia ejecutable 1>
< sentencia ejecutable 2>
< sentencia ejecutable n>
fin La composición de un registro la define el programador, por lo tanto, al igual que los arreglos, su estructura debe definirse en la sección tipo del algoritmo y también debe indicarse un nombre a la estructura o tipo de dato definida. Dentro dela sección delimitada por las palabras reservadas inicio y fin, se declaran los elementos que componen el registro, que pueden ser de tipo primitivos (entero, real, lógico, cadena, carácter) o compuestos (arrayo incluso otro registro).
Los elementos que componen un registro se denominan campos. En la sección var, se declaran las variables que se utilizarán en el algoritmo, por lo tanto, si se utilizará el tipo de dato del registro definido, se deben indicar las variables que utilizarán dicho tipo de dato.
Declaración de un registro con tres campos de tipo entero y uno de tipo real:
Algoritmo declaracion_registro_1
tipo
registro: reg1
inicio
entero: dato1, dato2, dato3
real: resultado
fin-registro
var
Reg1 : r1
Inicio
.
.
.
fin Declaración de un registro con campos de tipo entero, real y cadena:
Algoritmo declaracion_registro 2
tipo
registro: reg2
Inicio
entero: dato1
real: resultado
cadena: texto1
fin-registro
var
reg2: r2
inicio
.
.
.
fin Acceso a los campos de un registro
Para acceder a los elementos o campos de un registro, se utiliza el nombre o identificador de la variable de tipo registro y el operador punto (.), seguido del nombre del campo al que queremos acceder. En el siguiente fragmento de código, se desea ingresados valores por teclado para guardarlos en los campos dato1y dato2deun registro. Luego, la suma de los valores de ambos campos es asignada al campo resultado. se muestra por pantalla el valor del campo resultado.
Algoritmo acceso _ registro
tipo
registro: reg
Inicio
entero: dato1, dato2, resultado
fin-registro
var
reg: r
Inicio
escribir "Ingrese un número entero ")
leer(r.dato1)
escribir("lngrese un número entero ")
leer(r. dato2)
r.resultado <-r.dato1 + r.dato2
escribir("La suma de los valores ingresados es: ", r.resultado)
fin Arreglo de registros
Si se desea manipular una lista de elementos cuyo tipo de dato es de un registro definido, entonces se puede utilizar un arreglo de registros. En este caso, cada posición del arreglo corresponde a un registro.
Algoritmo arreglo _ de _ registros
tipo
registro: reg _ alumno
inicio
cadena: nombre, apellido
entero: notal, nota2, nota3
real: promedio
fin -registro
array[1...10] de reg_alumno: vector
var
vector: listado alumnos
Inicio
.
.
.
fin
Si se deseara acceder al campo promedio del tercer registro del arreglo listado_alumnos, se utilizaría la siguiente sintaxis:
listado_alumnos[3].promedio Si se deseara acceder al campo promedio del tercer registro del arreglo listado_alumnos, se utilizaría la siguiente sintaxis:
listado_alumnos[3].promedio
Ejercicio 1
Algoritmo que permita cargar números en una matriz de 3 filas y 4columnas.
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. Debe mostrar el contenido de los arreglos unidimensionales.
algoritmo matriz _ sumadilas_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... ")
Mostar("")
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
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
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[i])
fin-para
fin
Ejercicio 2
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
incio
mostrar("Carga de matriz... ")
Mostrar("")
para Í <— 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 Í <— 1 hasta 4 hacer
diagonal[i] <-[i,i]
fin-para
mostrar("Contenido arreglo con elementos de la diagonal principal")
para Í <— 1 hasta 4 hacer
mostrar Sin Saltar diagonal[i])
fin-para
fin
Ejercicio 3
algoritmo que permita 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("Ingrese los valores de ", N, " temperaturas")
para i <- 1 hasta N hacer
Leer(origen[i])
fin-para
suma <— O
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... ")
índice destino <- 0
para Í <— 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 Í <— 1 hasta indice_destino hacer
mostrar(destino[i])
fin-para
fin Ejercicio 4
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: buscarNombre
Logico: bandera
arreglo: nombre
Inicio
Repetir
mostrar("lngrese la cantidad de temperaturas 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 Í <— 1 hasta N hacer
leer(nombres[i])
fin-para
Repetir
mostrar("")
mostrar("ingrese el nombre que desea buscar. Si desea finalizar ingrese salir")
leer(nombresBuscar)
nombresBuscar <- Minusculas(nombresBuscar)
Bandera <- falso
Si nombreBuscar != "salir" entonces
para Í <— 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!)
hasta-que nombreBuscar = "salir"
fin
Registros (struct) C++
Definición y acceso a los datos Un registro es una agrupación de datos, los cuales no necesariamente son del mismo tipo. Se definen con la palabra “struct”. Para acceder a cada uno de los datos que forman el registro, tanto si queremos leer su valor como si queremos cambiarlo, se debe indicar el nombre de la variable y el del dato(o campo) separados por un punto:
Como es habitual en C++, para declarar la variable hemos indicado primero el tipo de datos (struct { …} ) y después el nombre que tendrá esa variable (persona).También podemos declarar primero cómo van a ser nuestros registros, y más adelante definir variables de ese tipo:
Un struct que almacene datos de una canción en formato MP3: Artista, Título, Duración (en segundos), Tamaño del fichero (en KB). Un programa debe pedir los datos de una canción al usuario, almacenarlos en dicho struct y después mostrarlos en pantalla.
Arrays de registros Hemos guardado varios datos de una persona.
Se pueden almacenar los devarias personas si combinamos el uso de los “struct” con las tablas (arrays) que vimos anteriormente. La sintaxis no es exactamente la misma, y tendremos que añadir la palabra “new” en el momento de reservar espacio. Por ejemplo, si queremos guardar los datos de 100 alumnos podríamos hacer:
La inicial del primer alumno sería “alumnos[0].inicial”, y la edad del último sería “alumnos[99].edad”. Ampliar el programa del ejercicio 7.1.1, para que almacene datos de hasta100 canciones. Deberá tener un menú que permita las opciones: añadir una nueva canción, mostrar el título de todas las canciones, buscar la canción que contenga un cierto texto (en el artista o en el título). Nota: si te parece demasiado complicado, en el apartado 7.4 tienes un ejemplo parecido, desarrollado de principio a fin.(7.2.2)Un programa que permita guardar datos de “imágenes” (ficheros de ordenador que contengan fotografías o cualquier otro tipo de información gráfica). De cada imagen se debe guardar: nombre (texto), ancho en píxeles (por ejemplo2000), alto en píxeles (por ejemplo, 3000), tamaño en Kb (por ejemplo 145,6). El programa debe ser capaz de almacenar hasta 700 imágenes (deberá avisar cuando su capacidad esté llena). Debe permitir las opciones: añadir una ficha nueva, ver todas las fichas (número y nombre de cada imagen), buscar la ficha que tenga un cierto nombre.
Creación – Estructuras de datos: registros
Concepto de registro.
- Las estructuras de datos se clasifican en estructuras simples y compuestas, según cuantos elementos agrupen.
- Las estructuras de datos, también se clasifican en estructuras de datos estáticas y dinámicas, según cuando se realice la reserva de memoria ram.
- Dentro de las estructuras de datos simples están los tipos entero, real, cadena, caráter y lógico. Dentro de las estructuras de datos compuestas están los arreglos y los registros.
- Las estructuras de datos estáticas, son aquellas en las que la reserva de memoria se realiza en tiempo de compilación, mientras que las estructuras de datos dinámicas, son aquellas en las que la reserva de memoria se realiza en tiempo de ejecución.
- El registro, es un tipo de dato compuesto, es una colección de elementos que pueden ser de distinto tipo. Todos los elementos del conjunto se referencian con una misma variable de ese tipo.
Este tipo de dato es apropiado cuando se quiere por ejemplo dispone de un programa que permita calcular cuánto hay que pagarle a una serie de empleados de una institución. Para poder confeccionar el cheque, debe conocerse el nombre y apellido junto con el monto a pagar.
El monto a pagar se determina según su categoría, número de horas trabajadas, monto por hora, descuentos especiales (adelanto de dinero), premios por asistencia, cargas sociales (esposa, hijos, escolaridad, etc) Toda esta información junta (registro) caracteriza a una persona. Entonces como esta colección de datos son de distinto tipo, no puedo utilizar un arreglo para alcenarlos. Para estos y otros casos existe el tipo de dato registro.
Otras situaciones…
Otras situaciones son, por ejemplo, representar los datos de un alumno, los datos de un docente, los datos de un cliente del banco, los datos de un rectángulo, los datos de una mesa (forma, material, color). Entonces cuando debo representa una colección de datos que pueden ser de distintos tipos, puede utilizar un registro para representarla.
Ahora bien, si necesito representar los datos de un alumno, también lo puedo hacer con tipos simples o primitivos, en este caso tendría tantas variables simples como datos quiera representar del alumno. La ventaja que tiene usar un registro en lugar de muchas variables simples, es que mediante un único identificador puedo acceder a la colección completa de datos del alumno.
En lugar de tener varias variables, tendría una sola y mediante esa única variable accedería a la información del alumno. Es más sencillo trabajar y usar los registros cuando la situación lo hace necesario.
Cuando se copia el contenido de un registro a otro, se copia miembro a miembro En memoria ram, todos los miembros del registro ocupan posiciones consecutivas.
Creación de variables de tipo registro.
En pseudocódigo el registro se declara de la siguiente forma:
Algoritmo MMMM tipo
registro: reg inicio
…… : …..
var
…… : …..
…… : ….. fin_registro
reg: re
………………..
……………….Los registros se declaran en la misma zona que los arreglos en decir en la sección tipo.
En el ejemplo anterior se declara un tipo de dato llamado reg, dentro de inicio y fin se declaran los miembros del registro, pueden declararse miembros primitivos (real, entero, lógico, cadena, carácter) o compuestos (array o incluso otro registro).
En la sección var se declara el tipo con el identificador de la variable con la cual se va a hacer referencia al registro, en este caso ese identificador es re.
A continuación, se van a presentar algunos casos para que puede apreciarse la forma de utilizar estos tipos de datos definidos por el usuario.
Ejercicios de Aplicación
Acceso a los campos. Operaciones de asignación, entrada/salida.
Para acceder a cada uno de los miembros de un registro se utiliza el nombre o identificador de la variable de tipo registro el operador punto (.) seguido del nombre de la variable del miembro al que queremos acceder ya sea para guardar información en el o para leer su contenido.
Los miembros de un registro no pueden accederse por medio de la variable de ese miembro, siempre se accede a los miembros a tras del identificador de la variable de tipo registro.
Por ejemplo en el siguiente trozo de código se quiere introducir un valor por teclado para guardarlo en el miembro real, variable resul:
Algoritmo YYY const:
tam= 5 tipo
array [ 1..5, 1..5] de carácter: vector registro: reg
inicio
entero: dato1,dato2 real: resul
carácter: dato2
var
vector: ve fin_registro
reg: re
entero: i, j, resultado
inicio
escribir ( „ ingresar un número real‟) leer ( re.resul)
………… fin
Notar la sintaxis para acceder a los miembros de un registro. leer ( re.resul)
A continuación se muestra como se realiza una asignación, para el trozo de código anterior, se desea acumular en la variable resultado, el contenido de los miembros entero del registro:
……………
…………..
leer( re.dato1, re.dato2) resultado ß re.dato1 + re.dato2
Para mostrar por pantalla el contenido de un miembro de un registro, se utiliza la variable registro punto ( .) seguido del nombre de la variable del miembro que se desea mostrar por pantalla. Para el código anterior, se desea mostrar por pantalla el contenido del miembro dato1, la sintaxis es:
……….
mostrar ( re.dato1)
…………
Arreglo de registros.
Es bastante común tener que utilizar arreglos de registros, es decir cada posición del arreglo es un registro. A continuación se presentarán algunos ejemplos:
Declaración de un arreglo unidimensional de 10 elementos de tipo registro. El registro contiene un miembro real y otro entero:
algoritmo TTT tipo
registro: regis inicio
entero: inf1 real: inf2
fin_registro
array [1..10] de regis: vector
var
vector: re
…………
………..Declaración de un arreglo de registro, el registro contiene un miembro que es un dato lógico, y dos enteros:
Algoritmo OOO tipo
registro: reg inicio
entero: dato1, dato2 lógico: inf1 fin_registro
array [1..10] de reg: vector
var
vector: re
…………
………..Declaración de un arreglo unidimensional de 20 elementos de tipo registro. Cada registro contine tres datos de tipo lógico:
Algoritmo TTT tipo
registro: regis inicio
lógico: inf1, inf2, inf3
fin_registro
array [1..20] de regis: vector
var
vector: vec
…………
………..Declaración de un arreglo de registros de 10 elementos. El registro contiene un entero, real, carácter, y un miembro que es una matriz de 5 x5 de caracteres:
Algoritmo OOO tipo
array [1..5, 1..5] de caracter: vector
registro: reg inicio
entero: dato1 real: resul carácter: dato2 vector: ve
fin_registro
array [1..10] de reg: arr
var
arr: vec
…………
………..Ejercicios de aplicación.
A continuación se mostrarán ejemplos tratando de abarcar la mayor diversidad de casos posibles.
Ejemplo 1:
Se desea representar información de 3 trabajadores. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, edad, número de horas trabajadas, monto por hora trabajada. Cargar desde el teclado los registros, y mostrar por pantalla la remuneración promedio que paga la empresa.
algoritmo Calcula_remuneracion tipo
registro: persona inicio
cadena: nombre, apellido entero: edad, num_hora real: monto_hora
fin_registro
var
real: total
persona: per1, per2, per3
inicio
total ⭠ 0
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per1.nombre, per1.apellido, per1.edad, per1.monto_hora, per1.num_hora )
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per2.nombre, per2.apellido, per2.edad, per2.monto_hora, per2.num_hora )
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per3.nombre, per3.apellido, per3.edad, per3.monto_hora, per3.num_hora ) total ⭠ total + per1.monto_hora * per1.num_hora
total ⭠ total + per2.monto_hora * per2.num_hora
total ⭠ total + per3.monto_hora * per3.num_hora mostrar ( „la empresa en promedio paga:‟, total/3)
finEjercicio 2:
Se desea representar información de 3 trabajadores. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, edad, número de horas trabajadas, monto por hora trabajada. Cargar desde el teclado los registros, y mostrar por pantalla la remuneración más alta, junto con su identificación.
algoritmo Calcula_Mayor_remuneracion tipo
registro: persona inicio
cadena: nombre, apellido entero: edad, num_hora real: monto_hora
fin_registro
var
real: total
persona: per1, per2, per3 cadena: nom,ape
inicio
total ⭠ 0
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per1.nombre, per1.apellido, per1.edad, per1.monto_hora, per1.num_hora )
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per2.nombre, per2.apellido, per2.edad, per2.monto_hora, per2.num_hora )
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas de un trabajador‟)
leer ( per3.nombre, per3.apellido, per3.edad, per3.monto_hora, per3.num_hora )
total ⭠ total + per1.monto_hora * per1.num_hora nom ⭠ per1.nombre
ape ⭠ per1.apellido
si total < (per2.monto_hora * per2.num_hora) entonces
total ⭠ per2.monto_hora * per2.num_hora
nom ⭠ per2.nombre ape ⭠ per2.apellido
fin-si
si total < (per3.monto_hora * per3.num_hora) entonces
total ⭠ per3.monto_hora * per3.num_hora
nom ⭠ per3.nombre ape ⭠ per3.apellido
fin-si
mostrar ( „la mayor remuneración es: „, total, „el nombre y apellido es:‟, nom,ape)
fin
Ejercicio 3:
Se desea representar información de 3 trabajadores. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, edad, número de horas trabajadas, monto por hora trabajada, sexo codificado (mujer=1, varón=0). Cargar desde el teclado los registros, y mostrar por pantalla la remuneración de las mujeres, junto con su identificación.
algoritmo Calcula_Mayor_remuneracion tipo
registro: persona inicio
cadena: nombre, apellido entero: edad, num_hora lógico: sexo
real: monto_hora fin_registro
var
persona: per1, per2, per3
inicio
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas, sexo ( mujer=1, varón=0), de un trabajador‟)
leer ( per1.nombre, per1.apellido, per1.edad, per1.monto_hora, per1.num_hora, per1.sexo)
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas, sexo codificado (mujer=1, varón=0), de un trabajador‟)
leer ( per2.nombre, per2.apellido, per2.edad, per2.monto_hora, per2.num_hora, per2.sexo)
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas, sexo codificado (mujer=1, varón=0), de un trabajador‟)
leer ( per3.nombre, per3.apellido, per3.edad, per3.monto_hora, per3.num_hora, per3.sexo)
si per1.sexo = 1 entonces
mostrar ( „la empleada:‟ per1.nombre, per1.apellido, „ gana:‟, per1.monto_hora * per1.num_hora)
fin-si
si per2.sexo = 1 entonces
mostrar ( „la empleada:‟ per2.nombre, per2.apellido, „ gana:‟, per2.monto_hora * per2.num_hora)
fin-si
si per3.sexo = 1 entonces
mostrar ( „la empleada:‟ per3.nombre, per3.apellido, „ gana:‟, per3.monto_hora * per3.num_hora)
fin-si
finEjemplo 4:
Se desea representar información de 5 trabajadores, mediante un arreglo de registros. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, edad, número de horas trabajadas, monto por hora trabajada, sexo codificado (mujer=1, varón=0). Cargar desde el teclado los registros, y mostrar por pantalla la remuneración de las mujeres, junto con su identificación.
algoritmo Calcula_Mayor_remuneracion tipo
registro: persona inicio
cadena: nombre, apellido entero: edad, num_hora lógico: sexo
real: monto_hora
var
fin_registro
array [1..5] de persona: vector
vector:vec entero: i
inicio
desde i ⭠ 1 hasta 5 hacer
ingresar („nombre, apellido, edad, monto por hora y número de horas trabajadas, sexo ( mujer=1, varón=0) del trabajador n:‟, i)
leer ( vec[ i].nombre, vec[ i].apellido, vec[ i].edad, vec[ i].monto_hora, vect[ i].num_hora, vec[ i].sexo )
fin-desde
desde i ⭠ 1 hasta 5 hacer
si vec[ i].sexo = 1 entonces
mostrar(„la empleada:‟ vec[ i].nombre, vec[ i].apellido, „gana:‟, vec[ i].monto_hora * vec[ i].num_hora)
fin-si
fin-desde
fin Ejemplo 5:
Se desea representar información de 10 trabajadores. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, edad, número de horas trabajadas, monto por hora trabajada. Cargar desde el teclado los registros, y mostrar por pantalla la remuneración más alta, junto con su identificación.
algoritmo Calcula_Mayor_remuneracion const
tam = 10 tipo
registro: persona inicio
cadena: nombre, apellido entero: edad, num_horas real: monto_hora
fin_registro
array [1..10] de persona: vector
var
entero: i vector: ve real: total
cadena: nom, ape
inicio
total ⭠ 0
desde i ⭠ 1 hasta tam hacer
ingresar ( „nombre, apellido, edad, monto por hora y número de horas trabajadas del trabajador n:‟, i)
leer ( ve[ i].nombre, ve[ i].apellido, ve[ i].edad, ve[ i].monto_hora, ve[ i].num_hora)
fin_desde
total ⭠ ve[ 1].monto_hora * ve[1 ].num_hora nom ⭠ ve[1 ].nombre
ape ⭠ ve[1 ].apellido
desde i ⭠ 2 hasta tam hacer
si total < (ve[ i].monto_hora * ve[ i].num_hora) entonces
total ⭠ ve[i ].monto_hora * ve[i ].num_hora
nom ⭠ ve[i ].nombre ape ⭠ ve[i ].apellido
fin-si
fin_desde
mostrar ( „la mayor remuneración es: „, total, „el nombre y apellido es:‟, nom,ape)
finEjemplo 6:
Se desea representar información de 10 trabajadores. Cada trabajador se representa con un registro. La información que se guarda en el registro es: nombre, apellido, remuneración mensual. Cargar desde el teclado los registros mediante un procedimiento. Mediante una función determinar el promedio de remuneración que paga la empresa, y mostrar por pantalla los nombres y apellidos de los trabajadores que perciben por arriba de la remuneración media.
algoritmo Calcula_Mayor_remuneracion const
tam = 10 tipo
registro: persona inicio
cadena: nombre, apellido real: remun
fin_registro
array [1..10] de persona: vector
var
entero: i vector: ve
real: rem_dedia
inicio
rem_media ⭠ 0 carga_registro ( ve)
rem_media ⭠ calcula_remun_media ( ve)
mostrar („los empleados que cobran remuneraciones mayores a la media son:‟)
desde i ⭠ 1 hasta tam hacer
si rem_media < (ve[ i].remun) entonces
mostrar ( ve[ i].nombre, ve[ i].apellido, ve[ i].remun
fin-si
fin_desde
fin
procedimiento carga_registro ( S persona: ve) var
entero: i
inicio
desde i ⭠ 1 hasta 10 hacer
ingresar( „ nombre, apellido y remuneración de la persona n: „, i) leer (ve[ i].nombre, ve[ i].apellido, ve[ i]remun)
fin_desde
fin_procedimiento
real función calcula_remun_media ( E persona: ve) var
entero: i real: media
inicio
media ⭠ 0
desde i ⭠ 1 hasta 10 hacer
media ⭠ media + ve[ i].remun
fin_desde
media ⭠ media / 10 devolver media
fin_funcionNo te 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:
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:
¿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.