lunes, 30 de junio de 2008

REGISTROS (RECORD)

Registros (Record)

Son estructuras de datos cuyos elementos pueden ser de diferentes tipos. En los registros se puede almacenar una variedad de información sobre una persona (nombre, estado civil, edad, fecha de nacimiento, etc.).

Cada elemento se almacena en un campo de registro independiente y se puede referenciar cada elemento almacenado en un campo por su nombre.
Tambien, se puede decir que un registro (record) es un tipo de dato estructurado que consta de un conjunto de elementos que pueden ser del mismo tipo o no. Los componentes de un registro se denominan campos, cada campo tiene un nombre llamado identificador del campo.

Formato:

TYPE
tipo_registro= record
lista_1: tipo_dato1;
lista_2 tipo_dato2;
lista_3 tipo_dato3;
.
.
.
lista_n:tipo_daton;
end;

donde,
tipo_registro es el nombre de la estructura.
lista_1, lista_2, lista_3 ... linsta_n son los nombres de los campos.
dato1, dato2, dato3 ... daton son los tipos de datos de cada campo.

VAR
nombre_reg:tipo_registro;

donde nombre_reg es el nombre de la variable de tipo registro.
tipo_registro es el nombre de la estructura que se uso en TYPE.


Ejemplo: Declarar un registro de empleados cuyos campos son: nombre, edad, direccin y salario

TYPE
empleado= record
nombre:string[30];
edad:integer;
direccion:string[40];
salarios:real;
end;

VAR
trabajador:empleado;

graficamente seria
nombre: Juan Perez
edad:22
direccion: calle 50, barquisimeto estado Lara.
salario12345

Acceso a los campos de un registro: Se puede acceder a cada campo de un registro directamente usando un designador o selectro de campo.
Formato: nombre_registro.nombre_campo

Ejemplo:
trabajador.nombre
trabajador.edad
trabajador.direccion
trabajador.salario

Una vez que los datos estan almacenados en un registro, se pueden manipular de igual forma que otros datos en memoria.
writeln ('el empleado se llama:', trabajador.nombre)
visualizad en pantalla lo siguiente el empleado se llama: Juan Perez

Operaciones sobre registros: Las operaciones de escritura y lectura se deben realizar individualmente, ya que un registro esta compuesto por campos de tipos diferentes.

Cargar datos a un registro y mostrarlos

program cargar_mostrar;
uses crt;
type
empleado=record
nombre:string[30];
edad:integer;
direcccion:string[40];
salario:real
end;

var
trabajador:empleado;
begin
{inicio cargar registro}
writeln('Introduzca nombre');
readln(trabajador.nombre);
writeln('Introduzca la edad');
readln(trabajador.edad);

writeln('Introduzca direccion');
readln(trabajador.direccion);

writeln('Introduzca salario');
readln(trabajador.salario);

{fin cargar registro}

{inicio mostrar informacion}
writeln('el nombre es', trabajador.nombre);
writeln('la edad del trabajador es', trabajador.edad);
writeln('la direccion del trabajador es', trabajador.direccion);
writeln('el salario del trabajador es', trabajador.salario);
readln;
{fin mostrar informacion}
end.


Ejercicio: Sean 10 alumnos de los cuales se tienen los siguientes datos nombre, asignatura y 4 notas de la asignatura. Calcular y mostrar la suma de las 4 notas y la media de la asignatura.

program registros;
uses crt;
type
alumnos=record
nombre:string[30];
asignatura:string[40];
nota:real;
end;

var
alumno:alumnos;
i,c:integer;
suma,media:real;

begin
for c:= 1 to 10 do
begin
writeln('Introduzca el nombre');
readln(alumno.nombre);
writeln('Introduzca la asignatura');
readln(alumno.asignatura);
suma:=0;

for i:=1 to 4 do
begin
writeln('introduzca la nota', i);

readln(alumno.nota);
suma:=suma+alumno.nota;
end;

media:=suma/4;
writeln('la media del alumno', alumno.nombre, 'es', media:2:2);
writeln('la suma es:',suma:2:2);
readln;
clrscr;

end;
end.

Tomado del libro Programacion en Pascal de Luis Joyanes Aguilar


ARRAYS DE REGISTROS

Los registros simples se utilizan raramente por si mismos. En general se agrupan en conjuntos conocidos como arrays de registros. Por ejemplo, si se dispone un registro que contiene los datos relativos a articulos de un almacén y si el inventario dispone de 100 artículos y se desean procesar adecuadamente se puede utilizar un array de 100 elementos; mediante la declaración siguiente se definen los elementos del conjunto.


Type
Itemstock = record
Nombre : string[30];
Numero : integer;
Precio : real;
End;

lista = array [ 1..100] of itemstock;
Var
inventario : lista;

Con estas declaraciones se puede acceder a cada registro a través de los campos de cada registro. Así, por ejemplo, la lista completa del inventario se puede cargar con el siguiente segmento del programa:

For i : = 1 to 100 do
Begin
Writeln(‘ introduzca el nombre’);
Readln (iventario[i].nombre);
Writeln(‘ introduzca número de stock’);
Readln (inventario[i].número);
Writeln(‘ introduzca precio);
Readln (invetario[i].precio);
End;

El proceso de registros del array es similar al tratamiento, ya conocido, de elementos de un array con la peculiaridad de ser tipos compuestos (registros) en lugar de ser tipos simples.
Elemplo: Inventario [ 2 ]. Nombre

miércoles, 25 de junio de 2008

ARREGLOS BIDIMENSIONALES Y MULTIDIMENSIONALES







Fuente: prof. Francys Ochoa

Enlace importante:














lunes, 23 de junio de 2008

CONTENIDO UNIDAD III Y PLAN DE EVALUACION

Sección 3N2IS / Semestre III
Materia: Programación
Docente: Ing. Mayra Ramirez

Contenido Corte III:
arreglos Bidimensionales / Multidimensionales.
Funciones/ recursividad
Registros y Archivos
Colas
Listas
Árboles
Grafos.

Plan de evaluación Corte III (35 ptos.)
Evaluación laboratorio 4 ptos.
Grupo 1 Jueves 10/7/2008
Grupo 2 Jueves 17/7/2008

Taller 4 ptos. Sobre pilas, colas, listas, árboles y grafos.
Miércoles 16/7/2008 y Miércoles 23/7/2008

Entrega proyecto 6 ptos. Miércoles 23/7/2008
Defensa proyecto 6 ptos.: Jueves 24/7/2008 y Jueves 31/7/2008

Examen Parcial 15 Ptos Miércoles 30/7/2008

=================================================================

Sección 3N5IS / Semestre III
Materia: Programación
Docente: Ing. Mayra Ramirez

Contenido Corte III:
Arreglos Bidimensionales / Multidimensionales.
Funciones/ recursividad
Registros
Archivos
Colas
Listas
Árboles
Grafos.


Plan de evaluación Corte III (35 ptos.)
Evaluación laboratorio 4 ptos.
Grupo 1 martes 8/7/2008
Grupo 2 martes 15/7/2008

Taller 4 ptos. Sobre pilas, colas, listas, árboles y grafos.
Lunes 14/7/2008 y Lunes 21/7/2008

Entrega proyecto 6 ptos. Lunes 21/7/2008
Defensa proyecto 6 ptos.: Martes 22/7/2008 y Martes 29/7/2008

Examen Parcial 15 Ptos Lunes 28/7/2008
==================================================================
Sección 3N6IS / Semestre III
Materia: Programación
Docente: Ing. Mayra Ramirez

Contenido Corte III:
Arreglos Bidimensionales / Multidimensionales.
Funciones/ recursividad
Registros
Archivos
Colas
Listas
Árboles
Grafos.


Plan de evaluación Corte III (35 ptos.)
Evaluación laboratorio 4 ptos.
Grupo 1 martes 8/7/2008
Grupo 2 martes 15/7/2008

Taller 4 ptos. Sobre pilas, colas, listas, árboles y grafos.
Lunes 14/7/2008 y Lunes 21/7/2008

Entrega proyecto 6 ptos. Lunes 21/7/2008
Defensa proyecto 6 ptos.: Martes 22/7/2008 y Martes 29/7/2008

Examen Parcial 15 Ptos Lunes 28/7/2008

===============================================================

jueves, 5 de junio de 2008

ARREGLOS UNIDIMENSIONALES

Un arreglo unidimensional es un tipo de datos estructurado que está formado por una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. Los datos que se guarden en los arreglos todos deben ser del mismo tipo.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.
Los arreglos nos permiten hacer un conjunto de operaciones para manipular los datos guardados en ellos, estas operaciones son: ordenar, buscar, insertar, eliminar, modificar entre otras.


REPRESENTACION EN MEMORIA: Los arreglos guardan en memoria la cantidad de espacios que se le indican en la declaración.

Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar 5 datos de tipo entero (integer)

x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto quiere decir en el arreglo X en la posición 1 guarda 34, en el arreglo X en la posición 2 guarda 22, asi hasta la última posición del arreglo X posicion 5 guarda 72.
X [1]

34

X [2]

22

X [3]

39

X [4]

63

X [5]
72

Declaracion de los arreglos unidimensionales: Se declara el tipo del arreglo, con la palabra reservada TYPE, luego se declara la variable de tipo arreglo, esto se hace en el bloque de declaracion de variables palabra reservada VAR.

Type

nombre_arreglo= array[x..y]of tipo_dato;

Ejemplos:

salarios= array [1…x] of real;

nombre_trabajador=array[1..x] of string;

Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string etc.

Variables tipo array

Var

sueldo:salarios;

nombre:nombre_trabajador;

Una vez declarados los arreglos procedemos a cargar información en ellos, para esto usamos estructuras repetitivas la mas recomendable por su facilidad es el for, una vez cargada la información se puede hacer cualquier operación de calculo y por último mostramos la información de los arreglos usando de igual manera la estructura repetitiva for.

carga de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo:

for i:=1 to num do

begin

readln(notas[i]);

end;

Mostrar la información de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo::

for i:=1 to num do

begin

writeln(notas[i]:3:1);

end;

Se han hechos programas que suman una cantidad de números usando dos variables, una para leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se pierden los valores de los sumandos. El uso de arreglos permite calcular la suma de los números con una cantidad mínima de código y a la vez conservar cada valor, como muestra el siguiente programa completo:


Program SumaN;

Uses

Crt;

Const

n = 5;

Var

nums: Array[1..n] Of Integer;

s, i: Integer;

Begin

For i:=1 To n Do

Begin

Write('Escriba el número: ');

ReadLn(nums[i]);

s := s + nums[i];

End;

WriteLn('La suma es: ', s);

End.

Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, también sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para adecuar el programa a la escala apropiada

Ejercicios de arreglos unidimensionales:



* Dadas n cantidad de notas, calcular e imprimir el promedio de las notas y todas las notas que fueron mayor a la media calculada.

PROGRAM calificaciones;
USES CRT;
type
listacalificaciones=array[1..n]of real;
VAR
notas:listacalificaciones;
media,suma:real;
num,i:integer;

BEGIN
WRITELN('INTRODUZCA la cantidad de notas a procesar');
READLN(NUM);
suma:=0;

for i:=1 to num do
begin
readln(notas[i]);
suma:=suma+notas[i];
end;
media:=suma/num;
writeln('la media es:' , media:2:2);
writeln('la lista de calificaciones mayores a la media es:');
for i:=1 to num do
begin
if notas[i]>media then
writeln(notas[i]:3:1);
readln;
end;
END.

(*Escribir un programa en pascal que rellene un array con 11
numeros, luego dividirlos entre 3 y mostralos por pantalla *)

PROGRAM numeros;
USES CRT;
type
arreglonumeros=array[1..11]of real;
VAR
num:arreglonumeros;
i:integer;
numero:real;

BEGIN
for i:=1 to 11 do
begin
WRITELN('Introduzca el numero ' , i, ' a dividir');
readln(num[i]);
numero:=num[i]/3;
write('los numero resultantes de la division son:' ,numero:2:2);
readln;
end;
end.