Source: http://html.rincondelvago.com/programacion_9.html
Timestamp: 2017-08-16 13:21:26+00:00

Document:
Algoritmos. Resolución de problemas. Programación estructurada. Estructuras de datos
unidad I: Algoritmo y Programas
1.1 consideraciones acerca de la computabilidad
1.3 datos, tipos de datos y operaciones
1.4 constantes y variables
1.5 funciones internas
1.6 floorchart S.O.B
unidad II: Resolución de problemas con comp. y herramientas de programación
2.3 Diseño de algoritmo
2.4 Representación grafica de algoritmos: diagrama de flujo (floor chart)
unidad III: Estructura gral. de un problema
3.1 Concepto de programa
3.2 Partes constitutivas de un programa
3.3 instrucciones y tipos de análisis de problemas modelos
3.4 escritura de algoritmos - Programas
Unidad IV: Introducción a la programación estructurada
4.1 técnicas de prog.
4.2 Prog. Modular
4.3 Prog estructurada
4.4 estructura secuencial
4.5 estructuras selectivas
4.6 estructuras repetitivas
4.7 estructuras repetitivas anidadas
Unidad V: Programas Procedimientos y funciones
5.1 Introducción a los subalgoritmo
5.4 funciones y procedimientos como parámetros
5.5 Recursividad
2.1 La sintaxis de pascal
2.2 estructuras de un programa en pascal
2.4 Los símbolos en pascal
2.4.1 Palabras reservadas
2.4.2 Símbolos reservados
2.4.3 identificadores
2.4.4 comentarios
2.4.5 encabezados
3.1.1 Tipo real
3.1.2 Tipo entero
3.1.3 Tipo carácter
3.2 Operaciones y funciones para caracteres
3.2.1 tipo booleano
3.2.2 Tipos definidos por el usuario
3.2.3 Tipo constante
Unidad IV Expresiones y declaraciones
4.1.1 Expresiones aritméticas
4.2 Uso de definiciones estándares
4.3 Expresiones boleanos
4.3.1 Reglas básicas del álgebra boleano
4.4 Declaraciones
Unidad V Instrucciones de entrada y salida
5.1 Instrucciones Read y readln
5.2 Instrucciones write y writeln
Unidad VI Estructuras de control
6.1 Declaraciones repetitivas
6.1.1 Declaración repeat
6.1.2 Declaración While
6.1.3 Declaración While y repeat
6.1.4 Declaración For
6.2 Declaraciones condicionales
6.2.1 Declaraciones Case
6.2.2 Declaraciones Case Else
{programa que calcula la suma de dos números}
N1,N2:interger;
Writeln(`capruta el primer numero:');
Readln(N1)
Writeln(`dame el segundo numero:');
T:=N1+N2;
Writeln(`la suma de dos números es:',T:7:0);
{programa que captura un nombre}
N:string[6]
Writeln(`captura el nombre:');
Writeln(`Captura el apellido:');
Writeln(`tu nombre es:',N,A);
{programa que convierte pesos a dólares}
TC=9.8;
P,D:real;
Writeln(`conversión de peso a dólar');
Writeln(`captura la cantidad en pesos:');
D:=P/TC;
Writeln(`la cantidad en dólar es :',D:6:0);
{programa que calcula el promedio de dos calificaciones}
C1,c2,p:real;
Writeln(`dame tu primera calificación:');
Writeln(`dame tu segunda calificación:');
P:=(c1+c2)/2;
Writeln(`tu promedio es :',p:7:0);
Writeln(`trata de mejorar');
{programa de datos personales}
N,ap,am,d,p:string[50];
Writeln (`dime tu nombre:');
Writeln (`cual es tu apellido paterno:');
Readln(ap);
Writeln(`cual es tu apellido materno:');
Readln(am);
Writeln(`cual es tu domicilio:');
Writeln(`cual es tu ocupación:');
Writeln(`que año naciste:');
Writeln(`tu eres:',n:,' `,ap:,' `,am);
Writeln(`vives en:',d);
Writeln(`eres:',p);
Writeln(`naciste en el año de:',a);
E:=2002-a;
Writeln(`tienes la edad de:',e);
Program prog6
{PROGRAMA que captura el sueldo de un empleado}
Nde,rfc,d,p,pr:string[50];
Sh,dt,sd,ss,sq:real;
Ht:integer;
Writeln(`nombre del empleado:');
Readln(nde);
Writeln(`cual es su rfc:');
Readln(rfc);
Writeln(`cual es su domicilio:');
Writeln(`cual es su puesto:');
Writeln(cual es su profesión:');
Writeln(`cual es su sueldo por hora:');
Writeln(`cuantas horas trabaja al día:');
Writeln(`cuantos días trabaja a la semana:');
Writeln(`el nombre del empleado”a” es:',nde);
Writeln(`su rfc es :',rfc);
Writeln(su domicilio es :',d);
Sd:=sh*ht;
Writeln(`su sueldo diario es de:',sd:2:0);
Ss:=sd*dt;
Writeln(`su sueldo semanal es de:',ss:2:0);
Sq:=ss*2;
Writeln(`su sueldo quincenal es de:',sq:2:0);
Writeln(`***siga trabajando casi es millonario***');
Program prog7
{datos personales};
N,d,t:string[20]
Writeln(`cual es tu nombre:');
Writeln(`cual es tu numero telefónico:');
Writeln('te llamas:',n);
Writeln(vives en:',D);
Writeln(`tu numero de teléfono es:',t);
Program prog8
{obtener el producto de dos números}
N1,n2,p:real;
Writeln(`cual es el primer numero:');
Writeln(`cual es el segundo numero:');
Writeln(`el producto es:',p);
Program prog9
{Conversión de metros a centímetros};
R,m:real;
Writeln(`cuantos metros:');
R:=m*cm;
Writeln(`son:',r:4:2);
Program prog10
{conversión de millas a kilómetros};
Mi,r:real;
Km=1.609;
Writeln(`cuantas millas son:');
Readln(mi);
R:=km*mi;
Writeln(`son en km:',r:5:3);
{programa que obtiene la suma de dos exámenes}
Ex1,ex2,s:real;
Writeln('calificación de el examen 1');
Readln(ex1);
Writeln('calificación de el examen 2');
Readln(ex2);
S:=ex1+ex2;
Writeln('la suma de los exámenes es:',s:3:1);
If s>=80 then
Writeln('el alumno esta aceptado');
Writeln('el alumno esta rechazado');
{programa que obtiene la comisión de una persona que vende libros}
A,b,x,z:real;
Writeln('el costo de los libros es');
Readln(x);Writeln('los libros vendidos son ');
Writeln('la ganancia obtenida por los libros vendidos es:', '$',z:3:2);
If z>= 1500 then
A:=(z*c)/100;
Writeln('su comisión es de el 20%');
Writeln('su ganancia es');
Writeln('$',a:3:2);
B:=(z*d)/100;
Writeln('su comisión es de el 10%');
Writeln('$',b:3:2);
Program prog13;
{programa que elebora boleta segun caracteristicas del alumno}
Writeln('Nombre de el alumno:');
Writeln('Semestre:');
Writeln('Asistencia Total:');
Writeln('promedio final:');
If (a>=80) and (p>=7) then
Writeln('******SE ELABORA BOLETA******');
Writeln('Nombre:',n);
Writeln('Semestre:',S);
Writeln('Asistencia:',A:3:0,'%');
Writeln('promedio final:',p:3:1);
Writeln('***NO SE ELABORA BOLETA***');
Program prog14;
{PROGRAMA QUE DESPLIEGA LA POBLACION DE UN ALUMNO SEGUN SUS CARACTERISTICAS}
Writeln('Nombre alumno:');
Writeln('Edad:');
If (p>6) and (p<8) and (e>6) and (e<8) then
Writeln('***** POBLACION "A" *********');
Writeln('edad:',e:3:0);
Writeln('Promedio:',p:3:1);
If (P=8) and (e=8) then
Writeln('****** POBLACION "B" ********');
Writeln('Alumno:',N);
Writeln('********* POBLACION "C" **********');
Program prog15
{determina si un numero es positivo, negativo o igual a cero};
Writeln('Dame un numero:');
Writeln('El numero es positivo:');
Writeln('el numero es negativo:');
Writeln('el numero es cero:');
Program prog16
{programa que captura 3 numeros y determina si es mayor menor o igual};
Writeln('Dame el primer numero:');
Writeln('dame el segundo numero:');
Writeln('dame el ultimo numero:');
If (n1>n2) and (n1>n3) then
Writeln('el mayor es el primero:',n1:4:2);
If (n2>n1) and (n2>n3) then
Writeln('el mayor es el segundo:',n2:4:2);
If (n3>n1) and (n3>n2) then
Writeln('el mayor es el tercero:',n3:4:2);
If (n1=n2) and (n2=n3) then
Writeln('los numeros son iguales:');
If (n1=n2) and (n1>n3) then
Writeln('el primero y el segundo son iguales y mayores que el tercero');
If (n1=n3) and (n1>n2) then
Writeln('el primero y el tercero son iguales y mayores que el segundo numero');
If (n2=n3) and (n2>n1) then
Writeln('el segundo y el tercero son iguales y mayores que el primero');
Program prog17
{programa que suma,resta,multiplica o divide dos numeros};
N1,n2,s,r,m,d:real;
Writeln(' * OPCIONES *');
Writeln(' 1 - SUMA');
Writeln(' 2 - RESTA');
Writeln(' 3 - MULTIPLICACION');
Writeln(' 4 - DIVISION');
Writeln(' 5 - SALIDA');
1:BEGIN;
Writeln(' * SUMA *');
WRITELN('CAPTURA EL PRIMER NUMERO');
Writeln('CAPTURA EL SEGUNDO NUMERO');
S:=N1+N2;
Writeln('EL RESULTADO ES: ',S:6:2);
2:BEGIN;
Writeln(' * RESTA *');
R:=N1-N2;
Writeln('EL RESULTADO ES: ',R:6:2);
3:BEGIN;
Writeln(' * MULTIPLICACION *');
M:=N1*N2;
Writeln('EL RESULTADO ES: ',m:6:2);
4:BEGIN;
Writeln(' * DIVISION *');
D:=N1/N2;
Writeln('EL RESULTADO ES: ',D:6:2);
5:BEGIN;
Writeln('*ADIOS*');
Program prog18
{programa que calcula el área de un triangulo, cuadrado o circulo};
A,t,c,cu,b,al,r:real;
Writeln(' *menu*');
Writeln(' 1 - triangulo');
Writeln(' 2 - cuadrado');Writeln(' 3 - circulo');
Writeln(' 4 - salida');
Writeln('seleccione una opción');
Writeln(' *triangulo*');
Writeln('que tamaño es la base');
Writeln('que tamaño es la altura');
T:=(b*al)/2;
Writeln('el área del triangulo es: ',t:6:2);
Writeln('cuadrado');
Writeln('que medida tiene uno de sus lados');
Cu:=b*b;
Writeln('el área del cuadrado es: ',cu:6:2);
Writeln(' *circulo*');
Writeln('que tamaño es el radio del circulo');
C:=pi*(r*r);
Writeln('el área del circulo es: ',c:6:2);
{menú de opciones para obtener el sueldo diario de una persona, su edad o la conversión de pesos a dólares}
S,st,p,c,d:real;
Op,h,a1,a2,e:integer;
Writeln('menu de opciones');
Writeln(' 1- sueldo diario de una persona');
Writeln(' 2- edad de una persona');
Writeln(' 3- conversión de pesos a dólares');
Writeln(' 4- salir');
Writeln('seleccione una opción y presione enter');
Writeln('sueldo diario de una persona');
Writeln('sueldo por horas de trabajo');
Writeln('horas trabajadas al dia');
St:=s*h;
Writeln('el sueldo diario de esta persona es:$',st:3:2);
Writeln('edad de una persona');
Writeln('año de nacimiento');
Writeln('año actual');
E:=a2-a1;
Writeln('su edad es:',e,'años');
Writeln('conversion de pesos a dolares');
Writeln('la cantidad en pesos es:');
Writeln('tipo de cambio actual');
D:=p/c;
Writeln('la cantidad en dolares es:$',d:3:2);
Writeln('precione "enter" para salir');
{programa que calcula el cuadrado, la raiz cuadrada y el coseno de un numero}
N,r,cuad,c:real;
Writeln('***menu de opciones***');
Writeln(' 1- cuadrado');
Writeln(' 2-raiz cuadrada');
Writeln(' 3-coseno');
Writeln('***seleccione una opcion y precione "enter"***');
Writeln('***cuadrado***');
Writeln('capturar numero');
Cuad:=sqr(n);
Writeln('el cuadrado de el numero es:',cuad:3:2);
Writeln('***raiz cuadrada***');
Writeln('la raiz cuadrada de el numero es:',r:3:2);
Writeln('***coseno***');
C:=cos(n);
Writeln('el coseno de el numero es:',c:3:2);
Writeln('desea seguir capturando <s/n>');
Until(resp <>'s') and (resp <>'s');
{programa que suma o multiplica}
N1,n2,s,r:real;
Writeln('1 - suma');
Writeln('2 - multiplicacion');
Writeln('3 - salir');
Writeln('******suma*******');
Writeln('capturar el primer numero');
Writeln('capturar el segundo numero ');
Writeln('el resultado de la suma es:',s:3:2);
Writeln('**multiplicacion**');
Writeln('capturar el segundo numero');
R:=n1*n2;
Writeln('el resultado de la multiplicacion es :',r:3:2);
{descuento a un empleado segun faltas}
Z=0.20;
E=0.15;
Nom,c:string;
Nuem,op:integer;
D,x,des,ht,dt,sh,sq,sd:real;
Writeln('capturar nombre');
Writeln('capturar # de empleado');
Readln(nuem);
Writeln('capturar categoria');
Writeln(' ***menu***');
Writeln('1 - de 6 a 8 faltas');
Writeln('2 - de 1 a 5 faltas');
Writeln('capturar numero de horas trabajadas al dia');
Writeln('capturar sueldo por hora ');
Writeln('capturar dias trabajados a la quincena');
Sq:=sh*ht*dt;
D:=(sq*z);
Sd:=ht*sh;
Des:=sq-d;
Writeln('***datos***');
Writeln('nombre:');
Writeln('puesto');
Writeln('sueldo diario ');
Writeln(sd:3:2);
Writeln('descuento dela quincena');
Writeln(d:3:2);
Writeln('sueldo quincenal');
Writeln(des:3:2);
D:=(sq*y);
Writeln('desea seguir capturando s/n');
Until (resp<>'s') and (resp<>'s');
{programa que realiza descuentos segun el codigo del articulo}
N,a,b,c,d:string;
P,t,t1:real;
Writeln('el nombre de el articulo es:');
Writeln('el precio de el articulo es:');
If (p>=5000) then
Writeln('el articulo ', n ,' pertenece a el codigo a');
T:=(p*30)/100;
T1:=p-t;
Writeln('el precio es :',p:3:2);
Writeln('el descuento fue del 30% esto es :',t:3:2);
Writeln('el precio final es :',t1:3:2);
If (p>=3000) and (p<5000) then
Writeln('el articulo ', n ,' pertenece a el codigo "b"' );
T:=(p*20)/100;
Writeln('pertenece al codigo b');
Writeln('',n);
Writeln('el precio es ',p:3:2);
Writeln('el descuento fue del 20% esto es :',t:3:2);
If (p>=2000) and (p<3000) then
Writeln('el articulo ', n ,' pertenece a el codigo "c"');
T:=(p*10)/100;
Writeln('pertenece al codigo c');
Writeln('el descuento fue del 10% esto es :',t:3:2);
If (p<2000) then
Writeln('el articulo ', n ,' pertenece a el codigo "d"');
T:=(p*5)/100;
Writeln('el descuento fue del 5% esto es :',t:3:2);
Writeln('presione enter para salir');
{programa que calcula el porcentaje de comision de cuatro empleados}
Vta,total,pv:real;
Cv,ce:integer;
Ce:=1;
While ce<=4 do
Writeln('nombre');
Cv:=0;
Writeln('ventas');
Readln(vta);
Total:=total+vta;
Cv:=cv+1;
Until cv=3;
Pv:=total*0.005;
Writeln('su nombre es:',nom);
Writeln('el total de ventas es:',total:2:2);
Writeln('el porcentaje de la venta es:',pv:2:2);
Program prog25
{programa que calcula el promedio de 3 calificaciones de 2 alumnos};
M,s,n:string[15];
X,ca,c:integer;
P,total:real;
While ca<=2 do
Writeln('semestre que cursa');
Writeln('nombre de la materia');
Writeln('calificacion');
Total:=total+c;
Until x=3;
P:=total/3;
Writeln('nombre: ',n);
Writeln('semestre que cursa: ',s);
Writeln('nombre de la materia: ',m);
Writeln('el promedio de calificaciones: ',p:2:2);
Writeln('presione "enter" para salir');
Program prog26
{programa que calcula el total de 3 carros};
M,c,mar,p:string[15];
Pre,t,tot,imp:real;
While cc<=3 do
Writeln('programa que calcula el precio de 3 carros');
Writeln('modelo del carro');
Writeln('marca del carro');
Readln(mar);
Writeln('cilindros del carro');
Writeln('puertas del carro');
Writeln('precio del auto');
T:=t+pre;
Imp:=t*0.15;
Tot:=t+imp;
Writeln('el subtotal de los 3 carros es:', t:3:2);
Writeln('el impuesto del 15% a los carros es de:', imp:3:2);
Writeln('el total de los carros con impuestos es de :', tot:3:2);
Program prog27
{programa que calcula el precio de 4 peliculas};
Cp,cc,ca:integer;
P,t,tot,st:real;
Mem,c,np,cla:string[15];
While cc<=2 do
Writeln('nombre del cliente');
Writeln('numero de membresia');
Readln(mem);
Cp:=0;
Writeln('nombre de pelicula');
Writeln('categoria de la pelicula "1,2,3"');
Readln(ca);
Writeln('clasificacion de la pelicula');
Readln(cla);
Writeln('precio de la pelicula');
If ca=1 then
Tot:=p*0.3;
St:=p-tot;
If ca=2 then
Tot:=p*0.2;
If ca=3 then
Tot:=p*0.1;
T:=t+st;
Cp:=cp+1;
Until cp=4;
Writeln('el total a pagar por 4 peliculas es de:', t:3:2);
Writeln('el programa ha concluido, presione enter para salir');
Program prog28
{programa que calcula la suma y el descuento de 8 articulos};
Pre,t,tot,des:real;
Ca:integer;
While ca<=8 do
Writeln('nombre del articulo');
Writeln('precio del articulo');
Tot:=tot+pre;
If (tot>=2000) then
Des:=tot*0.1;
T:=tot-des;
Writeln('el total de los articulos es de:', tot:3:2);
Writeln('el descuento del 10% por ser mayor de 2000 es de:', des:3:2);
Writeln('el total a pagar es de:', t:3:2);
If (tot<2000) then
Program prog29
{programa que calcula el precio de prendas en una limpiaduria};
Lun=0.05;
Mar=0.07;
Mie=0.08;
Jue=0.09;
Vie=0.1;
Pan=30;
Cha=50;
Blu=20;
Cam=25;
Ves=40;
Fal=60;
Sac=80;
T,st,des,pan1,cha1,blu1,cam1,ves1,fal1,sac1:real;
Writeln(' limpiaduria');
Writeln('cantidad de pantalones entregados');
Readln(pan1);
Writeln('cantidad de chammarras entregadas');
Readln(cha1);
Writeln('cantidad de blusas entregadas');
Readln(blu1);
Writeln('cantidad de camisas entregadas');
Readln(cam1);
Writeln('cantidad de vestidos entregados');
Readln(ves1);
Writeln('cantidad de faldas entregadas');
Readln(fal1);
Writeln('cantidad de sacos entregados');
Readln(sac1);
Writeln('1 - lunes');
Writeln('2 - martes');
Writeln('3 - miercoles');
Writeln('4 - jueves');
Writeln('5 - viernes');
Writeln('escoja una opcion');
St:=(pan1*pan)+(cha1*cha)+(blu1*blu)+(cam1*cam)+(ves1*ves)+(fal1*fal)+(sac1*sac);
Des:=lun*st;
T:=st-des;
Writeln('** lunes **');
Writeln('pantalones entregados:', pan1:2:0);
Writeln('chamarras entregadas:', cha1:2:0);
Writeln('blusas entregadas:', blu1:2:0);
Writeln('camisas entregadas:', cam1:2:0);
Writeln('vestidos entregados:', ves1:2:0);
Writeln('faldas entregadas:', fal1:2:0);
Writeln('sacos entregados:',sac1:2:0);
Writeln('total de articulos:', st:3:2);
Writeln('descuento del dia lunes:', des:3:2);
Writeln('total a pagar:', t:3:2);
Des:=mar*st;
Writeln('** martes **');
Writeln('descuento del dia martes:', des:3:2);
Des:=mie*st;
Writeln('** miercoles **');
Writeln('descuento del dia miercoles:', des:3:2);
Des:=jue*st;
Writeln('** jueves **');
Writeln('descuento del dia jueves:', des:3:2);
Des:=vie*st;
Writeln('** viernes **');
Writeln('descuento del dia viernes:', des:3:2);
Program prog30
{programa que calcula el promedio de un alumno con 3 calificaciones};
Sum,cal,prom:real;
Ccal:integer;
Write('nombre del alumno: ');
Ccal:=1;
While ccal<=3 do
Write('calificacion',ccal,': ');
Sum:=sum+cal;
Ccal:=ccal+1;
Prom:=sum/3;
Writeln('alumno:',nom);
Writeln('el promedio es:',prom:2:2);
PROGRAM PROG31
{PROGRAMA QUE CONVIERTE MINUTOS A SEGUNDOS};
min,seg:real;
write('Deseas convertir minutos a segundos: ');
Write('Captura los minutos:');
seg:=min*60;
Writeln('',min:2:2,' minutos son ',seg:2:2,' segundos');
writeln('Desea seguir capturando');
PROGRAM PROG32;
{PROGRAMA QUE CAPTURA NOMBRES Y SE SALE EN UN NOMBRE DETERMINADO}
N,NOM,hector:STRING[12];
WRITELN('DAME NOMBRE');
N:=NOM;
UNTIL (NOM='HECTOR') OR (NOM='hector');
program prog33
{programa que calcula la raiz cuadrada de un numero};
raiz:real;
raiz:=sqrt(num);
writeln('La raiz cuadrada de',num:3,' es :',raiz:2:2);
program prog34
{programa que calcula la tabla del 2};
res:=2*i;
writeln(`2 x `,i:3,' es :',res:2:2);
program prog35
{programa que calcula el cuadrado de un numero};
cua:real;
cua:=sqr(num);
writeln('El cuadrado de',num:3,' es :',cua:2:2);
program prog36
{programa que despliaga los numeros del 1 al 100};
write(' ',i:3);
program prog37
{programa que calcula la tabla de multiplicar de cualquier numero};
num,res:real;
writeln('Que numero deseas utilizar para calcular su tabla');
writeln('',num:2:2,' x',i:2,' es: ',res:2:2);
program prog38
{reciproco de los numeros 1 al 25};
res:=1/i;
writeln('1/',i:2,' es igual a:',res:2:3);
program prog39
{programa que calcula el cuadrado de veinte numeros apartir de un numero x};
write('Desde que numero deseas empezar: ');
res:=sqr(num);
writeln('el cuadrado de ',num:2:2,' es:', res:2:2);
program prog40
{programa que depliega numeros del 1 - 500};
num,x,y:integer;
for num:=1 to 500 do
if (y=26) then
program prog41;
{programa que captura la tabla de multiplicar del 2 y 3}
x,p,i,j:integer;
x:=2; p:=0;
p:=x*j;
writeln('',x,' * ',j,'=',p);
program prog42
{programa que calcula el promedio de 4 calificaciones};
prom,cal,tot:real;
writeln('calificacion ',i:1,':');
tot:=tot+cal;
prom:=tot/4;
writeln('el promedio de las 4 calificaciones es:',prom:2:2);
Algoritmo, en matemáticas, método de resolución de cálculos complicados mediante el uso repetido de otro método de cálculo más sencillo. Ejemplos básicos son los métodos para efectuar operaciones aritméticas (multiplicación, división, obtención de raíces cuadradas...), la obtención del máximo común divisor y del mínimo común múltiplo de un número mediante su descomposición en factores primos, y la división de un polinomio por x - a mediante la regla de Ruffini. En la actualidad, el término algoritmo se aplica a muchos de los métodos de resolución de problemas que emplean una secuencia mecánica de pasos, como en el diseño de un programa de ordenador o computadora. Esta secuencia se puede representar en forma de un diagrama de flujo para que sea más fácil de entender.
En las computadoras con lógica de microordenadores incorporada, esta lógica es un tipo de algoritmo. A medida que los equipos informáticos se hacen más complejos, más y más algoritmos del software toman la forma del llamado hard-software. Esto es, cada vez más, se están convirtiendo en parte de los circuitos básicos de los ordenadores o en módulos auxiliares; también están apareciendo por sí solos en máquinas específicas como las calculadoras de nóminas. En la actualidad, existen muchos algoritmos para diversas aplicaciones y algunos sistemas avanzados, como los algoritmos de inteligencia artificial, llegarán a ser corrientes en el futuro.
Un algoritmo es una serie de operaciones detalladas y no ambiguas, a ejecutar paso a paso y que conducen a la resolución de un problema, en otras palabras es un conjunto de reglas para resolver una cierta clase de problema o forma de escribir el problema.
Consiste en dos partes esenciales:
Una descripción de acciones que deben ser ejecutadas y una descripción de los datos que son manipulados por esas acciones; las acciones se describen mediante, las llamadas sentencias y datos mediante declaraciones y definiciones.
- Características de algoritmos -
a) un algoritmo debe ser preciso e indicar el orden de realización de cada paso
b) un algoritmo debe estar definido, si se sigue un algoritmo 2 veces se debe tener el mismo resultado
c) un algoritmo debe ser finito, si se sigue un algoritmo se debe terminar en algun momento.
Diagrama de flujo de datos: Una técnica de diseño que permite la documentación de un sistema o programa en varios niveles de generalidad.
Diagrama de flujo: Un diagrama que ilustra el flujo de datos, información y trabajo por medio de símbolos especializados que, cuando se conectan por líneas de flujo, reflejan la lógica de un sistema o programa.
Los diferentes objetos de información que Pascal utiliza para trabajar se conocen con el nombre de datos. Cada uno de estos objetos tendrá un tipo de datos diferente acorde con su información. Según del tipo de información de que se trate, podría ser un número, una letra, etc.
Determinar como ejecutar las operaciones.
Determinar el rango de valores que puede tomar una variable
Reservar en memoria el espacio correcto para cada tipo de datos.
En pascal todos los datos que se vayan a utilizar deben de tener sus tipos declarados previamente.
Byte: Números enteros comprendidos entre 0 y 255.
Integer: Enteros entre -32768 y 32767.
Longint: Enteros entre -2.147.483.648 y 2.147.483.647
Word: Enteros positivos entre 0 y 65535.
Los tipos de datos reales representan al conjunto de los números reales. Todo número se puede representar como un real, aunque su representación interna no es la misma.
Real: 2.910-39 ... 1.71038 (11-12 cifras)
Single: 1.510-45 ... 3.41038 (7-8 cifras)
Double: 5.010-324 ... 1.710308 (15-16 cifras)
Extended: 1.910-4932 ... 1.1104932 (19-20 cifras)
Comp: -2-63 + 1 ... 263 - 1 (19-20 cifras)
NUMERICO CADENA DE CARACTERES LOGICOS
REALES ENTEROS
DECIMALES COMA FLOTANTE
Es una colección de elementos de datos el medio en que se relacionan unos elementos con otros determina el tipo de estructura de datos.
Un elemento o dato es la cantidad que toma un único elemento que puede cambiar de cuando en cuando (se denomina variable).
Las estructuras de datos mas usuales son cadenas matrices, listas, tablas, árboles, pilas, colas y ficheros.
Entrada/salida: cualquier tipo de introducción de datos en la memoria desde los periféricos, “entrada” o registro de la información procesada en un periférico salida.
Lecturas tarjeta perforada, indica inicio y final del programa.
Conector (sirve para enlazar 2 partes cualesquiera de un organigrama a través de un conector en la salida y otro en la entrada, se refiere a la conexión en la misma página del diagrama
Símbolo de enlace de comunicaciones, es usado para uní terminales remotas con los sistemas de comunicación.
Línea de flujo: indica el sentido de ejecución de la operación
Línea conectora: sirve de unión entre 2 símbolos.
Terminal (representa el comienzo,<<inicio>>, y el final, <<fin>> de un programa, puede representar también una parada o interrupción programado que sea necesario realizar en un programa.
Proceso (cualquier tipo de operación que pueda originar cambio de valor formato o posición de la información almacenada en la memoria, operaciones aritméticas de transferencia, etc.
Conector (conexión entre 2 puntos del organigrama situado en las paginas diferentes.
Impresora (se utiliza en ocasiones en lugar del símbolo de E/S
Teclado, se utiliza para añadir en lugar del símbolo de E/S
Fuente de un programa desde un lenguaje de alto nivel a un código objeto antes de la ejecución del programa. El código objeto es un código máquina ejecutable. De manera más general, compilar suele utilizarse para describir la traducción de cualquier descripción simbólica de alto nivel a un formato simbólico de bajo nivel o legible por una máquina. Un programa que realiza esta función se denomina compilador.
Las personas tienen una gran capacidad para compensar los errores sufridos por los datos transmitidos. Es posible mantener una conversación entre dos individuos aun cuando sólo llegue intacto un 30% de los datos. Los ordenadores están en el otro extremo del espectro. Un único error de transmisión puede echar por tierra todo un diálogo. Por tal razón, la comprobación y prevención de errores constituye un requisito básico de cualquier tipo de comunicación de datos.
Realiza una instrucción o pasar un programa en un ordenador
Programación de computadoras es el proceso de planificar una secuencia de instrucciones que ha de surgir en una computadora.
Un programa es la secuencia de instrucciones que indica las acciones que ha de ejecutar la computadora.
Se podría considerar la programación como el conjunto de actividades y operaciones realizadas por el personal de informáticos tendientes a influir a la maquina para que puedan realizar las funciones en el algoritmo
Un programa en lenguaje pascal esta dividido en secciones:
Program_____cabecera del programa
Uses________ unidades
Label_______ etiquetas
Const_______ declaración de constantes
Type________ tipos;
Var__________declaración de variables;
Procedure____ procedimientos;
Funtion______ Funciones
*Sentencia Program:
Especifica el nombre del programa, que puede ser un nombre de solo 63 caracteres
EJ: program prog1.
*Sentencia uses:
Indica que unidades son usadas por el programa la unidad mas utilizada es para pantalla
EJ: Uses crt;
*Sentencia label:
Generalmente no se utiliza Ej: label A (A es la etiqueta)
*Sentencia Const:
Se declaran cualquiera de las constantes que se vayan a utilizar siempre se utiliza el “=”
EJ: IVA=.10
*Sentencia Type:
En esta se pueden crear y declarar sus propios tipos de datos EJ: Nombre = string[35]
Var N:nombre
*Sentencia Var:
Se declaran los nombres y tipos de variables que se van a usar en el programa
EJ: var: Num1, num2: integer;
Un compilador es un programa que traduce el programa fuente(conjunto de instrucciones de un lenguaje de alto nivel copol y pascal) a programa objeto(instrucciones a un lenguaje maquina que la computadora pueda interpretar y ejecutar)
El compilador efectúa solo la traducción, no ejecuta el programa.
Un intérprete es un programa que procesa los programas escritos en un lenguaje de alto nivel sin embargo esta diseñado de modo que no existe independencia entre la etapa de traducción y cada ejecución.
En cualquier lenguaje de alto nivel en que se escriba un programa este debe ser traducido al lenguaje maquina antes de ser ejecutado.
Esta confección de instrucciones de alto nivel a instrucciones de nivel de maquina se hace por programas del software del sistema denominados compiladores e interpretes.
Estos programas especiales se denominan traductores.
La modificación del programa fuente es muy sencilla en el interprete, mientras que en el compilador además de la modificación con el programa, esto es, será necesario crear un programa compilado, esto significa que para comprobar el funcionamiento de un programa una vez modificado habrá que volver a compilarlo
Las ejecuciones sucesivas de un programa compilado no necesita traducciones del programa fuente. como el interprete no produce un programa objeto se debe realizar el proceso de reducción cada vez que se ejecuta un programa.
Los lenguajes de bajo nivel permiten crear programas muy rápidos, pero que son a menudo difíciles de aprender. Más importante es el hecho de que los programas escritos en un bajo nivel son prácticamente específicos para cada procesador. Si se quiere ejecutar el programa en otra máquina con otra tecnología, será necesario rescribir el programa desde el principio.
Programación orientada a objetos, en informática, un estilo de programación en el que un programa se contempla como un conjunto de objetos limitados que, a su vez, son colecciones independientes de estructuras de datos y rutinas que interactúan con otros objetos. Una clase define las estructuras de datos y rutinas de un objeto. Un objeto es una instancia de una clase, que se puede usar como una variable en un programa. En algunos lenguajes orientados a objetos, éste responde a mensajes, que son el principal medio de comunicación. En otros lenguajes orientados a objeto se conserva el mecanismo tradicional de llamadas a procedimientos.
Programa fuente: Código del programa original.
Programa objeto: Un programa a nivel de lenguaje máquina que resulta de la compilación de un programa fuente.
1- ¿Qué es un diagrama de flujo?
Es un cuadro que explica paso por paso la secuencia de un objeto o programa
2- ¿Qué es un algoritmo?
Es una serie de operaciones detallistas y no ambiguas, a ejecutar paso por paso y que conducen a la resolución de un problema, es un conjunto de reglas para resolver un problema
3- ¿Cuáles son las características de los algoritmos?
Un algoritmo debe ser ordenado paso a paso, si se sigue un algoritmo 2 veces debe tener el mismo resultado y debe ser finito
4- ¿Cuáles son las partes esenciales de los algoritmos?
Acciones, las cuales son o deben ser ejecutadas mediante las llamadas sentencias; descripciones de datos que funcionan por medio de declaraciones y definiciones
5- Menciona los tipos de datos y especifique cada uno
Numérico, son los datos los cuales son números reales (decimales o fracciones) y enteros; caracteres, son datos de puras letras; lógicos, es mezcla de números y letras.
6- Cuales son los métodos para la resolución de problemas por computadora
Se utiliza un algoritmo complejo, conduce a la escritura de un programa y su ejecuciones la misma
7- Menciona las partes de un programa
program, uses, label, const, var, type, procedure, function
8- ¿Que es programación?
Conjunto de actividades y operaciones realizados por el personal inform. Tendientes a instruir a la maquina para que pueda realizar las funciones previstas en el algoritmo
9- ¿A que se le llama estructura de datos?
A una colección de datos relacionados entre si por ejemplo: cadena, tablas, árboles, pilas.
Sentencia: la instrucción para realizar uno o mas problemas.
Compilar: traduce todos los códigos fuente de un programa
Interprete: procesa los programas escritos con lenguaje de alto nivel
Declaración: declarar variables o constantes
Ejecutar: realizar una instrucción o realizar un programa
11- Fases para la resolución de un problema
1- Análisis del problema- se tiene una idea de solucionar los problemas
2- Diseño del algoritmo- se escribe paso por paso la solución
3- Codificación- se escribe en el programa
4- Compilación y ejecución - se pone a correr el programa
5- Verificación- se ven si hay algún problema o error y se corrige
6- Depuración- si no corre el programa se vuelve a corregir
7- Documentación- se salva
FOR identificador:= inicio TO fin DO instrucción;
Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en lugar de incrementarse se decrementa. Para esto cambiamos la palabra TO por DOWNTO, y colocamos el valor mayor a la izquierda y el menor a la derecha. Ejemplo:
Al final del programa la variable Numero guardará el valor 51, que fue el valor que no cumplió con la condición establecida en el ciclo WHILE.
Para crear un buen programa es necesario dotarlo con capacidad de decisión con base en las variables o eventos definidos por el programador, para que el programa sea aplicable en un entorno más generalizado y no solo para un problema específico.
SINTAXIS DE PASCAL:
Alternativa doble ::= if <Condición> then <Sentencia> else <Sentencia>
Alternativa múltiple ::= case <Expresión de Tipo ordinal> of <Caso>{; <Caso>} end
Alternativa múltiple ::= case <Expresión de Tipo ordinal> of <Caso>{; <Caso>} else <Sentencia> end ‡
Alternativa simple ::= if <Condición> then <Sentencia>
Bucle con numero fijo de iteraciones ::= for <Sentencia de asignación> to <Expresión de Tipo ordinal> do <Sentencia>
Bucle con numero fijo de iteraciones ::= for <Sentencia de asignación> downto <Expresión de Tipo ordinal> do <Sentencia> ‡
Bucle con salida al final ::= repeat <Sentencia>{; <Sentencia>} until <Condición>
Bucle con salida al principio ::= while <Condición> do <Sentencia>
Cabecera de función ::= function <identificador de función> : <identificador de Tipo elemental> ;
Cabecera de función ::= function <identificador de función> ( <Parámetros formales por valor>{; <Parámetros formales por valor>} ) : <identificador de Tipo elemental> ;
Cabecera de procedimiento ::= procedure <identificador de procedimiento> ;
Cabecera de procedimiento ::= procedure <identificador de procedimiento> ( <Parámetros formales>{; <Parámetros formales>} ) ;
Cabecera de programa ::= program <identificador de programa> ;
Cabecera de programa ::= program <identificador de programa> ( <Lista de dispositivos> );
Cabecera de unidad ::= unit <identificador de unidad> ;
Carácter de subrayado ::= _
Caso ::= <Rango de literales> : <Sentencia>
Comentario ::= { {<Carácter>} }
Comentario ::= (* {<Carácter>} *)
Condición ::= <Expresión de tipo boolean>
Conversión de tipo ::= <identificador de Tipo ordinal> ( <Expresión de Tipo ordinal> )
Cuerpo de función ::= <Sentencia compuesta>
Cuerpo de procedimiento ::= <Sentencia compuesta>
Cuerpo de programa ::= <Sentencia compuesta>
Declaración de campos ::= <identificador de campo>{, <identificador de campo>} : <identificador de Tipo de dato>
Declaración de constante ::= <identificador de constante> = <Literal>
Declaración de constante ::= <identificador de constante> : <identificador de Tipo elemental> = <Literal>
Declaración de función ::= <Cabecera de función><Zona de declaraciones><Cuerpo de función>
Declaración de interfaz ::= <Cabecera de función> | <Cabecera de procedimiento>
Declaración de procedimiento ::= <Cabecera de procedimiento><Zona de declaraciones><Cuerpo de procedimiento>
Declaración de subprograma ::= <Declaración de función> | <Declaración de procedimiento>
Declaración de variables ::= <identificador de variable>{, <identificador de variable>} : <Tipo de dato>
Definición de tipo ::= <identificador de tipo> = <Tipo de dato>
Digito ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
Dispositivo ::= input | output | <identificador de variable tipo fichero>
Elemento de array ::= <Variable de Tipo array> [ <Expresión de Tipo índice>{, <Expresión de Tipo índice>} ]
Elemento de estructura ::= <Elemento de array> | <Elemento de registro>
Elemento de registro ::= <Variable de Tipo registro> . <identificador de campo>
Estructura alternativa ::= <Alternativa simple> | <Alternativa doble> | <Alternativa múltiple>
Estructura de control ::= <Estructura alternativa> | <Estructura iterativa> | <Estructura with>
Estructura iterativa ::= <Bucle con salida al principio> | <Bucle con salida al final> | <Bucle con numero fijo de iteraciones>
Estructura with ::= with <Variable de tipo registro> do <Sentencia>
Expresión ::= <Literal> | <identificador de constante> | <Variable> | <Expresión unaria> | <Expresión binaria> | <Llamada a función> | <Conversión de tipo>
Expresión ::= ( <Expresión> )
Expresión binaria ::= <Expresión><Operador binario>Expresión>
Expresión unaria ::= <Operador unario><Expresión>
identificador ::= <Letra>{<Letra> | <Digito>}
Letra ::= <Letra mayúscula> | <Letra minúscula> | <Carácter de subrayado>
Letra mayúscula ::= A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z
Letra minúscula ::= a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
Lista de dispositivos ::= <Dispositivo>{<Dispositivo>}
Literal ::= <Literal de tipo entero> | <Literal de tipo real> | <Literal de tipo carácter> | <Literal de tipo boolean> | <Literal de tipo string> | <Literal de tipo conjunto> | <Literal de tipo puntero> | <Literal tipo enumerado>
Literal de tipo boolean ::= true | false ‡
Literal de tipo carácter ::= ' <Carácter> '
Literal de tipo carácter ::= # <Digito>{<Digito>} ‡
Literal de tipo conjunto ::= [ ]
Literal de tipo conjunto ::= [ <Rango de valores> ]
Literal de tipo entero ::= <Signo><Digito>{<Digito>}
Literal de tipo puntero ::= nil ‡
Literal de tipo real ::= <Signo><Digito>{<Digito>} . <Digito>{<Digito>}
Literal de tipo real ::= <Signo><Digito>{<Digito>} e <Signo><Digito>{<Digito>}
Literal de tipo real ::= <Signo><Digito>{<Digito>} . <Digito>{<Digito>} e <Signo><Digito>{<Digito>}
Literal de tipo string ::= ' {<Carácter>} '
Literal tipo enumerado ::= <identificador de valor enumerado>
Llamada a función ::= <identificador de función>
Llamada a función ::= <identificador de función> ( <Parámetros actuales por valor>{; <Parámetros actuales por valor>} )
Llamada a procedimiento ::= <identificador de procedimiento>
Llamada a procedimiento ::= <identificador de procedimiento> ( <Parámetros actuales>{; <Parámetros actuales>} )
Operador aritmético entero ::= + | - | * | div | mod ‡
Operador aritmético real ::= + | - | * | / ‡
Operador binario ::= + | - | * | div | mod | / | and | or | = | <> | < | > | <= | >= | in
Operador de conjunto ::= + | - | * | = | <> | <= | >= | in ‡
Operador de string ::= + ‡
Operador lógico ::= not | and | or
Operador relacional ::= = | <> | < | > | <= | >=
Operador unario ::= - | not
Parámetros actuales ::= <Parámetros actuales por valor> | <Parámetros actuales por variable>
Parámetros actuales por valor ::= <Expresión>
Parámetros actuales por variable ::= <Variable>
Parámetros formales ::= <Parámetros formales por valor> | <Parámetros formales por variable>
Parámetros formales por valor ::= <identificador de variable>{, <identificador de variable>} : <identificador de tipo>
Parámetros formales por variable ::= var <identificador de variable>{, <identificador de variable>} : <identificador de tipo>
Programa ::= <Cabecera de programa><Zona de declaración de unidades><Zona de declaraciones><Cuerpo de programa> .
Rango de literales ::= <Literal de Tipo ordinal>
Rango de literales ::= <Literal de Tipo ordinal> .. <Literal de Tipo ordinal> ‡
Rango de literales ::= <Rango de literales>{, <Rango de literales>}
Rango de valores ::= <Expresion de Tipo ordinal>
Rango de valores ::= <Expresion de Tipo ordinal> .. <Expresion de Tipo ordinal> ‡
Rango de valores ::= <Rango de valores>{, <Rango de valores>}
Sentencia ::= <Sentencia de asignacion> | <Sentencia compuesta> | <Llamada a procedimiento> | <Estructura de control>
Sentencia compuesta ::= begin <Sentencia>{; <Sentencia>} end
Sentencia de asignación ::= <Variable> := <Expresión> ‡
Signo ::= | + | -
Tipo array ::= <identificador de tipo array>
Tipo array ::= array[ <Tipo índice>{, <Tipo índice>} ] of <Tipo de dato>
Tipo conjunto ::= <identificador de tipo conjunto>
Tipo conjunto ::= set of <Tipo ordinal> ‡
Tipo de dato ::= <Tipo simple> | <Tipo estructurado> ‡
Tipo elemental ::= <Tipo simple> | <Tipo string>
Tipo entero ::= integer | longint ‡
Tipo enumerado ::= <identificador de tipo enumerado>
Tipo enumerado ::= ( <Literal tipo enumerado>{, <Literal tipo enumerado>} )
Tipo estructurado ::= <Tipo array> | <Tipo registro> | <Tipo fichero> | <Tipo conjunto> | <Tipo string>
Tipo fichero ::= <identificador de tipo fichero>
Tipo fichero ::= text
Tipo fichero ::= file of <Tipo de dato> ‡
Tipo indice ::= <Tipo ordinal>
Tipo ordinal ::= <Tipo ordinal predefinido> | <Tipo enumerado> | <Tipo subrango>
Tipo ordinal predefinido ::= <Tipo entero> | char | boolean
Tipo puntero ::= <identificador de tipo puntero>
Tipo puntero ::= ^ <identificador de Tipo de dato> ‡
Tipo real ::= real ‡
Tipo registro ::= <identificador de tipo registro>
Tipo registro ::= record <Declaración de campos>{; <Declaración de campos>} end
Tipo simple ::= <Tipo ordinal> | <Tipo real> | <Tipo puntero>
Tipo string ::= <identificador de tipo string>
Tipo string ::= string[ <Literal de tipo entero> ] ‡
Tipo subrango ::= <identificador de tipo subrango>
Tipo subrango ::= <Literal de Tipo ordinal> .. <Literal de Tipo ordinal>
Unidad ::= <Cabecera de unidad><Zona de interfaz><Zona de implementación> end.
Variable ::= <identificador de variable> | <Elemento de estructura> | <Variable dinámica>
Variable dinámica ::= <Variable de Tipo puntero> ^ ‡
Zona de declaración de constantes ::=
Zona de declaración de constantes ::= const <Declaración de constante>{; <Declaración de constante>} ;
Zona de declaración de interfaces ::= <Declaración de interfaz>{; <Declaración de interfaz>} ;
Zona de declaración de subprogramas ::=
Zona de declaración de subprogramas ::= <Declaración de subprograma>{; <Declaración de subprograma>} ;
Zona de declaración de unidades ::=
Zona de declaración de unidades ::= unit <identificador de unidad>{, <identificador de unidad>} ;
Zona de declaración de variables ::=
Zona de declaración de variables ::= var <Declaración de variables>{; <Declaración de variables>} ; ‡
Zona de declaraciones ::= <Zona de declaración de constantes><Zona de definición de tipos><Zona de declaración de subprogramas><Zona de declaración de variables> ‡
Zona de definición de tipos ::=
Zona de definición de tipos ::= type <Definición de tipo>{; <Definición de tipo>} ;
Zona de implementación ::= implementation <Zona de declaración de subprogramas>
Zona de interfaz ::= interface <Zona de declaracion de unidades><Zona de declaración de constantes><Zona de definición de tipos><Zona de declaración de interfaces>
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.
Se utilizan para tomar decisiones lógicas. En éstas se evalúa una condición y en función del resultado de la misma se realiza una opción u otra. Las condiciones se especifican usando expresiones lógicas. En pseudo código éstas palabras son if, then, else. Las estructuras selectivas pueden ser: - simples, dobles o múltiples.
La estructura repetitiva while, es aquélla en que el cuerpo del bucle se repite mientras se cumple una determinada condición
Esta estructura se ejecuta hasta que se cumpla una condición determinada que se comprueba hasta el final del bucle. Se ejecuta al menos una vez.
El bucle repetir-Hasta que se repite mientras el valor de la expresión booleana de la condición sea falsa, justo la opuesta de la sentencia mientras.
Recursividad: Propiedad de un lenguaje que permite a un procedimiento llamarse a si mismo para volver a ejecutar su código en una instancia distinta.
Las formas de iteración sirven para ejecutar ciclos repetidamente, dependiendo de que se cumplan ciertas condiciones. Una estructura de control que permite la repetición de una serie determinada de sentencias se denomina bucle1 (lazo o ciclo).
del que se sale, normalmente, mediante una sentencia "exit when" o con una alternativa que contenga una cláusula "exit".
Tabla de ordenadores de operadores
La diferencia entre las instrucciones Read y ReadLn consiste en que Read permite que la siguiente instrucción continúe leyendo valores en la misma línea; mientras que, con ReadLn la siguiente lectura se hará después de que se haya tecleado el carácter de fin de línea.
Cuando se tienen datos de tipo char en una instrucción Read, los caracteres blancos y los de fin de línea son considerados en el conteo de los elementos de las cadenas de caracteres mientras no se complete el total especificado para cada una de ellas. Cada fin de línea es tratado como un carácter, pero el valor asignado a la variable será un carácter blanco.
Es aconsejable que cada cadena de caracteres se lea en una instrucción Read o ReadLn por separado, para evitar el tener que ir contando hasta completar la cantidad exacta de caracteres que forman la cadena ( o de lo contrario se tendrán resultados sorpresivos y frustrantes al verificar los datos leídos ).
El procedimiento Write permite que la siguiente instrucción se realice en la misma línea , mientras que WriteLn alimenta una nueva línea, antes de finalizar.
Al ejecutarse la sentencia for la primera vez, a contador se le asigna un valor inicial (expresion.1), y a continuación se ejecutan las intrucciones del interior del bucle, enseguida se verifica si el valor final (expresión.2) es mayor que el valor inicial (expresión.1); en caso de no ser así se incrementa contador en uno y se vuelven a ejecutar las instrucciones, hasta que el contador sea mayor que el valor final, en cuyo momento se termina el bucle.
La acción de repeat-until es repetir una serie de instrucciones hasta que se cumpla una determinada condición.
Es una variable que nos permite guardar un valor que se incrementa o decrementa en forma no constante durante el proceso, en un momento determinado tendrá un valor y al siguiente tendrá otro valor igual o distinto, por ejemplo cuando se realiza un deposito en el banco, la cantidad depositada no siempre es la misma; unas veces será una cantidad y otras veces distintas. Lo mismo ocurre cuando realizamos algún retiro, pero decrementando la cantidad total.
Se utilizan para saltar de un lugar a otra zona del programa o código si es que se cumple una cierta condición.
Es un campo de memoria que toman diversos valores a lo largo de la ejecución del programa y que permite comunicar información de una parte a otra del mismo, es decir variar la secuencia de ejecución de un programa, dependiendo el valor de el valor que tenga en cada momento. Los únicos valores que quede tomar es encendido y apagado.
Es un dispositivo diseñado para segmentar la red. Opera en la capa 3 de modelo OSI y permite un control Sowftware sobre los paquetes puede proporcionar seguridad, control, servicio de firewall y un acceso a una WAN ( por ejemplo con RSDI, Frame relay, ATM, MODEM…).
Al funcionar en una capa mayor que la del switch, el ruteador distingue entre los diferentes protocolos de red tales como IP, IPX, apple talk. Esto le permite hacer una decisión mas inteligente que el switch al reenviar los paquetes permitiendo también unir redes que funcionan con protocolos diferentes.
Es responsable de crear y mantener tablas de ruteo para cada capa del protocolo de red, estas tablas son creadas de forma estática o bien dinámica de esta manera el ruteador extrae de la capa de red la dirección destino y realiza una decisión de envío basado en el contenido de la especificación del protocolo en la tabla de ruteo.
Es la unidad básica de transmisión de datos en una red, cada paquete tiene información de un recorrido en la red y la información entra de un dispositivo a otro
Es un dispositivo diseñado para resolver problemas de rendimiento en la red. Debidos a anchos de banda pequeños y embotellamientos. Opera en la capa 2 del modelo OSI y reenvía los paquetes en base a la dirección MAC
Es un protocolo de red independiente del nivel físico y que soporta múltiples sesiones entre múltiples ordenadores. Esta constituido en capas lo que permite adaptarlo a nuevas tecnologías y requerimientos sin necesidad de modificar el conjunto.
Sirve para indicar errores en el proceso de transmisión de datos como si fuera una ayuda
Provee dos servicios que no incluye la capa IP: provee los números de puerto para distinguir las distintas solicitudes del usuario y una suma para verificar que los datos arriben correctamente las aplicaciones que usan este protocolo deben asegurarse que reciban los data gramas en el orden apropiado
Ataque de tipo dos usado cuando un atacante envia paquetes ping mayores a los 65,536 BYTES permitidos por el protocolo TCP/IP; el ataque provoca que los servidores se congelen o se reinicien.
Sirve para eliminar la necesidad de comprar HUD y para que la red este completamente dedicada teniendo un backbone duplex
ARREGLOS ( VECTORES Y MATRICES )
Un arreglo es una posición de memoria que podría considerarse como una plantilla de una hoja de calculo en la que en cada una de las celdas de la plantilla puede haber almacenados distintos valores, los cuales se diferencian unos de otros por su ubicación. En otras palabras un arreglo es una especie de variable que contiene muchos valores pero cada uno con una posición diferente.
Un arreglo puede ser unidimensional o vectorial, bidimensional o matricial, o multidimencional.
VECTORES O ARREGLOS UNIDIMENCIONALES :
Se lee: " A sub i " , donde i es cualquier numero entero positivo
diferente de cero y representa la ubicación de un valor dentro del
Gráficamente se vería así :
Ú ¿
³ ÚÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄÂÄÄÄ¿ ³
A ³ ³ 5 ³ 7 ³ 2 ³ 9 ³ 3 ³ 8 ³ 6 ³ 1 ³ 4 ³ 0 ³ . ³ . ³ . ³ . ³ . ³ X ³ ³
³ ÀÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÁÄÄÄÙ ³
³            ³
À i i+1 i+2 i+3 i+4 i+5 i+6 i+7 i+8 i+9 ................... i+N Ù
En este caso vemos por ejemplo que A[7] "A sub 7" tiene almacenado el
valor 4 o escrito de otra forma: A[7] = 4
Y asi mismo:
A[i+N] = X
para e de 1 hasta n hacer
imprimir "teclee la edad de la persona",e
L[e]  edad
imprimir "la edad de la persona",i," es: ",L[i]
Este programa sirve para preguntarle la edad a un numero n de
personas y una vez terminada el ingreso de todos datos, se imprime
una lista con la edad de cada persona.
MATRICES O ARREGLOS BIDIMENCIONALES:
M[F,C]
Se lee: " A sub F coma C " , donde F y C son dos números cualquiera,
enteros, positivos, diferentes de cero, lo cual da como resultado una
pareja ordenada que representa la ubicación de un valor dentro de
la matriz M.
Donde: El valor de F representa las Filas y C las Columnas
[F,C]
³ À Columnas
À Filas
Ú C C+1 C+2 ¿
³    ³
³ ÚÄÄÄÂÄÄÄÂÄÄÄ¿ ³
³ F  ³ 5 ³ 7 ³ 2 ³ ³
³ ÃÄÄÄÅÄÄÄÅÄÄÄ´ ³
A ³ F+1 ³ 8 ³ 3 ³ 9 ³ ³
³ F+2 ³ 4 ³ 6 ³ 1 ³ ³
³ ÀÄÄÄÁÄÄÄÁÄÄÄÙ ³
En este caso vemos por ejemplo que A[3,2] " A sub 3 coma 2 " tiene
almacenado el valor 6 o escrito de otra forma: A[3,2] = 6
A[1,1] = 5
A[1,2] = 7
A[1,3] = 2
A[2,1] = 8
A[2,2] = 3
A[3,1] = 4
A[3,2] = 6
imprimir "Teclee el numero de personas que desea registrar"
para p de 1 hasta n hacer
imprimir "teclee el código de la persona",p
leer codi
imprimir "teclee la edad de la persona",p
imprimir "teclee el teléfono de la persona" ,p
leer tele
R[p,1]  código
R[p,2]  edad
R[p,3]  tele
imprimir "el código de la persona",i," es: ",R[i,1]
imprimir "la edad de la persona",i," es: ",R[i,2]
imprimir "el teléfono de la persona" ,i," es: ",R[i,3]
Este programa sirve para registrar un numero n de personas con los
datos de código, edad y teléfono y una vez terminada el ingreso de
datos, se imprime una lista con la información de cada persona.
ARREGLOS MULTIDIMENCIONALES :
Los arreglos multidimencionales son aquellos que para determinar la
ubicación de un valor almacenado dentro de ellos, se requiere de mas
de dos términos independientes como en la J y la I en los arreglos
bidimensionales, por lo tanto un arreglo multidimencional podría ser:
T[i,j,k], el cual seria de tres dimensiones o términos independientes
Para esta clase de arreglos no ampliare mas el tema pues no veo necesario tocarlo mas profundamente, pues esto es solo un cursillo de lógica de programación y para aquel que ya esta en capacidad de usar arreglos multidimencionales, este curso ya no será de su necesidad.
Es una colección de datos relacionados entre si por ejemplo: cadena, tablas, árboles, pilas.
www.laopinion.com/glossary/d.html
http://encarta.msn.es/find/Concise.asp?z=1&pg=2&ti=761574357
http://www.terra.es/personal/ffrrbb/elrincondelpascal
http://www.recursos-as400.com/edep.shtml
Biblioteca Microsoft encarta2002
Enciclopedia Lauruse
Biblioteca Microsoft encarta 2000
N1,N2:INTEGER
T:=N1+N2
N,A:STRING
TC = 9.80
P,D:REAL
D:=P/TC
C1,C2,P:REAL
P:= (C1+C2)/2
N,AP,AM,D,P:STRING
A,E:INTEGER
N,AP,AM,D,P,A
E:=2002-A
N,AP,AM,D,P,A,E
NDE,RFC,D,P,PR:STRING
SH,DT,SD,SS,SQ:REAL
HT:INTEGER
NDE,RFC,D,P,PR,SH,DT,HT
SD:=SH*HT
SS:=SD*DT
SQ:=SS*2
NDE,RFC,D,P,PR,SD,SS,SQ
N,D,T:STRING
N,D,T
N,T,D
N1.N2,P:REAL
T:=N1*N2
R,M:REAL
R:=M*CM
R:=MI*KM
KM=1.609
R,MI:REAL
S,EX1,EX2 :REAL
EX1,EX2
S:=EX1+EX2
C,T,CM1,V:REAL
T:=V*C
T>1500
CM1:=T*(20/100)
CM1:=T*(10/100)
N,S,A,P
SE ELABORA BOLETA
NO SE ELABORA BOLETA
A=>80
P=>7
S,N:INTEGER; A,P:REAL
E,P:REAL
N,E,P
E=>8
P=>8
POBLA-CION A
POBLA-CION B
POBLA-CION C
C=PI(SQR(R))
CU=B*AL
T=(B*AL)/2
NUM ES 0
NUM ES NEG
NUM ES +
N:REAL
N1>N3
N3>N1
N1 ES MAYOR
N2 ES MAYOR
N3 ES MAYOR
N1,N2 IGUAL
N1,N3 IGUAL
N2,N3 IGUAL
A,B:INTEGER S,R,M,D:REAL
S=SUMA
R=RESTA
M=MULTIPLI
OP=D
R:=A-B
M:=A*B
D:=A/B
1=TRIAN
2=CIRCULO
3=CUADRO
4=SALIR
B,AL,R
A,T,C,CU,B,AL,R,OP:REAL
SD,SH,HT,TC,P,D,E,A:REAL
1-SUELDO
3-PESO-DLL
SH,HT
SD=SH*HT
E=2002-A
DLL=P/TC
N,R,CU,C:REAL
OP,RESP:CHAR
1-CUADRADO
2-RAIZ
3-COSENO
N,OP
CU:=SQR(N)
R:=SQRT(N)
C:=COS(N)
DESEA SEGUIR CAPTURANDO
UNTIL R<>'S'
N1,N2,N3,N4,T:REAL
RESP:CHAR
OP:INTEGER
2-MULTIPLICAR
3-SALIR
N1,N2, N3,N4
T:=N1+N2+N3+N4
T:=N1*N2*N3*N4
N,C:STRING
NUEM,OP:INTEGER
D,X,DES,HT,SH,SQ,SD:REAL
N,NUEM,C
1- 6 A 8 FALTAS
2- 1 A 5 FALTAS
HT,SH
SQ:=SH*HT*E
D:=SQ*Z
SD:=HT*SH
DES:=SQ-D
N,C,SD,DES
X:=SQ*Y
DES:=SQ-X
UNTIL RESP<>'S'
PRE,DES,TOT:REAL
NOM,PRE
IF PRE<2000
DES:=PRE*0.05
TOT:=PRE-DES
NOM,PRE,DES,TOT
UNTIL RESP='S'
VTA,TOT,PV:REAL
CV,CE:INTEGER
CE:=1
NOM,VTA
UNTIL CV=3
CV:=0
CV:=CV+1
PV:=TOT*0.05
NOM,TOT,PV
CE:=CE+1
N,S,M,P
P:=TOT/3
TOT=X+TOT
UNTIL C=2
N,M,S,X
CA:=1
N,S,M:STRING
P,TOT:REAL
X,CA,C:INTEGER
CC:INTEGER
M,C,MAR,P:STING
PRE,T,TOT,IMP:REAL
M,C,MAR,PRE,P
T=T+PRE
UNTIL CC<=3
IMP:=T*0.15
TOT:=T+IMP
T,IMP,TOT
CP,CC,CA:INTEGER
P,T,TOT,ST:REAL
MEM,C,NP,CLA
CC<=2
MEM,C
NP,CA,CLA,P
IF CA=1
IF CA=2
IF CA=3
TOT:=P*0.3
ST:=P-TOT
TOT:=P*0.2
TOT:=P*0.1
UNTIL CP=4
UNTIL CC=2
PROGRAMA HA CONCLUIDO
PRE,T,TOT,DES:REAL
CA:INTEGER
WHILE CA<=8
PRE,NOM
TOT=TOT+PRE
CA:=CA+1
IF TOT>=2000 THEN
DES=TOT*.1
T=TOT-DES
TOT,DES,T
LUN=.05,MAR=.07,MIE=.08,JUE=.09,VIE=.1,PAN=30, CHA=50,BLU=20,CAM=25,VES=40,FAL=60,SAC=80
T,ST,DES,PAN1,BLU1,CAM1,VES1,SAC1,FAL1:REAL
PAN1,CHA1,BLU1,CAM1,VES1,SAC1,FAL1
ST=(PAN*PAN1)+(CHA*CHA1)+(BLU*BLU1)+(CAM+CAM1)+(VES*VES1)+(FAL*FAL1)+(SAC*SAC1
MIERCOLES - 3
DES=LUN*ST
T=ST-DES
PAN1,CHA1,BLU1,CAM1,VES1,FAL1,SAC1,ST,DES,T
DESEA SEGUIR CAPTURANDO?
SUM,CAL,PROM:REAL
CCAL:INTEGER
CCAL:=1
SUM:=SUM+CAL
CCAL:=CCAL+1
PROM=SUM/3
NOM,PROM
NIM,SEG:REAL
QUIERE CONVERTIR MINUTOS A SEGUNDOS
WHILE RESP='S'
SEG=60*MIN
N,NOM,HECTOR:STRING
N:=NOM
UNTIL NOM:=HECTOR
NUM,I:INTEGER
R:=SQRT(NUM)
RES:=2* I
CU:=SQR(NUM)
CU:REAL
R:=NUM* I
NUM,R:REAL
RES=1/I
RES:=SQR(NUM)
IF Y=26 THEN
NUM,RES:REAL
GOTO (X,Y); NUM
NUM,X,Y:INTEGER
P:=X*J
FOR I:=1 TO 2 DO FOR J:=1 TO 10 DO
X:=2, P:=2
X,P,I,J:INTEGER
PROM:=TOT/4
TOT:=TOT+CAL
CAL,TOT:REAL
Programa fuente en pascal
Resultados del programa pascal
Datos necesarios para programa pascal

References: Resolución 
 Resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución