lunes, 23 de marzo de 2009
miércoles, 18 de marzo de 2009
SESIÓN DE CLASE PARA 5TO. SEC. -2009 - I.E.P. CLARETIANO
REGISTROS
CONCEPTO DE REGISTROS: Un registro es una estructura heterogénea de datos, denominados campos y a los que accedemos por nombre. Al igual que en cualquier otro dato, el tipo registro (Record) antes de poder ser utilizado debe ser declarado en la sección de tipos.
La única operación (a parte de la lectura) que se puede realizar con una variable registro como tal es la asignación, es decir, se pueden copiar todos los campos de una variable registro a otra variable registro del mismo tipo. Además un registro puede ser pasado como parámetro a una función o prpcedimiento.
DECLARACIÓN DE UN REGISTRO:
La sintaxis de declaración de un registro es la siguiente:
Type
Tipo registro = Record
Campo1:Tipo1;
....
Campo N:TipoN;
End;
En donde:
TipoRegistro: Nombre de la estructura o dato del registro.
Campo: Lista de uno o mas campos separados por comas.
Tipo: Cualquier tipo de dato estándar o de finido por el usuario.
Por ejemplo:
Type
Alumno=Record
Nombre:String;
Edad:Integer;
Domicilio:String;
Grado:String[10]
Telefono:String[10];
End;
Esta declaración ha creado un tipo de dato llamado Alumno con cinco campos.
VARIABLE TIPO REGISTRO:
La de un registro por si solo no significa nada, para poder usar un registro es necesario que se declare una variable del tipo registro en el bloque Var, de la siguiente manera:
Var
NombreRegistro:TipoRegistro;
Por ejemplo, basándose en la declaración de registro anterior podríamos tener:
Var
Estudiante: Alumno;
Aux:Alumno;
ACCESAR A LOS CAMPOS DE UN REGISTRO:
Es importante saber como accesar a uno o más campos de un registro, la menera más común es la siguiente:
NombreRegistro.Campo
Por ejemplo:
Alumno.Nombre:='José María';
Alumno.Edad:=5;
Alumno.Domicilio:='Av. Angamos 325';
Alumno.Grado:='Primero';
Alumno.Telefono:='842564';
Cuando los datos ya están almacenados en el registro se puede manipular de forma similar a los otros datos en memoria.
LECTURA DE LOS CAMPOS DE UN REGISTRO:
Readln(Alumno.Nombre);
Readln(Alumno.Telefono);
ESCRITURA DE LOS CAMPOS DE UN REGISTRO:
Writeln(Alumno.Nombre);
Writeln('Nro. Telefononico: ',Alumno.Telefono);
Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:
Program Registro1;
Uses Crt;
Type
Alumno =Record
Nombre:String;
Edad:Integer;
Domicilio:String;
Grado:String[10]
Telefono:String[10];
End;
Var
DatosA;Alumno;
Begin
Clrscr;
(*Lectura de datos *)
Write('Nombre : ');Readln(DatosA.Nombre);
Write('Edad: ');Readln(DatosA.Edad);
Write('Domicilio: ');Readln(DatosA.Domicilio);
Write('Grado: ');Readln(DatosA.Grado);
Write('Telefono: ');Readln(DatosA.Telefono);
(*Escritura de los datos del registro*)
Clrscr;
Writeln('DATOS DEL ALUMNO ');
Writeln(DatosA.Nombre);
Writeln(DatosA.Edad);
Writeln(DatosA.Domicilio);
Writeln(DatosA.Grado);
Writeln(DatosA.Telefono);
Readkey;
End.
REGISTROS ANIDADOS:
En la construcción de un programa grande que maneje registros, a menudo nos tocaremos con la necesidad de tener registros anidados, eso quiere decir que es posible declarar un tipo registro con campos que sean otros registros.
Veamos la siguiente declaración:
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac:Fecha;
GrupoSangre:String[10];
End;
Var
DatosA;Alumno;
Obsérvese que la variable FechNac es de tipo Fecha la cual hemos declrado anteriormente. Otra forma de declarar el registro anterior sería.
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac=Record
dia,mes,anno:String[2];
End;
GrupoSangre:String[10];
End;
Lo malo de declarar un registro de esta manera (sin definición ni tipo) es que este no se puede mandar como parámetro.
COMO ACCESAR A REGISTROS ANIDADOS:
Para accesar a un campo de un registro anidado debemos de tener en cuenta la jerarquía de los registros, desde el nombre del registro principal (raíz) hasta el campo específico.
Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:
Program Registro2;
Uses Crt;
Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac:Fecha;
GrupoSangre:String[10];
End;
Var
DatosA;Alumno;
DatosEs:DatosEspecificos;
Procedure Leer;
Begin
Readln(DatosA.Apellidos);
Readln(DatosEs.FechNac.Dia);
End;
Procedure Escribir;
Begin
Writeln(DatosA.Apellidos);
Writeln(DatosEs.FechNac.Dia);
End;
Begin
Clrscr;
Leer;
Escribir;
Readkey;
End.
ARRAY DE REGISTROS:
En casos muy raros utilizaremos registros simples o unitarios, por lo general nos veremos en la necesidad de usar varios registros, la forma más adecuada de utilizar varios registros, la forma más adecuada de utilizar varios registros a la vez es mediante un arreglo de registro. El siguiente ejemplo detalla como podemos leer, escribir y manipular los datos de un arreglo:
Program Registro3;
Uses Crt;
Const
Max=10;
(*Declaracion del registro anidado*)
Type
Notas=Record
N1,N2,N3:Real;
End;
Alumno=Record
Nombres:String[30];
Nota:Notas;
Promedio:Real;
End;
(*declaracion del arreglo de registro*)
Type
ArrAlumn0=Array[1..MAx] of Alumno;
Var
i:Integer;
(*En el procedimiento leer se pasa como parámetro un arreglos de registros);
Procedure Leer(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Begin
Clrscr;
Write('Ingrese el nombre del alumno ',i,':');
Readln(A[i].Nombres);
Write('Nota 1:');Readln(A[i].Nota.N1);
Write('Nota 2:');Readln(A[i].Nota.N2);
Write('Nota 3:');Readln(A[i].Nota.N3);
End;
End;
{La función Promedio recibe como parámetro solo un registro por lo que el parámetro debe ser de tipo Alumno, es decir un solo registro; y devuelve el promedio}
Function PromedioA(Alu:Alumno):Real;
Begin
PromedioA:=(Alu.Nota.N1+Alu.Nota.N2+Alu.Nota.N3)/3;
End;
Procedure CalcularPromedio(Var Al:ArrAlum);
Procedure Escribir(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Al[i].Promedio:=PromedioA(Al[i]);
End;
Procedure Escribir(Var Al:ArrAlum);
Begin
For I:=1 To Max Do
Begin
Clrscr;
Writeln('Nombre del Alumno ',i,':',A[i].Nombres);
Writeln('Nota 1:',A[i].Nota.N1);
Writeln('Nota 2:',A[i].Nota.N2);
Writeln('Nota 3:',A[i].Nota.N3);
Writeln('Promedio: ',Al[i].Promedio:4:2);
Writeln;
End;
End;
(*Declaración de la variable Alum del tipo ArrAlum, arreglo de registros)
Var
Alum:ArrAlum;
Begin
Clrscr;
Leer(Alum);
CalcularPromedio(Alum);
Clrscr;
Escribir(Alum);
Readkey
End.
Como todo arreglo el proceso de lectura y escritura es mediante un bucle repetitivo, en este caso hemos usado la sentencia For, y se debe de leer cada uno de los datos, por separado.
Otro aspecto es que el campo Promedio no es ingresado por el usuario, si no que se calcula mediante el procedimiento CalcularPromedio, este procedimiento le pasa como referencia un registro (El registro actual ) a la función PromedioA, el cual con los datos de ese único registro calcula el promedio y lo retorna.
Debemos diferenciar en los parámetros de referencia de las funciones y procedimientos, ya que a los procedimientos se les pasa como parámetros un arreglo de registros (de tipo ArrAlum) mientras que a la Función solo se le pasa un registro (de tipo Alumno).
lunes, 16 de marzo de 2009
5to. SEC. I.E.P. CLARETIAMO 2009
domingo, 15 de marzo de 2009
SESIÓN 3 - 5TO. SEC. - 2009 - I.E.P. CLARETIANO
Caso1: Acción1;
Caso2:Acción2;
Caso3:Acción3;
CasoN:AcciónN:
End;
SESIÓN 2- 2009 5TO. SEC. I.E.P. CLARETIANO
lunes, 9 de marzo de 2009
I.E.P. CLARETIANO- TRUJILLO - 5TO. SEC. - SESIÓN 1 - 6/3/09
Es aquélla en la que una acción (instrucción) sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso. La estructura secuencial tiene una entrada y una salida. Su representación gráfica es la siguiente:
Estructura secuencial:
Acción 1
Acción 2
Acción 3
.......
PSEUDOCÓDIGO DE UNA ESTRUCTURA SECUENCIAL:
Inicio
:
:
acciones
:
:
fin
Ejemplo:
Calcular el salario neto de un trabajador en función del número de horas trabajadas, precio de la hora de trabajo y considerando unos descuentos fijos al sueldo bruto en concepto de impuestos (20%).
**Pseudocódigo**
· Inicio
· {cálculo salario neto}
· leer nombre, horas, precio_hora
· salario_bruto horas * precio
· salario_neto salario_bruto_impuestos
· escribir nombre, salario_bruto, salario_neto_bruto, salario_neto
· Fin
2. CONDICIONALES
La especificación formal de algoritmos tiene realmente utilidad cuando el algoritmo requiere una
descripción más complicada que una lista sencilla de instrucciones. Este es el caso cuando existen un número de posibles alternativas resultantes de la evaluación de una determinada condición.
Las estructuras selectivas se utilizan para tomar decisiones lógicas; de ahí que se suelan denominar también estructuras de decisión o alternativas.
En las estructuras selectivas se evalúa una condición y en función del resultado la misma se realiza una opción u otra. Las condiciones se especifican usando expresiones lógicas. La representación de una estructura selectiva se hace con palabras en pseudocódigo (if, then, else o bien en español si, entonces, sino), con una figura geométrica en forma de rombo o bien con un triángulo en el interior de una caja rectangular.
Las estructuras selectivas o alternativas pueden ser:
· Simples
· Doble
· Múltiples
2.1. ALTERNATIVA SIMPLE (SI−ENTONCES/IF−THEN).
La estructura alternativa simple si−entonces (en inglés if−then o bien IF−THEN ) ejecuta una determinada acción cuando se cumple una determinada condición. La selección si−entonces evalúa la condición y . .
Si la condición es verdadera, entonces ejecuta la acción S1 (o acciones caso de ser S1 una acción compuesta y constar de varias acciones)
Si la condición es falsa, entonces no hacer nada.
**PSEUDOCÓDIGO EN ESPAÑOL**
Si
Fin_si
PSEUDOCÓDIGO EN INGLÉS
If
end_if
2.2. ALTERNATIVA DOBLE ( SI−ENTONCES−SI_NO / IF − THEN − ELSE ).
Si la condición C es verdadera, se ejecuta la acción S1 y, si es falsa, se ejecuta la acción S2.
**PSEUDOCODIGO EN ESPAÑOL**
Si <> entonces
<>
si_no
fin_si
PSEUDOCODIGO EN INGLES.
If <> then
<>
else
<>
endif
2.3. ALTERNATIVAS MÚLTIPLES (SEGÚN _ SEA, CASO DE / CASE).
Cuando existen más de dos elecciones (alternativas) posibles, es cuando se presenta el caso de alternativas múltiples. Si el número de alternativas es grande puede plantear serios problemas de escritura del algoritmo y naturalmente de legibilidad.
La estructura de decisión múltiple evaluará una expresión que podrá tomar n valores distintos 1,2,3,4,..n .
Según que elija uno de estos valores en la condición, se realizará una de las n acciones, o lo que es igual, el flujo del algoritmo seguirá un determinado camino entre los n posibles.
**PSEUDOCÓDIGO**
En inglés la estructura de decisión múltiple se representa:
Case expresión of
[e1]: acción S1
[e2]: acción S2
:
[en]: acción Sn
else
acción Sx
end_case
Ejemplo:
Se desea diseñar un algoritmo que escriba los nombres de los días de la semana en función del valor de una variable DIA introducida por teclado.
Los días de la semana son 7; por consiguiente, el rango de valores de DIA será 1..7, y caso de que DIA tome un valor fuera de este rango se deberá producir un mensaje de error advirtiendo la situación anómala.
Inicio
Leer DIA
Según_sea DIA hacer
1:escribir('Lunes')
2: escribir('Martes')
3: escribir('Miércole')
4: escribir('Jueves')
5: escribir('Viernes')
6: escribir('Sabado')
7: escribir('Domingo')
else
escribir('Error')
fin_según
fin
3. ESTRUCTURAS REPETITIVAS.
Las estructuras que repiten una secuencia de instrucciones un número determinado de veces se denominan Bucles y se denomina Iteración al hecho de repetir la ejecución de una secuencia de acciones. Entre las estructuras repetitivas se encuentran:
· Mientras (while)
· Repetir (repeat)
· Desde (for)
3.1 ESTRUCTURA MIENTRAS (WHILE).
La estructura repetitiva while, es aquélla en que el cuerpo del bucle se repite mientras se cumple una determinada condición.
**Pseudocódigo en español Pseudocódigo en inglés**
Mientras condición hacer while condición do
Acción S1
Acción S2 :
: End_while
acción Sn
Fin_mientras
Ejemplo:
Contar los números enteros positivos introducidos por teclado. Se consideran dos variables enteras NUMERO y CONTADOR (contará el número de enteros positivos). Se supone que se leen números positivos y se detiene el bucle cuando se lee un número negativo o cero.
**PSEUDOCÓDIGO**
Inicio
contador 0
Leer (numero)
Mientras numero > 0 hacer
contador contador+1
Leer (numero)
Fin_Mientras
Escribir('El número de enteros positivos es : ', contador)
Fin
Son aquellos en que el número de iteraciones se conoce antes de ejecutarse el ciclo. La forma de esta estructura es la siguiente:
Ejemplo:
jueves, 5 de marzo de 2009
CLASE PARA QUINTO DE SECUNDARIA 2009 -I.E.P. CLARETIANO SESION 1 : - 4/3/09
Como ejemplo: podemos decir que la utilización de un directorio (Búsqueda de un teléfono). Para poder buscar un teléfono en un directorio, se debe conocer el algoritmo que se va a utilizar, es decir la forma en que están codificados los nombres de las personas, para así lograr encontrarlos y localizar el número telefónico
Como ejemplo podemos citar los pasos para resolver una ecuación de segundo grado, los pasos lógicos y secuenciales para obtener una nomina.
El nombre es quien identifica la variable en todo el transcurso del algoritmo, y son un conjunto de caracteres, letras y números. Dicho nombre debe ser mnemotécnico, es decir, que con solo leer el nombre de la variable se pueda entender o determinar con facilidad lo que ella significa o contiene. Como ejemplo podemos decir la Variable VrHr significa a simple vista Valor de la Hora; pero si fuese X o HH, estos nombres pueden significar muchas cosas o, a la vez, no significar nada.
El valor es la cantidad que una variable representa o tiene asociada en un momento determinado. Se debe tener en cuenta que una variable también puede tener asociado un valor lógico como falso o verdadero
4. CONSTANTES:Son todos aquellos valores que no cambian en el transcurso de un algoritmo y son introducidos en el momento de utilizarse.
En determinados casos se puede presentar que el valor de una variable no cambie en el transcurso de un algoritmo; pero por este hecho no se considera constante, sigue siendo una variable, porque su valor puede cambiar y las constantes no lo pueden hacer.