Informática

Programación

Compartir 0 Me sirvió 0 No me sirvió

ALGORITMOS Y PROGRAMACION

QUINTO SEMESTRE

GRUPO 510

ALGORITMO

unidad I: Algoritmo y Programas

1.1 consideraciones acerca de la computabilidad

1.2 Concepto de algoritmo

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.1 Resolución de problemas

2.2 Análisis de problemas

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.2 funciones

5.3 procedimientos

5.4 funciones y procedimientos como parámetros

5.5 Recursividad

Programación

Unidad I

Programa de computadora

Algoritmos y estructuras de datos

Programas simples en pascal

Unidad II

2.1 La sintaxis de pascal

2.2 estructuras de un programa en pascal

2.3 Declaraciones

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

Unidad III

3.1 Tipos de datos

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 Expresiones

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

Program prog1;

{programa que calcula la suma de dos números}

Uses crt;

Var

N1,N2:interger;

T:real;

Begin

Clrscr;

Writeln(`capruta el primer numero:');

Readln(N1)

Writeln(`dame el segundo numero:');

Readln(N2)

T:=N1+N2;

Writeln(`la suma de dos números es:',T:7:0);

Readln;

End.

DIAGRAMA1

Program prog2;

{programa que captura un nombre}

Uses crt;

Var

N:string[6]

A:string[5]

Begin

Clrscr;

Writeln(`captura el nombre:');

Readln(N);

Writeln(`Captura el apellido:');

Readln(A);

Writeln(`tu nombre es:',N,A);

Readln;

End

DIAGRAMA 2

Program prog3;

{programa que convierte pesos a dólares}

Uses crt;

Const

TC=9.8;

Var

P,D:real;

Begin

Clrscr;

Writeln(`conversión de peso a dólar');

Writeln;

Writeln(`captura la cantidad en pesos:');

Readln(P)

D:=P/TC;

Writeln(`la cantidad en dólar es :',D:6:0);

Readln;

End.

DIAGRAMA 3

Program Prog4

{programa que calcula el promedio de dos calificaciones}

Uses crt;

Var

C1,c2,p:real;

Begin

Clrscr;

Writeln(`dame tu primera calificación:');

Readln(c1);

Writeln(`dame tu segunda calificación:');

Readln(c2);

P:=(c1+c2)/2;

Writeln(`tu promedio es :',p:7:0);

Readln;

Writeln(`trata de mejorar');

Readln;

End.

DIAGRAMA 4

Program prog5

{programa de datos personales}

Uses crt;

Var

N,ap,am,d,p:string[50];

E:integer;

Begin

Clrscr;

Writeln (`dime tu nombre:');

Readln(n);

Writeln (`cual es tu apellido paterno:');

Readln(ap);

Writeln(`cual es tu apellido materno:');

Readln(am);

Writeln(`cual es tu domicilio:');

Readln(d);

Writeln(`cual es tu ocupación:');

Readln(p);

Writeln(`que año naciste:');

Readln(a);

Writeln(`tu eres:',n:,' `,ap:,' `,am);

Writeln(`vives en:',d);

Writeln(`eres:',p);

Writeln(`naciste en el año de:',a);

Readln;

E:=2002-a;

Writeln(`tienes la edad de:',e);

Readln;

End.

DIAGRAMA 5

Program prog6

{PROGRAMA que captura el sueldo de un empleado}

Uses crt;

Var

Nde,rfc,d,p,pr:string[50];

Sh,dt,sd,ss,sq:real;

Ht:integer;

Begin

Clrscr;

Writeln(`nombre del empleado:');

Readln(nde);

Writeln(`cual es su rfc:');

Readln(rfc);

Writeln(`cual es su domicilio:');

Readln(d);

Writeln(`cual es su puesto:');

Readln(p);

Writeln(cual es su profesión:');

Readln(pr);

Writeln(`cual es su sueldo por hora:');

Readln(sh);

Writeln(`cuantas horas trabaja al día:');

Readln(ht);

Writeln(`cuantos días trabaja a la semana:');

Readln(dt);

Writeln(`el nombre del empleado”a” es:',nde);

Readln;

Writeln(`su rfc es :',rfc);

Readln;

Writeln(su domicilio es :',d);

Readln;

Sd:=sh*ht;

Writeln(`su sueldo diario es de:',sd:2:0);

Readln;

Ss:=sd*dt;

Writeln(`su sueldo semanal es de:',ss:2:0);

Readln;

Sq:=ss*2;

Writeln(`su sueldo quincenal es de:',sq:2:0);

Readln;

Writeln(`***siga trabajando casi es millonario***');

Readln;

End.

DIAGRAMA 6

Program prog7

{datos personales};

Uses crt;

Var

N,d,t:string[20]

Begin

Clrscr;

Writeln(`cual es tu nombre:');

Readln(n);

Writeln(`cual es tu domicilio:');

Readln(d);

Writeln(`cual es tu numero telefónico:');

Readln(t);

Writeln('te llamas:',n);

Readln;

Writeln(vives en:',D);

Readln;

Writeln(`tu numero de teléfono es:',t);

Readln;

End.

DIAGRAMA 7

Program prog8

{obtener el producto de dos números}

Uses crt;

Var

N1,n2,p:real;

Begin

Clrscr;

Writeln(`cual es el primer numero:');

Readln(n1);

Writeln(`cual es el segundo numero:');

Readln(n2);

P:=n1*n2;

Writeln(`el producto es:',p);

Readln;

End.

DIAGRAMA 8

Program prog9

{Conversión de metros a centímetros};

Uses crt;

Var

R,m:real;

Const

Cm=100;

Begin

Clrscr;

Writeln(`cuantos metros:');

Readln(m);

R:=m*cm;

Writeln(`son:',r:4:2);

Readln;

End.

DIAGRAMA 9

Program prog10

{conversión de millas a kilómetros};

Uses crt;

Var

Mi,r:real;

Const

Km=1.609;

Begin

Clrscr;

Writeln(`cuantas millas son:');

Readln(mi);

R:=km*mi;

Writeln(`son en km:',r:5:3);

Readln;

End.

DIAGRAMA 10

Program prog11;

{programa que obtiene la suma de dos exámenes}

Uses crt;

Var

Ex1,ex2,s:real;

Begin

Clrscr;

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);

Readln;

If s>=80 then

Begin

Writeln('el alumno esta aceptado');

Readln;

End

Else

Begin

Writeln('el alumno esta rechazado');

Readln;

End;

End.

DIAGRAMA 11

Program prog12;

{programa que obtiene la comisión de una persona que vende libros}

Uses crt;

Const

C=20;

D=10;

Var

A,b,x,z:real;

Y:integer;

Begin

Clrscr;

Writeln('el costo de los libros es');

Readln(x);Writeln('los libros vendidos son ');

Readln(y);

Z:=x*y;

Writeln('la ganancia obtenida por los libros vendidos es:', '$',z:3:2);

Readln;

If z>= 1500 then

Begin

Clrscr;

A:=(z*c)/100;

Writeln('su comisión es de el 20%');

Writeln('su ganancia es');

Writeln('$',a:3:2);

Readln;

End

Else

Begin

Clrscr;

B:=(z*d)/100;

Writeln('su comisión es de el 10%');

Writeln('su ganancia es');

Writeln('$',b:3:2);

Readln;

End;

End.

Diagrama 12

Program prog13;

{programa que elebora boleta segun caracteristicas del alumno}

Uses crt;

Var

N,s:string;

A,p:real;

Begin

Clrscr;

Writeln('Nombre de el alumno:');

Readln(n);

Writeln('Semestre:');

Readln(s);

Writeln('Asistencia Total:');

Readln(a);

Writeln('promedio final:');

Readln(p);

If (a>=80) and (p>=7) then

Begin

Clrscr;

Writeln('******SE ELABORA BOLETA******');

Writeln('Nombre:',n);

Writeln('Semestre:',S);

Writeln('Asistencia:',A:3:0,'%');

Writeln('promedio final:',p:3:1);

Readln;

End

Else

Begin

Clrscr;

Writeln('***NO SE ELABORA BOLETA***');

Readln;

End

End.

DIAGRAMA 13

Program prog14;

{PROGRAMA QUE DESPLIEGA LA POBLACION DE UN ALUMNO SEGUN SUS CARACTERISTICAS}

Uses crt;

Var

N:string;

E,p:real;

Begin

Clrscr;

Writeln('Nombre alumno:');

Readln(N);

Writeln('Edad:');

Readln(E);

Writeln('promedio final:');

Readln(p);

If (p>6) and (p<8) and (e>6) and (e<8) then

Begin

CLRSCR;

Writeln('***** POBLACION "A" *********');

Writeln('nombre:',N);

Writeln('edad:',e:3:0);

Writeln('Promedio:',p:3:1);

Readln;

End

Else

If (P=8) and (e=8) then

Begin

CLRSCR;

Writeln('****** POBLACION "B" ********');

Writeln('Alumno:',N);

Writeln('Edad:',e:3:0);

Writeln('promedio final:',p:3:1);

Readln;

End

Else

Begin

CLRSCR;

Writeln('********* POBLACION "C" **********');

Writeln('Nombre:',N);

Writeln('edad:',e:3:0);

Writeln('Promedio:',p:3:1);

Readln;

End;

End.

DIAGRAMA 14

Program prog15

{determina si un numero es positivo, negativo o igual a cero};

Uses crt;

Var

N:real;

Begin

Clrscr;

Writeln('Dame un numero:');

Readln(n);

If n>0 then

Begin

Writeln('El numero es positivo:');

Readln;

End

Else

If n<0 then

Begin

Writeln('el numero es negativo:');

Readln;

End

Else

If n=0 then

Writeln('el numero es cero:');

Readln;

End.

DIAGRAMA 15

Program prog16

{programa que captura 3 numeros y determina si es mayor menor o igual};

Uses crt;

Var

N1,n2,n3:real;

Begin

Clrscr;

Writeln('Dame el primer numero:');

Readln(n1);

Writeln('dame el segundo numero:');

Readln(n2);

Writeln('dame el ultimo numero:');

Readln(n3);

If (n1>n2) and (n1>n3) then

Begin

Writeln('el mayor es el primero:',n1:4:2);

Readln;

End

Else

If (n2>n1) and (n2>n3) then

Begin

Writeln('el mayor es el segundo:',n2:4:2);

Readln;

End

Else

If (n3>n1) and (n3>n2) then

Begin

Writeln('el mayor es el tercero:',n3:4:2);

Readln;

End

Else

If (n1=n2) and (n2=n3) then

Begin

Writeln('los numeros son iguales:');

Readln;

End

Else

If (n1=n2) and (n1>n3) then

Begin

Writeln('el primero y el segundo son iguales y mayores que el tercero');

Readln;

End

Else

If (n1=n3) and (n1>n2) then

Begin

Writeln('el primero y el tercero son iguales y mayores que el segundo numero');

Readln;

End

Else

If (n2=n3) and (n2>n1) then

Begin

Writeln('el segundo y el tercero son iguales y mayores que el primero');

Readln;

End

End.

DIAGRAMA 16

Program prog17

{programa que suma,resta,multiplica o divide dos numeros};

Uses crt;

Var

N1,n2,s,r,m,d:real;

Op:integer;

Begin

Clrscr;

Writeln(' * OPCIONES *');

Writeln(' 1 - SUMA');

Writeln(' 2 - RESTA');

Writeln(' 3 - MULTIPLICACION');

Writeln(' 4 - DIVISION');

Writeln(' 5 - SALIDA');

Writeln('SELECCIONE UNA OPCION');

READLN(OP);

CASE OP OF

1:BEGIN;

Writeln(' * SUMA *');

WRITELN('CAPTURA EL PRIMER NUMERO');

READLN(N1);

Writeln('CAPTURA EL SEGUNDO NUMERO');

READLN(N2);

S:=N1+N2;

Writeln('EL RESULTADO ES: ',S:6:2);

READLN;

END;

2:BEGIN;

Writeln(' * RESTA *');

WRITELN('CAPTURA EL PRIMER NUMERO');

READLN(N1);

Writeln('CAPTURA EL SEGUNDO NUMERO');

READLN(N2);

R:=N1-N2;

Writeln('EL RESULTADO ES: ',R:6:2);

READLN;

END;

3:BEGIN;

Writeln(' * MULTIPLICACION *');

WRITELN('CAPTURA EL PRIMER NUMERO');

READLN(N1);

Writeln('CAPTURA EL SEGUNDO NUMERO');

READLN(N2);

M:=N1*N2;

Writeln('EL RESULTADO ES: ',m:6:2);

READLN;

END;

4:BEGIN;

Writeln(' * DIVISION *');

WRITELN('CAPTURA EL PRIMER NUMERO');

READLN(N1);

Writeln('CAPTURA EL SEGUNDO NUMERO');

READLN(N2);

D:=N1/N2;

Writeln('EL RESULTADO ES: ',D:6:2);

READLN;

END;

5:BEGIN;

Writeln('*ADIOS*');

READLN;

END;

END.

DIAGRAMA 17

Program prog18

{programa que calcula el área de un triangulo, cuadrado o circulo};

Uses crt;

Const

Pi=3.141592654;

Var

A,t,c,cu,b,al,r:real;

Op:integer;

Begin

Clrscr;

Writeln(' *menu*');

Writeln(' 1 - triangulo');

Writeln(' 2 - cuadrado');Writeln(' 3 - circulo');

Writeln(' 4 - salida');

Writeln('seleccione una opción');

Readln(op);

Case op of

1:begin

Writeln(' *triangulo*');

Writeln('que tamaño es la base');

Readln(b);

Writeln('que tamaño es la altura');

Readln(al);

T:=(b*al)/2;

Writeln('el área del triangulo es: ',t:6:2);

Readln;

End;

2:begin

Writeln('cuadrado');

Writeln('que medida tiene uno de sus lados');

Readln(b);

Cu:=b*b;

Writeln('el área del cuadrado es: ',cu:6:2);

Readln;

End;

3:begin

Writeln(' *circulo*');

Writeln('que tamaño es el radio del circulo');

Readln(r);

C:=pi*(r*r);

Writeln('el área del circulo es: ',c:6:2);

Readln;

End;

4:begin

Writeln('*adios*');

Readln

End;

End.

DIAGRAMA 18

Program prog19;

{menú de opciones para obtener el sueldo diario de una persona, su edad o la conversión de pesos a dólares}

Uses crt;

Var

S,st,p,c,d:real;

Op,h,a1,a2,e:integer;

Begin

Clrscr;

Writeln('menu de opciones');

Writeln;

Writeln(' 1- sueldo diario de una persona');

Writeln;

Writeln(' 2- edad de una persona');

Writeln;

Writeln(' 3- conversión de pesos a dólares');

Writeln;

Writeln(' 4- salir');

Writeln;

Writeln('seleccione una opción y presione enter');

Readln(op);

Case op of

1:begin

Clrscr;

Writeln('sueldo diario de una persona');

Writeln;

Writeln('sueldo por horas de trabajo');

Readln(s);

Writeln('horas trabajadas al dia');

Readln(h);

St:=s*h;

Writeln('el sueldo diario de esta persona es:$',st:3:2);

Readln;

End;

2:begin

Clrscr;

Writeln('edad de una persona');

Writeln;

Writeln('año de nacimiento');

Readln(a1);

Writeln('año actual');

Readln(a2);

E:=a2-a1;

Writeln('su edad es:',e,'años');

Readln;

End;

3:begin

Clrscr;

Writeln('conversion de pesos a dolares');

Writeln;

Writeln('la cantidad en pesos es:');

Readln(p);

Writeln('tipo de cambio actual');

Readln(c);

D:=p/c;

Writeln('la cantidad en dolares es:$',d:3:2);

Readln;

End;

4:begin

Clrscr;

Writeln('adios');

Writeln('precione "enter" para salir');

Readln;

End;

End

End.

DIAGRAMA 19

Program prog20;

{programa que calcula el cuadrado, la raiz cuadrada y el coseno de un numero}

Uses crt;

Var

N,r,cuad,c:real;

Op:integer;

Resp:char;

Begin

Repeat;

Clrscr;

Writeln('***menu de opciones***');

Writeln;

Writeln(' 1- cuadrado');

Writeln(' 2-raiz cuadrada');

Writeln(' 3-coseno');

Writeln;

Writeln('***seleccione una opcion y precione "enter"***');

Readln(op);

Case op of

1:begin

Clrscr;

Writeln('***cuadrado***');

Writeln;

Writeln('capturar numero');

Readln(n);

Cuad:=sqr(n);

Writeln('el cuadrado de el numero es:',cuad:3:2);

Readln;

End;

2:begin

Clrscr;

Writeln('***raiz cuadrada***');

Writeln;

Writeln('capturar numero');

Readln(n);

R:=sqrt(n);

Writeln('la raiz cuadrada de el numero es:',r:3:2);

Readln;

End;

3:begin

Clrscr;

Writeln('***coseno***');

Writeln;

Writeln('capturar numero');

Readln(n);

C:=cos(n);

Writeln('el coseno de el numero es:',c:3:2);

Readln;

End;

Writeln('desea seguir capturando <s/n>');

Readln(resp);

Until(resp <>'s') and (resp <>'s');

End.

DIAGRAMA 20

Program prog21;

{programa que suma o multiplica}

Uses crt;

Var

N1,n2,s,r:real;

Resp:char;

Op:integer;

Begin

Clrscr;

Writeln('*********menu***********');

Writeln('1 - suma');

Writeln('2 - multiplicacion');

Writeln('3 - salir');

Writeln;

Writeln('***seleccione una opcion y precione "enter"***');

Readln(op);

Case op of

1:begin

Clrscr;

Writeln('******suma*******');

Writeln('capturar el primer numero');

Readln(n1);

Writeln('capturar el segundo numero ');

Readln(n2);

S:=n1+n2;

Writeln('el resultado de la suma es:',s:3:2);

Readln;

End;

2:begin

Clrscr;

Writeln('**multiplicacion**');

Writeln('capturar el primer numero');

Readln(n1);

Writeln('capturar el segundo numero');

Readln(n2);

R:=n1*n2;

Writeln('el resultado de la multiplicacion es :',r:3:2);

Readln;

End;

3:begin

Clrscr;

Writeln('adios');

Readln;

End;

Else

Writeln('error');

Readln;

End;

End.

DIAGRAMA 21

Program prog22;

{descuento a un empleado segun faltas}

Uses crt;

Const

Y=0.10;

Z=0.20;

E=0.15;

Var

Nom,c:string;

Nuem,op:integer;

D,x,des,ht,dt,sh,sq,sd:real;

Resp:char;

Begin

Repeat

Clrscr;

Writeln('capturar nombre');

Readln(nom);

Writeln('capturar # de empleado');

Readln(nuem);

Writeln('capturar categoria');

Readln(c);

Begin

Clrscr;

Writeln(' ***menu***');

Writeln('1 - de 6 a 8 faltas');

Writeln('2 - de 1 a 5 faltas');

Writeln;

Writeln('***seleccione una opcion y precione "enter"***');

Readln(op);

Case op of

1:begin

Clrscr;

Writeln('capturar numero de horas trabajadas al dia');

Readln(ht);

Writeln('capturar sueldo por hora ');

Readln(sh);

Writeln('capturar dias trabajados a la quincena');

Readln(dt);

Sq:=sh*ht*dt;

D:=(sq*z);

Sd:=ht*sh;

Des:=sq-d;

Clrscr;

Writeln('***datos***');

Writeln('nombre:');

Writeln(nom);

Writeln('puesto');

Writeln(c);

Writeln('sueldo diario ');

Writeln(sd:3:2);

Writeln('descuento dela quincena');

Writeln(d:3:2);

Writeln('sueldo quincenal');

Writeln(des:3:2);

Readln;

End;

2:begin

Clrscr;

Writeln('capturar numero de horas trabajadas al dia');

Readln(ht);

Writeln('capturar sueldo por hora ');

Readln(sh);

Writeln('capturar dias trabajados a la quincena');

Readln(dt);

Sq:=sh*ht*dt;

D:=(sq*y);

Sd:=ht*sh;

Des:=sq-d;

Clrscr;

Writeln('***datos***');

Writeln('nombre:');

Writeln(nom);

Writeln('puesto');

Writeln(c);

Writeln('sueldo diario ');

Writeln(sd:3:2);

Writeln('descuento dela quincena');

Writeln(d:3:2);

Writeln('sueldo quincenal');

Writeln(des:3:2);

Readln;

End;

Clrscr;

Writeln('desea seguir capturando s/n');

Readln(resp);

Until (resp<>'s') and (resp<>'s');

End.

DIAGRAMA 22

Program prog23;

{programa que realiza descuentos segun el codigo del articulo}

Uses crt;

Var

N,a,b,c,d:string;

P,t,t1:real;

Resp:char;

Begin

Repeat

Clrscr;

Writeln('el nombre de el articulo es:');

Readln(n);

Writeln('el precio de el articulo es:');

Readln(p);

If (p>=5000) then

Begin

Clrscr;

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);

Readln;

End

Else

If (p>=3000) and (p<5000) then

Begin

Clrscr;

Writeln('el articulo ', n ,' pertenece a el codigo "b"' );

T:=(p*20)/100;

T1:=p-t;

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);

Writeln('el precio final es :',t1:3:2);

Readln;

End

Else

If (p>=2000) and (p<3000) then

Begin

Clrscr;

Writeln('el articulo ', n ,' pertenece a el codigo "c"');

T:=(p*10)/100;

T1:=p-t;

Writeln('pertenece al codigo c');

Writeln('',n);

Writeln('el precio es :',p:3:2);

Writeln('el descuento fue del 10% esto es :',t:3:2);

Writeln('el precio final es :',t1:3:2);

Readln;

End;

If (p<2000) then

Begin

Clrscr;

Writeln('el articulo ', n ,' pertenece a el codigo "d"');

T:=(p*5)/100;

T1:=p-t;

Writeln('el precio es :',p:3:2);

Writeln('el descuento fue del 5% esto es :',t:3:2);

Writeln('el precio final es :',t1:3:2);

Readln;

End;

Writeln('desea seguir capturando <s/n>');

Readln(resp);

Until (resp<>'s') and (resp<>'s');

Writeln('presione enter para salir');

Readln;

End.

DIAGRAMA 23

Program prog24;

{programa que calcula el porcentaje de comision de cuatro empleados}

Uses crt;

Var

Nom:string[15];

Vta,total,pv:real;

Cv,ce:integer;

Begin

Clrscr;

Ce:=1;

While ce<=4 do

Begin

Writeln('nombre');

Readln(nom);

Cv:=0;

Total:=0;

Repeat

Writeln('ventas');

Readln(vta);

Total:=total+vta;

Cv:=cv+1;

Until cv=3;

Clrscr;

Pv:=total*0.005;

Clrscr;

Writeln('su nombre es:',nom);

Writeln('el total de ventas es:',total:2:2);

Writeln('el porcentaje de la venta es:',pv:2:2);

Ce:=ce+1;

End;

Writeln('precione "enter" para salir');

Readln;

End.

DIAGRAMA 24

Program prog25

{programa que calcula el promedio de 3 calificaciones de 2 alumnos};

Uses crt;

Var

M,s,n:string[15];

X,ca,c:integer;

P,total:real;

Begin

Clrscr;

Ca:=1;

While ca<=2 do

Begin

Writeln('nombre');

Readln(n);

Writeln;

Writeln('semestre que cursa');

Readln(s);

Writeln;

Writeln('nombre de la materia');

Readln(m);

X:=0;

Total:=0;

Repeat;

Writeln;

Writeln('calificacion');

Readln(c);

Total:=total+c;

X:=x+1;

Until x=3;

Clrscr;

P:=total/3;

Writeln('nombre: ',n);

Writeln;

Writeln('semestre que cursa: ',s);

Writeln;

Writeln('nombre de la materia: ',m);

Writeln;

Writeln('el promedio de calificaciones: ',p:2:2);

Writeln;

Ca:=ca+1;

End;

Writeln('presione "enter" para salir');

Readln;

End.

DIAGRAMA 25

Program prog26

{programa que calcula el total de 3 carros};

Uses crt;

Var

Cc:integer;

M,c,mar,p:string[15];

Pre,t,tot,imp:real;

Begin

Clrscr;

Cc:=1;

T:=0;

While cc<=3 do

Begin

Writeln('programa que calcula el precio de 3 carros');

Writeln;

Writeln('modelo del carro');

Readln(m);

Writeln('marca del carro');

Readln(mar);

Writeln('cilindros del carro');

Readln(c);

Writeln('puertas del carro');

Readln(p);

Writeln('precio del auto');

Readln(pre);

T:=t+pre;

Clrscr;

Cc:=cc+1;

End;

Imp:=t*0.15;

Tot:=t+imp;

Writeln('el subtotal de los 3 carros es:', t:3:2);

Writeln;

Writeln('el impuesto del 15% a los carros es de:', imp:3:2);

Writeln;

Writeln('el total de los carros con impuestos es de :', tot:3:2);

Writeln;

Writeln('presione "enter" para salir');

Readln;

End.

DIAGRAMA 26

Program prog27

{programa que calcula el precio de 4 peliculas};

Uses crt;

Var

Cp,cc,ca:integer;

P,t,tot,st:real;

Mem,c,np,cla:string[15];

Begin

Clrscr;

Cc:=1;

While cc<=2 do

Begin

Writeln('nombre del cliente');

Readln(c);

Writeln;

Writeln('numero de membresia');

Readln(mem);

Cp:=0;

T:=0;

Repeat

Writeln;

Writeln('nombre de pelicula');

Readln(np);

Writeln;

Writeln('categoria de la pelicula "1,2,3"');

Readln(ca);

Writeln;

Writeln('clasificacion de la pelicula');

Readln(cla);

Writeln;

Writeln('precio de la pelicula');

Readln(p);

If ca=1 then

Begin

Tot:=p*0.3;

St:=p-tot;

End;

If ca=2 then

Begin

Tot:=p*0.2;

St:=p-tot;

End;

If ca=3 then

Begin

Tot:=p*0.1;

St:=p-tot;

End;

T:=t+st;

Cp:=cp+1;

Until cp=4;

Clrscr;

Writeln('el total a pagar por 4 peliculas es de:', t:3:2);

Readln;

Cc:=cc+1;

End;

Textcolor(yellow);

Writeln;

Writeln('el programa ha concluido, presione enter para salir');

Readln;

End.

DIAGRAMA 27

Program prog28

{programa que calcula la suma y el descuento de 8 articulos};

Uses crt;

Var

Nom:string[15];

Pre,t,tot,des:real;

Ca:integer;

Begin

Clrscr;

Ca:=1;

Tot:=0;

While ca<=8 do

Begin

Writeln;

Writeln('nombre del articulo');

Readln(nom);

Writeln;

Writeln('precio del articulo');

Readln(pre);

Tot:=tot+pre;

Ca:=ca+1;

End;

If (tot>=2000) then

Begin

Des:=tot*0.1;

T:=tot-des;

Writeln('el total de los articulos es de:', tot:3:2);

Writeln;

Writeln('el descuento del 10% por ser mayor de 2000 es de:', des:3:2);

Writeln;

Writeln('el total a pagar es de:', t:3:2);

Readln;

End;

If (tot<2000) then

Begin

Writeln('el total de los articulos es de:', tot:3:2);

Readln;

End;

End.

DIAGRAMA 28

Program prog29

{programa que calcula el precio de prendas en una limpiaduria};

Uses crt;

Const

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;

Var

T,st,des,pan1,cha1,blu1,cam1,ves1,fal1,sac1:real;

Resp:char;

Op:integer;

Begin

Repeat

Clrscr;

Writeln(' limpiaduria');

Writeln;

Writeln('cantidad de pantalones entregados');

Readln(pan1);

Writeln;

Writeln('cantidad de chammarras entregadas');

Readln(cha1);

Writeln;

Writeln('cantidad de blusas entregadas');

Readln(blu1);

Writeln;

Writeln('cantidad de camisas entregadas');

Readln(cam1);

Writeln;

Writeln('cantidad de vestidos entregados');

Readln(ves1);

Writeln;

Writeln('cantidad de faldas entregadas');

Readln(fal1);

Writeln;

Writeln('cantidad de sacos entregados');

Readln(sac1);

Clrscr;

Writeln('menu de opciones');

Writeln;

Writeln('1 - lunes');

Writeln('2 - martes');

Writeln('3 - miercoles');

Writeln('4 - jueves');

Writeln('5 - viernes');

Writeln;

Writeln('escoja una opcion');

Readln(op);

Clrscr;

Case op of

1:begin

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;

Writeln('total de articulos:', st:3:2);

Writeln('descuento del dia lunes:', des:3:2);

Writeln('total a pagar:', t:3:2);

Readln;

End;

2:begin

St:=(pan1*pan)+(cha1*cha)+(blu1*blu)+(cam1*cam)+(ves1*ves)+(fal1*fal)+(sac1*sac);

Des:=mar*st;

T:=st-des;

Writeln('** martes **');

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;

Writeln('total de articulos:', st:3:2);

Writeln('descuento del dia martes:', des:3:2);

Writeln('total a pagar:', t:3:2);

Readln;

End;

3:begin

St:=(pan1*pan)+(cha1*cha)+(blu1*blu)+(cam1*cam)+(ves1*ves)+(fal1*fal)+(sac1*sac);

Des:=mie*st;

T:=st-des;

Writeln('** miercoles **');

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;

Writeln('total de articulos:', st:3:2);

Writeln('descuento del dia miercoles:', des:3:2);

Writeln('total a pagar:', t:3:2);

Readln;

End;

4:begin

St:=(pan1*pan)+(cha1*cha)+(blu1*blu)+(cam1*cam)+(ves1*ves)+(fal1*fal)+(sac1*sac);

Des:=jue*st;

T:=st-des;

Writeln('** jueves **');

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;

Writeln('total de articulos:', st:3:2);

Writeln('descuento del dia jueves:', des:3:2);

Writeln('total a pagar:', t:3:2);

Readln;

End;

5:begin

St:=(pan1*pan)+(cha1*cha)+(blu1*blu)+(cam1*cam)+(ves1*ves)+(fal1*fal)+(sac1*sac);

Des:=vie*st;

T:=st-des;

Writeln('** viernes **');

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;

Writeln('total de articulos:', st:3:2);

Writeln('descuento del dia viernes:', des:3:2);

Writeln('total a pagar:', t:3:2);

Readln;

End;

Clrscr;

Writeln('desea seguir capturando s/n');

Readln(resp);

Until (resp<>'s') and (resp<>'s');

End.

DIAGRAMA 29

Program prog30

{programa que calcula el promedio de un alumno con 3 calificaciones};

Uses crt;

Var

Nom:string[15];

Sum,cal,prom:real;

Ccal:integer;

Begin

Clrscr;

Write('nombre del alumno: ');

Readln(nom);

Sum:=0;

Ccal:=1;

While ccal<=3 do

Begin

Writeln;

Write('calificacion',ccal,': ');

Readln(cal);

Sum:=sum+cal;

Ccal:=ccal+1;

End;

Prom:=sum/3;

Begin

Clrscr;

Writeln('alumno:',nom);

Writeln;

Writeln('el promedio es:',prom:2:2);

Writeln;

Writeln('presione enter para salir');

Readln

End;

End.

DIAGRAMA 30

PROGRAM PROG31

{PROGRAMA QUE CONVIERTE MINUTOS A SEGUNDOS};

USES CRT;

VAR

min,seg:real;

resp:char;

begin

clrscr;

write('Deseas convertir minutos a segundos: ');

readln(resp);

while (resp='s') or (resp='S') do

begin

Write('Captura los minutos:');

readln(min);

seg:=min*60;

Writeln('',min:2:2,' minutos son ',seg:2:2,' segundos');

writeln;

writeln('Desea seguir capturando');

readln(resp);

end;

end.

DIAGRAMA 31

PROGRAM PROG32;

{PROGRAMA QUE CAPTURA NOMBRES Y SE SALE EN UN NOMBRE DETERMINADO}

USES CRT;

VAR

N,NOM,hector:STRING[12];

BEGIN

CLRSCR;

REPEAT

WRITELN('DAME NOMBRE');

READLN(NOM);

N:=NOM;

UNTIL (NOM='HECTOR') OR (NOM='hector');

END.

DIAGRAMA 32

program prog33

{programa que calcula la raiz cuadrada de un numero};

uses crt;

var

num,i:integer;

raiz:real;

begin

clrscr;

num:=0;

for i:=1 to 10 do

begin

num:=num+1;

raiz:=sqrt(num);

writeln('La raiz cuadrada de',num:3,' es :',raiz:2:2);

readln;

end;

end.

DIAGRAMA 33

program prog34

{programa que calcula la tabla del 2};

uses crt;

var

i:integer;

res:real;

begin

clrscr;

for i:=1 to 10 do

begin

res:=2*i;

writeln(`2 x `,i:3,' es :',res:2:2);

readln;

end;

end.

DIAGRAMA 34

program prog35

{programa que calcula el cuadrado de un numero};

uses crt;

var

num,i:integer;

cua:real;

begin

clrscr;

num:=0;

for i:=1 to 10 do

num:=num+1;

cua:=sqr(num);

writeln('El cuadrado de',num:3,' es :',cua:2:2);

readln;

end.

DIAGRAMA 35

program prog36

{programa que despliaga los numeros del 1 al 100};

uses crt;

var

i:integer;

begin

clrscr;

for i:=1 to 100 do

write(' ',i:3);

readln;

end.

DIAGRAMA 36

program prog37

{programa que calcula la tabla de multiplicar de cualquier numero};

uses crt;

var

num,res:real;

i:integer;

begin

clrscr;

writeln('Que numero deseas utilizar para calcular su tabla');

readln(num);

for i:=1 to 10 do

begin

res:=num*i;

writeln('',num:2:2,' x',i:2,' es: ',res:2:2);

readln;

end;

end.

DIAGRAMA 37

program prog38

{reciproco de los numeros 1 al 25};

uses crt;

var

i:integer;

res:real;

begin

clrscr;

for i:=1 to 25 do

begin

res:=1/i;

writeln('1/',i:2,' es igual a:',res:2:3);

readln;

end;

end.

DIAGRAMA 38

program prog39

{programa que calcula el cuadrado de veinte numeros apartir de un numero x};

uses crt;

var

i:integer;

num,res:real;

begin

clrscr;

write('Desde que numero deseas empezar: ');

readln(num);

for i:=1 to 20 do

begin

res:=sqr(num);

writeln('el cuadrado de ',num:2:2,' es:', res:2:2);

readln;

num:=num+1;

end;

end.

DIAGRAMA 39

program prog40

{programa que depliega numeros del 1 - 500};

uses crt;

var

num,x,y:integer;

begin

clrscr;

x:=1;

y:=1;

for num:=1 to 500 do

begin

gotoxy(x,y);

write(num);

y:=y+1;

if (y=26) then

begin

y:=1;

x:=x+4;

end;

readln;

end.

DIAGRAMA 40

program prog41;

{programa que captura la tabla de multiplicar del 2 y 3}

uses crt;

var

x,p,i,j:integer;

begin

clrscr;

x:=2; p:=0;

for i:= 1 to 2 do

begin

for j:=1 to 10 do

begin

p:=x*j;

writeln('',x,' * ',j,'=',p);

end;

x:=x+1;

end;

readln;

end.

DIAGRAMA 41

program prog42

{programa que calcula el promedio de 4 calificaciones};

uses crt;

var

i:integer;

prom,cal,tot:real;

begin

clrscr;

tot:=0;

for i:=1 to 4 do

begin

writeln('calificacion ',i:1,':');

readln(cal);

tot:=tot+cal;

end;

prom:=tot/4;

writeln('el promedio de las 4 calificaciones es:',prom:2:2);

readln;

end.

DIAGRAMA 42

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.

Tipo de datos

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.

La asignación de tipos a los datos tiene dos objetivos principales:

Detectar errores de operaciones en programas.

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.

Clasificación de los tipos de datos

Enteros:

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.

Reales:

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)

DATOS

NUMERICO CADENA DE CARACTERES LOGICOS

REALES ENTEROS

DECIMALES COMA FLOTANTE

La Estructura de Datos

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.

Símbolos

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

Compilar

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.

Errores

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.

La protección contra los errores suele efectuarse añadiendo bits adicionales a los paquetes que contienen los datos a transferir. Alrededor del 4% de los bits en un paquete de datos se dedican a la detección de errores. El método más sencillo de aprovechar estos bits es fijar un bit de paridad, un único dígito que se coloca para que la suma de una determinada secuencia de bits sea 1 o 0. Es una forma muy eficaz de detectar errores de bits aislados, pero no sirve cuando hay errores que afectan a 2 (o 4) bits.

Normalmente se utilizan otras técnicas más depuradas conocidas como sumas de control. Se fundamentan en complejos cálculos matemáticos y resultan eficaces para detectar diferentes tipos de errores. Más enrevesadas resultan las técnicas de corrección de errores, que suelen precisar un porcentaje mayor de bits, pero que son capaces de corregir realmente errores de transmisión eliminando la necesidad de retransmitir paquetes enteros por culpa de un único bit.

Ejecutar

Realiza una instrucción o pasar un programa en un ordenador

Fases de la programación:

1.- ANALISIS: Cuando se tiene y piensa la idea o problema a ejecutar.

2.- DISEÑO: Se plantea un algoritmo con los pasos a dibujar o realizarse.

3.- IMPLEMENTACION: Los pasos de algoritmo se transforma en un código pascal y se plasman en el programa

4.- PRUEBAS: Se corre el programa y se registra su efectividad.

5.- DEPURACION: después de haber corrido el programa se hacen las correcciones necesarias.

6.- RETROALIMENTACION Y LIBERACION: Después de haber corregido los errores se regresa al paso 4 en caso de haber existido.

Estructura de un programa

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

Estructura de un programa en pascal

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

Begin

{cuerpo del programa}

end

*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;

Compilar

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.

Ejecución

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.

LENGUAJES DE BAJO NIVEL

Vistos a muy bajo nivel, los microprocesadores procesan exclusivamente señales electrónicas binarias. Dar una instrucción a un microprocesador supone en realidad enviar series de unos y ceros espaciadas en el tiempo de una forma determinada. Esta secuencia de señales se denomina código máquina. El código representa normalmente datos y números e instrucciones para manipularlos. Un modo más fácil de comprender el código máquina es dando a cada instrucción un mnemónico, como por ejemplo STORE, ADD o JUMP. Esta abstracción da como resultado el ensamblador, un lenguaje de muy bajo nivel que es específico de cada microprocesador.

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.

LENGUAJES DE ALTO NIVEL

Por lo general se piensa que los ordenadores son máquinas que realizan tareas de cálculos o procesamiento de textos. La descripción anterior es sólo una forma muy esquemática de ver una computadora. Hay un alto nivel de abstracción entre lo que se pide a la computadora y lo que realmente comprende. Existe también una relación compleja entre los lenguajes de alto nivel y el código máquina.

Los lenguajes de alto nivel son normalmente fáciles de aprender porque están formados por elementos de lenguajes naturales, como el inglés. En BASIC, el lenguaje de alto nivel más conocido, los comandos como "IF CONTADOR = 10 THEN STOP" pueden utilizarse para pedir a la computadora que pare si CONTADOR es igual a 10. Por desgracia para muchas personas esta forma de trabajar es un poco frustrante, dado que a pesar de que las computadoras parecen comprender un lenguaje natural, lo hacen en realidad de una forma rígida y sistemática.

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.

PREGUNTAS FRECUENTES

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.

10- Definir

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

CICLOS FOR

El ciclo FOR repite una sentencia un determinado número de veces que se indica al momento de llamar al ciclo.

Lo que hace FOR es que incrementa una variable en uno desde un valor inicial hasta un valor final ejecutando en cada incremento la sentencia que se quiere repetir. Su sintaxis es:

FOR identificador:= inicio TO fin DO instrucción;

Donde el identificador es la variable que se incrementará, inicio es el primer valor que tendrá dicha variable y fin es el valor hasta el cual se incrementará la misma; instrucción es la sentencia (sencilla o compuesta) que se ejecutará en cada incremento de la variable.

El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La variable utilizada es "Numero".

PROGRAM Ciclo_FOR;
VAR
Numero : Integer;

BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.

Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se ejecutará el número de veces predefinido sin posibilidad de agregar o eliminar ciclos.

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:

PROGRAM Ciclo_FOR_2;
VAR
Numero : Integer;

BEGIN
FOR Numero := 50 DOWNTO 1 DO
WriteLn(Numero);
END.

CICLOS WHILE

Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza mientras se cumpla una condición, por lo tanto es posible controlar el número de repeticiones una vez iniciado el ciclo. Su sintaxis es:

WHILE condición DO instrucción

Donde condición es la condición que se evaluará, mientras ésta sea verdadera se ejecutará la instrucción, que es una sentencia simple o compuesta.

Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se vería como sigue:

PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;

BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.

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.

CICLOS REPEAT-UNTIL

Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia entre ambos es que en WHILE la condición se evalúa al principio del ciclo, en cambio en REPEAT-UNTIL se evalúa al final, lo que significa que en un ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos una vez, cosa que puede no ocurrir en el ciclo WHILE. Ejemplo:

PROGRAM Ciclo_RepeatUntil;
VAR
Numero : Integer;
BEGIN
Numero := 1;
REPEAT
WriteLn (Numero);
Numero := Numero + 1;
UNTIL Numero = 50;
END.

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 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 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>

PROGRAMACIÓN MODULAR

Uno de los métodos más conocidos para resolver un problema es dividirlo en problemas más pequeños, llamados subproblemas. De esta manera, en lugar de resolver una tarea compleja y tediosa, resolvemos otras más sencillas y a partir de ellas llegamos a la solución. Esta técnica se usa mucho en programación ya que programar no es más que resolver problemas, y se le suele llamar diseño descendente, metodología del divide y vencerás o programación top-down.

Es evidente que si esta metodología nos lleva a tratar con subproblemas, entonces también tengamos la necesidad de poder crear y trabajar con subprogramas para resolverlos. A estos subprogramas se les suele llamar módulos, de ahí viene el nombre de programación modular. En Pascal disponemos de dos tipos de módulos: los procedimientos y las funciones.

Programación Estructurada es una técnica en la cual la estructura de un programa, esto es, la interpelación de sus partes realiza tan claramente como es posible mediante el uso de tres estructuras lógicas de control:

a. Secuencia: Sucesión simple de dos o mas operaciones.

b. Selección: bifurcación condicional de una o mas operaciones.

c. Interacción: Repetición de una operación mientras se cumple una condición.

Estos tres tipos de estructuras lógicas de control pueden ser combinados para producir programas que manejen cualquier tarea de procesamiento de información.

Un programa estructurado esta compuesto de segmentos, los cuales puedan estar constituidos por unas pocas instrucciones o por una pagina o más de codificación. Cada segmento tiene solamente una entrada y una salida, estos segmentos, asumiendo que no poseen lazos infinitos y no tienen instrucciones que jamás se ejecuten, se denominan programas propios. Cuando varios programas propios se combinan utilizando las tres estructuras básicas de control mencionadas anteriormente, el resultado es también un programa propio.

Estructura Secuencial

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.

Estructura selectiva:

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.

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)

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

Estructura Repetir (repeat)

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.

Estructura Desde/Para (for)

En muchas ocasiones se conoce de antemano el número de veces que se desean ejecutar las acciones de un bucle. En estos casos en el que el número de iteraciones es fija, se debe usar la estructura desde o para.

La estructura Desde ejecuta las acciones del cuerpo del bucle un número específico de veces y de modo automático controla el número de iteraciones o pasos a través del cuerpo del bucle.

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.

Iteración

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).

loop

...

end loop;

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

Operador	Operación	Operandos	Ejemplo	Resultado
+	Suma	real , integer	a + b	suma de a y b
-	Resta	real , integer	a - b	Diferencia de a y b
*	Multiplicación	real , integer	a * b	Producto de a por b
/	División	real , integer	a / b	Cociente de a por b
div	División entera	integer	a div b	Cociente entero de a por b
mod	Módulo	integer	a mod b	Resto de a por b
shl	Desplazamiento a la izquierda		a shl b	Desplazar a la izquierda b bits
shr	Desplazamiento a la derecha		a shr b	Desplazar a la derecha b bits

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.

CASE-OF-ELSE

Esta forma es muy útil cuando se tiene que elegir entre más de dos opciones, por lo que le llamaremos forma de selección múltiple.

Dependiendo del valor que tenga la expresión selector, se ejecutarán las instrucciones etiquetadas por constante .

Aquí también los bloques de instrucciones pueden ser reemplazados por instrucciones simples.

Conviene tener presente que no debe escribirse punto y coma antes de la palabra else.

FOR-TO-DO

Cuando se sabe de antemano el número de veces que deberá ejecutarse un ciclo determinado, ésta es la forma más conveniente.

El formato para for-to-do es :

for <contador>:=<expresión.1> to <expresión.2> do

begin

<Instrucciones> ;

end;

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.

REPEAT-UNTIL

La acción de repeat-until es repetir una serie de instrucciones hasta que se cumpla una determinada condición.

Su formato es :

repeat

<instrucción.1> ;

<instrucción.2> ;

..................

<instrucción.N> ;

until <condición>;

Aquí las palabras repeat y until sirven también como delimitadores de bloque.

WHILE-DO

La estructura repetitiva while(mientras) es aquella en la que el número de iteraciones no se conoce por anticipado y el cuerpo del bucle se ejecuta repetidamente mientras que una condición sea verdadera .

Su formato es :

while <condición> do

begin

<instrucciones>;

end;

Acumulador

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.

Bifurcación

Se utilizan para saltar de un lugar a otra zona del programa o código si es que se cumple una cierta condición.

Interruptor

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.

Ruteador

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.

Paquete de datos

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

Swich

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

TCP PACKET

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.

ICMP Ping packet

Sirve para indicar errores en el proceso de transmisión de datos como si fuera una ayuda

UDP packet

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

Ping of death

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.

Router Switch

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 :

Su sintaxis es:

A[i]

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

vector A.

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[1] = 5

A[2] = 7

A[3] = 2

A[4] = 9

A[5] = 3

: :

A[i+N] = X

Un ejemplo podría ser:

inicio

leer n

para e de 1 hasta n hacer

imprimir "teclee la edad de la persona",e

leer edad

L[e] edad

fin para

para i de 1 hasta n hacer

imprimir "la edad de la persona",i," es: ",L[i]

fin para

fin

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:

Su sintaxis es:

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

Gráficamente se vería así :

Ú 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

Y así mismo:

A[1,1] = 5

A[1,2] = 7

A[1,3] = 2

A[2,1] = 8

A[2,2] = 3

A[2,3] = 9

A[3,1] = 4

A[3,2] = 6

A[3,3] = 1

Un ejemplo podría ser:

Inicio

imprimir "Teclee el numero de personas que desea registrar"

leer n

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

leer edad

imprimir "teclee el teléfono de la persona" ,p

leer tele

R[p,1] código

R[p,2] edad

R[p,3] tele

Fin para

para i de 1 hasta n hacer

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]

fin para

fin

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.

Diagrama de flujo

Es un cuadro que explica paso por paso la secuencia de un objeto o programa

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

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

Estructura de datos

Es 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

Acumulador

Bifurcación

Se utilizan para saltar de un lugar a otra zona del programa o código si es que se cumple una cierta condición.

Interruptor

Ruteador

Paquete de datos

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

Swich

TCP PACKET

ICMP Ping packet

Sirve para indicar errores en el proceso de transmisión de datos como si fuera una ayuda

UDP packet

Ping of death

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.

Router Switch

Sirve para eliminar la necesidad de comprar HUD y para que la red este completamente dedicada teniendo un backbone duplex

BIBLIOGRAFIA

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

119

INICIO

N1,N2

N1,N2:INTEGER

T:REAL

N1,N2

T:=N1+N2

FIN

INICIO

N,A:STRING

N,A

FIN

INICIO

TC = 9.80

P,D:REAL

D:=P/TC

FIN

INICIO

C1,C2,P:REAL

C1,C2

P:= (C1+C2)/2

FIN

INICIO

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

INICIO

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

FIN

INICIO

N,D,T:STRING

N,D,T

N,T,D

FIN

INICIO

N1.N2,P:REAL

N1,N2

T:=N1*N2

FIN

INICIO

R,M:REAL

CM=100

R:=M*CM

FIN

R:=MI*KM

KM=1.609

R,MI:REAL

INICIO

S,EX1,EX2 :REAL

EX1,EX2

S:=EX1+EX2

IF S>=80 THEN

RECHAZADO

ACEPTADO

FIN

INICIO

C,T,CM1,V:REAL

V,C

T:=V*C

T>1500

CM1:=T*(20/100)

CM1:=T*(10/100)

CM1

FIN

N,S,A,P

SE ELABORA BOLETA

NO SE ELABORA BOLETA

A=>80

P=>7

N,S,A,P

S,N:INTEGER; A,P:REAL

INICIO

N:STRING

E,P:REAL

N,E,P

P>6

P<8

E>6

E<8

E=>8

P=>8

POBLA-CION A

POBLA-CION B

POBLA-CION C

FIN

OP=1

OP=3

OP=2

OP=4

ADIOS

C=PI(SQR(R))

CU=B*AL

T=(B*AL)/2

FIN

NUM ES 0

NUM ES NEG

NUM ES +

N<0

N>0

N:REAL

INICIO

N1,N2,N3:REAL

N1,N2,N3

N1>N2

N1>N3

N2>N1

N2>N3

N3>N1

N3>N2

N1=N2

N2=N3

N1=N2

N1>N3

N1=N3

N1>N2

N1 ES MAYOR

N2 ES MAYOR

N3 ES MAYOR

SON IGUAL

N1,N2 IGUAL

N1,N3 IGUAL

N2,N3 IGUAL

FIN

ERROR

ADIOS

FIN

INICIO

A,B:INTEGER S,R,M,D:REAL

OP:CHAR

A,B

S=SUMA

R=RESTA

M=MULTIPLI

D=DIVISION

OP=S

OP=R

OP=M

OP=D

S:=A+B

R:=A-B

M:=A*B

D:=A/B

ERROR

FIN

1=TRIAN

2=CIRCULO

3=CUADRO

4=SALIR

B,AL,R

A,T,C,CU,B,AL,R,OP:REAL

INICIO

PI=3.1416

INICIO

SD,SH,HT,TC,P,D,E,A:REAL

1-SUELDO

2-EDAD

3-PESO-DLL

4-SALIR

OP=1

OP=2

OP=3

OP=4

SH,HT

SD=SH*HT

E=2002-A

TC,P

DLL=P/TC

DLL

ADIOS

ERROR

FIN

INICIO

N,R,CU,C:REAL

OP,RESP:CHAR

1-CUADRADO

2-RAIZ

3-COSENO

N,OP

CASE OP OF

ELSE

CU:=SQR(N)

R:=SQRT(N)

C:=COS(N)

SALIDA

DESEA SEGUIR CAPTURANDO

RESP

UNTIL R<>'S'

FIN

INICIO

N1,N2,N3,N4,T:REAL

RESP:CHAR

OP:INTEGER

1-SUMA

2-MULTIPLICAR

3-SALIR

CASE OP OF

ELSE

N1,N2, N3,N4

T:=N1+N2+N3+N4

N1,N2, N3,N4

T:=N1*N2*N3*N4

ADIOS

ERROR

FIN

INICIO

Y=0.10

Z=0.20

E=15

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

CASE OP OF

HT,SH

SQ:=SH*HT*E

D:=SQ*Z

SD:=HT*SH

DES:=SQ-D

N,C,SD,DES

SQ:=SH*HT*E

X:=SQ*Y

SD:=HT*SH

DES:=SQ-X

HT,SH

DESEA SEGUIR CAPTURANDO

UNTIL RESP<>'S'

PRESIONE ENTER

FIN

INICIO

RESP:CHAR

NOM:STRING

PRE,DES,TOT:REAL

NOM,PRE

IF PRE<2000

COD D

DES:=PRE*0.05

TOT:=PRE-DES

DES:=PRE*0.05

TOT:=PRE-DES

COD D

IF PRE<2000

DES:=PRE*0.05

TOT:=PRE-DES

COD D

IF PRE<2000

DES:=PRE*0.05

TOT:=PRE-DES

COD D

IF PRE<2000

ERROR

DESEA CONTINUAR

NOM,PRE,DES,TOT

RESP

UNTIL RESP='S'

FIN

INICIO

NOM:STRING

VTA,TOT,PV:REAL

CV,CE:INTEGER

CE:=1

WHILE CE<=4 DO

NOM,VTA

UNTIL CV=3

CV:=0

TOT:=0

CV:=CV+1

PV:=TOT*0.05

NOM,TOT,PV

CE:=CE+1

FIN

CA=CA+1

N,S,M,P

P:=TOT/3

TOT=X+TOT

C=C+1

X:=0

TOT:=0

UNTIL C=2

N,M,S,X

WHILE CA<=2 DO

CA:=1

N,S,M:STRING

P,TOT:REAL

X,CA,C:INTEGER

INICIO

CC:INTEGER

M,C,MAR,P:STING

PRE,T,TOT,IMP:REAL

CC=1

T=0

M,C,MAR,PRE,P

T=T+PRE

CC=CC+1

UNTIL CC<=3

IMP:=T*0.15

TOT:=T+IMP

T,IMP,TOT

PRESIONE ENTER PARA SALIR

FIN

INICIO

CP,CC,CA:INTEGER

P,T,TOT,ST:REAL

MEM,C,NP,CLA

UNTIL

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

ST:=P-TOT

TOT:=P*0.1

ST:=P-TOT

ERROR

T=T+ST

CP=CP+1

UNTIL CP=4

CC=CC+1

UNTIL CC=2

PROGRAMA HA CONCLUIDO

FIN

INICIO

NOM:STRING

PRE,T,TOT,DES:REAL

CA:INTEGER

CA:=1

WHILE CA<=8

PRE,NOM

TOT=TOT+PRE

CA:=CA+1

IF TOT>=2000 THEN

TOT

DES=TOT*.1

T=TOT-DES

TOT,DES,T

FIN

INICIO

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

RESP:CHAR

OP:INTEGER

PAN1,CHA1,BLU1,CAM1,VES1,SAC1,FAL1

ST=(PAN*PAN1)+(CHA*CHA1)+(BLU*BLU1)+(CAM+CAM1)+(VES*VES1)+(FAL*FAL1)+(SAC*SAC1

LUNES - 1

MARTES - 2

MIERCOLES - 3

JUEVES - 4

VIERNES - 5

CASE OP OF

DES=LUN*ST

T=ST-DES

DES=LUN*ST

T=ST-DES

DES=LUN*ST

T=ST-DES

DES=LUN*ST

T=ST-DES

DES=LUN*ST

T=ST-DES

PAN1,CHA1,BLU1,CAM1,VES1,FAL1,SAC1,ST,DES,T

DESEA SEGUIR CAPTURANDO?

FIN

INICIO

NOM:STRING

SUM,CAL,PROM:REAL

CCAL:INTEGER

NOM

SUM:=0

CCAL:=1

WHILE CCAL<=3 DO

CAL

SUM:=SUM+CAL

CCAL:=CCAL+1

PROM=SUM/3

NOM,PROM

PRESIONE ENTER PARA SALIR

FIN

INICIO

NIM,SEG:REAL

RESP:CHAR

QUIERE CONVERTIR MINUTOS A SEGUNDOS

WHILE RESP='S'

RESP

MIN

SEG=60*MIN

DESEA SEGUIR CAPTURANDO

FIN

INICIO

N,NOM,HECTOR:STRING

NOM

N:=NOM

UNTIL NOM:=HECTOR

FIN

INICIO

NUM,I:INTEGER

R:REAL

NUM:=0

FOR I:=1 TO 10 DO

NUM=NUM+1

R:=SQRT(NUM)

FIN

RES

FIN

RES:=2* I

FOR I:=1 TO 10 DO

NUM:=0

NUM,I:INTEGER

RES:REAL

INICIO

FIN

CU:=SQR(NUM)

NUM=NUM+1

FOR I:=1 TO 10 DO

NUM:=0

NUM,I:INTEGER

CU:REAL

INICIO

FIN

FOR I:=1 TO 100 DO

NUM:=0

I:INTEGER

INICIO

FIN

R:=NUM* I

NUM

FOR I:=1 TO 10 DO

NUM

I:INTEGER

NUM,R:REAL

INICIO

RES

FIN

RES=1/I

FOR I:=1 TO 25 DO

RES

I:INTEGER

RES:REAL

INICIO

FIN

NUM=NUM+1

RES:=SQR(NUM)

FOR I:=1 TO 20 DO

IF Y=26 THEN

I:INTEGER

NUM,RES:REAL

INICIO

FIN

Y:=Y+1

GOTO (X,Y); NUM

FOR I:=1 TO 500 DO

X:=1

Y:=1

NUM,X,Y:INTEGER

INICIO

X:=X+Y

Y:=1

FIN

P:=X*J

X:=X+1

FOR I:=1 TO 2 DO FOR J:=1 TO 10 DO

X:=2, P:=2

X,P,I,J:INTEGER

INICIO

PROM

FIN

PROM:=TOT/4

TOT:=TOT+CAL

FOR I:=1 TO 4 DO

TOT:=0

I:INTEGER

CAL,TOT:REAL

INICIO

CAL

Compilador

pascal

Programa fuente en pascal

Computadora

Programa

Objeto

(maquina)

Programa

Objeto

(Maquina)

Resultados del programa pascal

Computadora

Datos necesarios para programa pascal

Tal vez te pueda interesar:

Descargar

Enviado por:	Hector
Idioma:	castellano
País:	México

Palabras clave:

Algoritmos Resolución de problemas Programación estructurada Estructuras de datos

Te va a interesar