Escribir un programa que calcule la suma de los números hasta un
número dado (introducido por el usuario).

PROGRAM EJER51; 
        USES CRT;

        VAR x, y, num:INTEGER;
BEGIN
     ClrScr;

     WRITE ('Este programa calcula la suma de los numeros
hasta uno ');
     WRITE ('introducido por el usuario: ');

     READLN (num);       WRITELN ('');
     x:=0;

     WHILE num >= 0 DO
     BEGIN
          WRITELN (x);
          x:= x + num;
          num:=num - 1;
     END;
END.


PROGRAM EJER51;
        USES CRT;
        VAR i,num:INTEGER;
        VAR suma:LONGINT;
BEGIN
     ClrScr;

     WRITE('Introduzca un numero -> '); READLN(num);

     FOR i:=0 TO num DO
         suma:=suma+ i;

     WRITE('Suma '); WRITE('0-'); WRITE(num);
WRITE('---->'); WRITE(suma);
END.


Escribir un programa que pida un número y si el que se introduce
por el teclado es menor de 100 que vuelva a solicitarlo.

PROGRAM EJER52; 
        USES CRT;

        VAR num:INTEGER;
BEGIN
{Este programa no finaliza hasta que se escribe un numero mayor a 100}

     ClrScr;

     REPEAT
           WRITELN ('Introduzca un numero: ');
           READLN (num);
     UNTIL num > 100;
END.


PROGRAM EJER52;
        USES CRT;
        VAR num:INTEGER;
BEGIN
     ClrScr;

     WRITE('Introduzca un numero -> '); READLN(num);

     WHILE num<=100 DO
     BEGIN
          WRITE('Introduzca un numero -> '); READLN(num);
     END;
END.


Escribir un programa en Pascal que calcule el factorial de un número.

PROGRAM EJER53; 
        USES CRT;

        VAR factorial, x, num, y:REAL;
BEGIN
     {Este programa hace el factorial de un numero}

     ClrScr;

     WRITE ('Introduzca un numero para hacer su factorial: ');

     READLN (num);      WRITELN ('');

     x:=1;

     WHILE num > 1 DO
     BEGIN
           x:=x * num;
           num:=num - 1;
           WRITELN (x);
     END;
END.


PROGRAM EJER53;
        USES CRT;
        VAR temp,num,fac:LONGINT;
BEGIN
     ClrScr;

     fac:=1;
     temp:=num;

     WRITE('Introduzca un numero -> '); READLN(num);

     temp:=num;

     WHILE num>=1 DO
     BEGIN
          fac:=fac*num;
          num:=num-1;
     END;

     WRITE('El factorial de '); WRITE(temp); WRITE(' es '); WRITE(fac);
END.

Escribir un programa en Pascal que calcule la media de 5 números
introducidos por el teclado.

PROGRAM EJER54; 
        USES CRT;
        VAR n1, n2, n3, n4, n5:REAL;
        VAR resultado:REAL;
BEGIN
     ClrScr;

     WRITELN ('Introduzca 5 numeros para hacer su media');
     WRITELN ('');

     WRITE ('Nº 1: ');  READLN (n1);
     WRITE ('Nº 2: ');  READLN (n2);
     WRITE ('Nº 3: ');  READLN (n3);
     WRITE ('Nº 4: ');  READLN (n4);
     WRITE ('Nº 5: ');  READLN (n5);
     WRITELN ('');

     resultado:= (n1 + n2 + n3 + n4 + n5) / 2;

     WRITE (resultado:5:2);
END.

PROGRAM EJER54;
        USES CRT;
        VAR i:INTEGER;
        VAR num,suma:REAL;
BEGIN
     ClrScr;

     i:=0;

     REPEAT
           WRITE('Introduzca un numero: ');     READLN(num);
           suma:=suma+num;
           i:=i+1;
     UNTIL i=5;

     WRITE('La media es: ');    WRITELN(suma/i:5:2);
END.

Escribir un programa en Pascal que calcule el salario neto semanal
de un trabajador en función del número de horas trabajadas
y la tasa de impuestos de acuerdo a las siguientes hipótesis.

- Las primeras 35 horas se pagan a tarifa normal
- Las horas que pasen de 35 se pagan 1.5 veces la tarifa normal
- Las tasas de impuestos son:
	a: Los primeros 50 dólares son libres de impuestos
	b: Los siguientes 40 dólares tienen un 25% de impuestos
	c: Los restantes de 45% de impuestos

PROGRAM EJER55; 
        USES CRT;

        VAR sns:REAL; {salario neto semanal}
        VAR h_trabajadas, h_extra:REAL;
        VAR precio_h, precio_h_extra:REAL;
        VAR total:REAL;
        VAR impuestos0,impuestos25,impuestos45:REAL;
        {Impuestos con cada % correspondiente}
BEGIN
     ClrScr;

     WRITELN ('INTRODUZCA LOS DATOS PARA CALCULAR EL SALARIO
NETO SEMANAL');
     WRITELN ('');
     WRITE ('Las horas trabajadas semanales son 35, las demas
debe ');
     WRITELN ('considerarlas como horas extra. Escriba en
dolares.');
     WRITELN ('');
     WRITE ('Horas trabajadas: ');     READLN (h_trabajadas);
     WRITE ('Horas extra: ');          READLN (h_extra);
     WRITE ('Precio por cada hora: '); READLN (precio_h);
     WRITELN ('');

     precio_h_extra:=precio_h * 1.5;
     sns:=(h_trabajadas * precio_h) + (h_extra * precio_h_extra);

     impuestos0:=0;
     impuestos25:=sns - ((sns - 50) * 0.25);
     impuestos45:=sns - ((sns - 90) * 0.45);

     IF sns <= 50 THEN
     WRITELN ('El salario neto semanal es: ',sns:5:2)
     ELSE IF sns < 90 THEN
     WRITELN ('El salario neto semanal es: ',impuestos25:5:2)
     ELSE IF sns > 90 THEN
     WRITELN ('El salario neto semanal es: ',impuestos45:5:2);
END.


PROGRAM EJER55;
        USES CRT;
        VAR hor_tra,sal_bru,tas_imp,sal_net:real;
        CONST tar_hor=2;
        CONST tasa_imp1=0.25;
        CONST tasa_imp2=0.45;
BEGIN
     ClrScr;

     WRITE('Numero de horas trabajadas: ');     READLN(hor_tra);

     {Calculo del salario bruto}

     IF hor_tra <= 35 THEN
        sal_bru:=hor_tra*tar_hor
     ELSE
        sal_bru:=(35*tar_hor)+((hor_tra-35)*(1.5*tar_hor));

     {Calculo de impuestos}

     IF sal_bru <= 50 THEN
        tas_imp:=0
     ELSE IF sal_bru <= 90 THEN
        tas_imp:=(sal_bru-50)*tasa_imp1
     ELSE
        tas_imp:=(40*tasa_imp1)+((sal_bru-90)*tasa_imp2);

     {Calculo salario neto}

     sal_net:=sal_bru-tas_imp;

     WRITE('Horas trabajadas -------> ');  WRITELN(hor_tra:5:2);
     WRITE('Salario bruto-----------> ');  WRITELN(sal_bru:5:2);
     WRITE('Impuestos---------------> ');  WRITELN(tas_imp:5:2);
     WRITE('Salario neto------------> ');  WRITELN(sal_net:5:2);
END.


Escribir un programa en Pascal que detecte si un número es primo o no. 
Un número es primo si sólo es divisible por sí mismo y por la unidad.

Ejemplo: 	2,3,4,7,11,17,19 son números primos
		9 no es número primo, es divisible por 1, 9, 3
El algoritmo para resolver este problema pasa por dividir
sucesivamente el número estudiado por 2,3,4, etc., hasta
el propio número.
{Se puede hacer únicamente dividiento por 2,3 y 5. El 4
tambien se hace en el ejercicio, no se quita para no liar el
ejercicio, ya que son ejercicios para aprender, ya habra 
tiempo de perfeccionar nuestro codigo}

PROGRAM EJER56; 
        USES CRT;

        VAR num, x:INTEGER;
        VAR primo:INTEGER;
BEGIN
     ClrScr;

     WRITELN ('Introduzca un numero para comprobar si es primo.');
     WRITELN ('');

     x:=1;

     WRITE ('Introduzca el numero: ');        READLN (num);
     WRITELN ('');

     REPEAT
     x:= x + 1;
     primo:= num mod x;

     WRITELN (primo);
     UNTIL x = 5;   WRITELN ('');

     WRITELN ('Si ninguno de los resultados es 0, el numero es primo.');
     WRITELN ('Si alguno es 0, el numero no es primo.');
END.

PROGRAM EJER56;
        USES CRT;
        VAR i,num,flag:INTEGER;

BEGIN
     ClrScr;
     flag:=0;

     WRITE('Introduzca un numero -> '); READLN(num);

     FOR i:=2 TO (num-1) DO
     BEGIN
          IF (num mod i)=0 THEN
          flag:=1;
     END;

     IF flag=1 THEN
     BEGIN
          WRITE(num);   WRITE(' no es un numero primo');
     END
     ELSE
     BEGIN
          WRITE(num);   WRITE(' es un numero primo');
     END;
END.

Escribir un programa en Pascal que calcule la depreciación de un
objeto según el métodode la línea recta. Calcular el número
de años que tarda en hacerse 0.
En este método el valor original del objeto se divide por su vida
(número de años). 
El cociente resultanteserá la cantidad en la que el objeto se deprecia
anualmente. Por ejemplo, si un objeto se deprecia 8000 dólares en diez
años, entonces la depreciaciónanual será 8000/10=800 dólares.
Por tanto, el valor del objeto habrá disminuido en 800 dólares cada
año.
Nótese que la depreciación anual es la misma cada año cuando se
utiliza este método.

PROGRAM EJER57; 
        USES CRT;

        VAR annos, valor:REAL;
        VAR depreciacionanno:REAL;
        VAR x:INTEGER;
BEGIN
     ClrScr;

     WRITELN ('Escriba los datos para conocer la depreciacion anual');
     WRITELN ('');

     WRITE ('Valor original: ');        READLN (valor);
     WRITE ('Numero de años: ');    	READLN (annos);
     WRITELN ('');

     depreciacionanno:= valor / annos;
     x:=0;

     WHILE valor > 0.1 DO
     BEGIN
     valor:=valor - depreciacionanno;
     x:= x + 1;
     WRITELN ('AÑO ',x:2,': ',valor:8:0,' pts.');
     END;
END.


PROGRAM EJER57;
        USES CRT;

        VAR val_ini,val_dep,tas_dep:REAL;
        VAR i,anios:INTEGER;
BEGIN
     ClrScr;

     WRITE('Valor inicial -----> ');    READLN(val_ini);
     WRITE('Numero de años ----> ');    READLN(anios);

     tas_dep:=val_ini/anios;;
     val_dep:=val_ini-tas_dep;

     FOR I:=1 TO anios DO
     BEGIN
          WRITE('Año ');
          WRITE(i:3);
          WRITE(' ------ ');
          WRITELN(val_dep:10:2);
          val_dep:=val_dep-tas_dep;
     END;
END.

Escribir un programa en Pascal que calcule la depreciación de
un objeto según el método del balance doblemente declinante.
En este método, el valor del objeto disminuye cada año en un
porcentaje constante.
Por tanto, la verdadera cantidad depreciada, en dólares, variara de
un año al siguiente.
Para obtener el factor de depreciación, dividimos por dos la vida del
objeto. Este factor se multiplica por el valor del objeto al comienzo
de cada año (y no el valor del original del objeto) para obtener la
depreciación anual. Supongamos, por ejemplo que deseamos
depreciar un objeto de 8000 dólares por diez años; el factor
de depreciación será 2/10=0.2.Por tanto, la depreciación
el primer año será 0,2 X 8000 = 1600 dólares, la
depreciación del segundo año será 0,2 X 6400=1280
dólares; la depreciación del tercer año será 0,2
X 5120 = 1024 dólares, y así sucesivamente.

PROGRAM EJER58; 
        USES CRT;
        VAR fdd:REAL; {Factor de depreciacion}
        VAR vidaobj:REAL; {Vida del objeto = años}
        VAR depreciacionanno:REAL;
        VAR valorobj:REAL; {Valor del objeto}
        VAR x:INTEGER;
BEGIN
     ClrScr;
     WRITE ('PARA CALCULAR LA DEPRECIACION POR EL METODO DEL
BALANCE ');
     WRITELN ('DOBLEMENTE DECLINANTE ESCRIBA LOS DATOS:');
     WRITELN ('');

     WRITE ('VALOR DEL OBJETO: ');      READLN (valorobj);
     WRITE ('AñOS: ');           READLN (vidaobj);
     WRITELN ('');

     fdd:= 2 / vidaobj;
     x:=1;

     REPEAT
          depreciacionanno:= fdd * valorobj;
          valorobj:=valorobj - depreciacionanno;
          WRITELN ('AñO ',x:2,': ',valorobj:8:2,' pts.');
          x:= x + 1;
     UNTIL x > vidaobj;

     WRITELN ('');
     x:= x - 1;
     WRITELN ('EL VALOR A LOS ',x,' AñOS SERA DE: ',
valorobj:6:2,' pts.');
END.

PROGRAM EJER58;
        USES CRT;

        VAR val_ini,val_dep,coe_dep,tas_dep:REAL;
        VAR i,anios:INTEGER;
BEGIN
     ClrScr;

     WRITE('Valor inicial ----->');         READLN(val_ini);
     WRITE('Numero de años ----> '); READLN(anios);

     coe_dep:=2/anios;
     tas_dep:=val_ini*coe_dep;
     val_dep:=val_ini-tas_dep;

     FOR i:=1 TO anios DO
     BEGIN
          WRITE('Año ');
          WRITE(i:3);
          WRITE(' ------ ');
          WRITELN(val_dep:10:2);
          val_dep:=val_dep-(val_dep*coe_dep);
     END;
END.

Escribir un programa que calcule las raíces de la
ecuación (ax2 + bx + c = 0) teniendo en cuenta los siguientes casos:

a. Si a es igual a 0 y b es igual a 0, imprimiremos un mensaje diciendo
que la ecuación es degenerada.
b. Si a es igual a 0 y b no es igual a 0, existe una raíz
única con valor -c/b.
c. En los demás casos, utilizaremos la fórmula siguiente:
xi = (-b ± raizcuadrada(b2 - 4ac))/(2a)
La expresión d = b2 - 4ac se denomina discriminante.
- Si d es mayor o igual que 0 entonces hay dos raíces reales
- Si d es menor que 0 entonces hay dos raíces complejas de la
forma: x+yi,x-yi.
Siendo x el valor -b/2a e y el valor absoluto de
raizcuadrada(b2-4ac)/(2a)

PROGRAM EJER59; 
        USES CRT;

        VAR a, b ,c:REAL;
        VAR sp, sn:REAL; {Solucion positiva y negativa}
        VAR d:REAL; {Discriminante}
BEGIN
     ClrScr;
     WRITELN ('Introduzca los valores para calcular la ecuacion de 2º
grado');
     WRITELN ('');

     WRITE ('a: ');     READLN (a);
     WRITE ('b: ');     READLN (b);
     WRITE ('c: ');     READLN (c);
     WRITELN ('');

     IF (a=0) and (b=0)  THEN
     WRITELN ('La ecuacion es degenerada.')
     ELSE IF (a=0) and (b<>0) THEN
     WRITELN ('Existe una raiz con valor -c/b: ',-c/b:5:2)
  ELSE
  BEGIN
     sp:=(-b + sqrt(sqr(b) - (4 * a * c))) / 2 * a;
     sn:=(-b - sqrt(sqr(b) - (4 * a * c))) / 2 * a;
     d:=sqr(b) - (4 * a * c);

     WRITE ('La solucion positiva es: ');     WRITELN (sp:5:2);
     WRITE ('La solucion negativa es: ');     WRITELN (sn:5:2);
  END;
END.

PROGRAM EJER59;
        USES CRT;
        VAR a,b,c,d,r1,r2,x,y:REAL;
BEGIN
     ClrScr;

     WRITE('Coeficiente a -> ');        READLN(a);
     WRITE('Coeficiente b -> ');        READLN(b);
     WRITE('Coeficiente c -> ');        READLN(c);

     IF (a=0) AND (b=0) THEN
     BEGIN
          WRITE('La ecuacion es degenerada');
          EXIT;
     END
     ELSE IF (a=0) AND (b<>0) THEN
     BEGIN
          r1:=c/b;
          WRITE('r1 = '); WRITELN(r1:5:2);
          EXIT;
     END
     ELSE
     BEGIN
          d:=sqr(b)-4*a*c;
          IF (d>=0) THEN
          BEGIN
               r1:=(-b+sqrt(sqr(b)-4*a*c))/(2*a);
               r2:=(-b-sqrt(sqr(b)-4*a*c))/(2*a);
               WRITE('r1 = ');      WRITELN(r1:5:2);
               WRITE('r2 = ');      WRITELN(r2:5:2);
          END
          ELSE
          BEGIN
               x:=-b/(2*a);
               y:=-b-sqrt(abs(sqr(b)-4*a*c));
               WRITE('r1 = '); WRITE(x:5:2); WRITE(' + '); WRITE(y:5:2);
               WRITELN('i');
               WRITE('r2 = '); WRITE(x:5:2); WRITE(' - '); WRITE(y:5:2);
               WRITELN('i');
          END;
     END;
END.


Escribir un programa en Pascal que sume dos cadenas. (los datos vienen en
el cuerpo del ejercicio).

PROGRAM EJER60; 
        USES CRT;

        VAR tit_pel1:STRING;
        VAR tit_pel2:STRING;
        VAR tit_pel3:STRING;
BEGIN
     tit_pel1:='Alien';
     tit_pel2:='Blade ';
     tit_pel3:='Runner';

     ClrScr;

     WRITELN ('TITULOS DE PELICULAS');

     WRITELN (tit_pel1);
     WRITELN (tit_pel2 + tit_pel3);

END.


PROGRAM EJER60;
        USES CRT;
        VAR tit_pel1:STRING;
        VAR tit_pel2:STRING;
        VAR tit_pel3:STRING;
BEGIN
     tit_pel1:='Alien';
     tit_pel2:='Blade';
     tit_pel3:='Runner';

     ClrScr;

     WRITELN('TITULOS DE PELICULAS');

     WRITELN(tit_pel1);
     WRITELN(tit_pel2 + tit_pel3);
END.

Volver