Programmming

Ejercicio3(arrays)

2011-11-23T19:10:00.000+01:00

Plantee e implemente un programa en PASCAL que calcule la suma de los elementos de un array de números reales proporcionados por el usuario, considerando como máximo 30 elementos.

PROGRAM ejercicio(input,output);
(*Programa que contenga un array en el que se puedan insertar como máximo 30 elementos y que haga la suma de ellos considerandolos numeros reales introducidos por el usuario*)
TYPE
TAelementos = ARRAY[1..30] OF real;
VAR
Aelementos:TAelementos;
a:integer;
(***************************************************************************************************************************************************)
PROCEDURE leer;

VAR
I,elementos:integer;
acumulador:real;
BEGIN
I:=0;
writeln('Cuantos elementos va a introducir por teclado?');
REPEAT
read(elementos);
UNTIL (elementos>0) AND (elementos<=30);
FOR I:=1 TO elementos DO
BEGIN
write('Introduzca el elemento numero ',I:2,':');
read(Aelementos[I]);
acumulador:=acumulador+Aelementos[I];
END;
writeln('La suma de todos los elementos es:',acumulador:2:2);
END;
(**********************************************************************************************************************************************************)
BEGIN
leer;
read(a);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio1(Arrays)

2011-11-23T18:41:00.001+01:00

Plantee e implemente un programa en PASCAL que solicite números enteros por teclado y vaya almacenándolos en un array de 10 elementos, mostrando a continuación por pantalla el contenido del array creado.

PROGRAM enteros(input,output);
(*Programa que contenga un array que solicite enteros por teclado y los vaya almacenando en un array de 10 elementos y que a continuacion muestre los elementos por teclado*)
CONST
elementos =10;

TYPE
TAelementos = ARRAY [1..elementos] OF integer;
VAR
Aelementos:TAelementos;
a:integer;
(********************************************************)
PROCEDURE leer;
VAR
I:integer;
BEGIN
I:=0;
FOR I:=1 TO 10 DO
BEGIN
write('Escriba el elemento numero ',I,':');
read(a);
Aelementos[I]:=a;
END;
END;
(*********************************************************)
PROCEDURE escribir;
VAR
I:integer;
BEGIN
I:=0;
FOR I:=1 TO 10 DO
writeln('El numero introducido en la seccion ',I,' es ',Aelementos[I]);
END;
(***********************************************************)
BEGIN
leer;
writeln;
escribir;
read(a);

END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 25 (procedimientos y funciones)

2011-11-21T19:54:00.001+01:00

Plantee e implemente un subprograma en PASCAL que indique si un número entero es o no un número primo. Además del subprograma, implemente un programa principal apropiado para probar su funcionamiento.

PROGRAM numeros_primos(input,output);
(*Programa que incluya un subprograma que diga si un numero es primo o no*)
VAR
numero:integer;
(**********************************************************************************)
PROCEDURE primo;
BEGIN
write('Escriba un numero entero y positivo: ');
REPEAT
read(numero);
IF ((numero=2) OR (numero=3)) THEN writeln('El numero ',numero,' es primo.') ELSE
IF ((numero MOD numero=0) AND (numero MOD 1=0) AND (numero MOD 2 <>0) AND (numero MOD 3 <>0)) THEN writeln('El numero ',numero,' es primo.') ELSE writeln('El numero ',numero,' no es primo.');
UNTIL numero>0;

END;
(***********************************************************************************)
BEGIN
primo;
read(numero);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 0(Arrays)

2011-11-21T19:17:00.001+01:00

Plantee e implemente un programa en PASCAL para calcular la media de cuatro puntuaciones de un estudiante de un curso de informática (representadas por 4
enteros entre 0 y 100) introducidas por teclado. Debe incluir obligatoriamente los siguientes elementos:
- Función pedirNota: solicita un entero por teclado entre 0 y 100, si no es correcto lo sigue pidiendo hasta que lo sea.
- Función calculoPuntuacion: recibe un real y devuelve la letra de la nota media en función a la siguiente tabla.
Media Puntuación
[90, 100]
A
[80, 90]
B
[70, 80]
C
[60, 70]
D
[0, 60]
E
- Programa principal apropiado que solicita al usuario cuatro notas (usando pedirNota) y calcula la media aritmética de las mismas, llamando además a calculoPuntuacion para obtener la letra de la puntuación que luego se debe mostrar en pantalla.

PROGRAM notas(input,output);
(*Programa que pida 4 notas comprendidas entre 0 y 100 y debe de realizar la media de dichas notas*)

TYPE
TAnotas = ARRAY[1..4]OF integer;
VAR
Anotas:TAnotas;
total,a:integer;
media:real;
b:char;
(****************************************************************************************************)
PROCEDURE pedirNota;
VAR
I:integer;
BEGIN
FOR I:=1 TO 4 DO
BEGIN
REPEAT
write('Escriba la nota ',I:1,':');
read(Anotas[I]);
IF (Anotas[I]>=1)AND(Anotas[I]<=100) THEN total:=Anotas[I]+total;
UNTIL (Anotas[I]>=1)AND(Anotas[I]<=100)
END;
media:=total/4;
END;
(*****************************************************************************************************)
FUNCTION calculoPuntuacion(media:real):char;
VAR
a:char;
BEGIN
IF (media<=100)AND(media >=90) THEN a:='A' ELSE IF (media<90)AND(media >=80) THEN a:='B' ELSE IF (media<80)AND(media >=70) THEN a:='C' ELSE IF (media<70)AND(media >=60) THEN a:='D' ELSE IF (media<60)AND(media >=0) THEN a:='E';
calculoPuntuacion:=a;
END;
(*************************************************************************************************************)
BEGIN
pedirNota;
b:=calculoPuntuacion(media);
writeln('Ha alcanzado una media de ',media:2:2,' por lo tanto su calificacion sera de ',b);
read(a);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 5(arrays)

2011-11-20T15:01:00.001+01:00

Plantee e implemente un programa en PASCAL para almacenar las temperaturas (en ºC) registradas en una ciudad durante un día hora a hora (0-23). Introduzca las temperaturas a partir de los datos proporcionados por el usuario, visualice ordenadamente las temperaturas registradas y calcule y muestre por pantalla la temperatura máxima, mínima y media alcanzadas.

PROGRAM temp(input,output);
(*Programa que pida una serie de temperaturas por teclado, y como salida las imprima por pantalla hora a hora, calcule maximo, minimo y la media*)

CONST
horas=24;
TYPE
TAtemperaturas = ARRAY[1..horas] OF real;
VAR
Atemperaturas:TAtemperaturas;
a,m,b,c:real;
(********************************************************************************************************************************************************)
PROCEDURE leer;
VAR
I:integer;
BEGIN
I:=1;
WHILE I<=horas DO
BEGIN
read(a);
Atemperaturas[I]:=a;
I:=I+1;
END;
END;

(********************************************************************************************************************************************************)
PROCEDURE escribir;
VAR
Y:integer;
BEGIN
FOR Y:=1 TO horas DO
IF Y=1 THEN writeln('La temperatura a la ',Y:3,' es de ',Atemperaturas[Y]:3:2,' grados.') ELSE writeln('La temperatura a las ',Y,' es de ',Atemperaturas[Y]:3:2,' grados.');
END;
(********************************************************************************************************************************************************)
FUNCTION media(Atemperaturas:TAtemperaturas):real;
VAR
acumulador:real;
M:integer;
BEGIN
M:=0;
FOR M:=1 TO horas DO
acumulador:= acumulador + Atemperaturas[M];
media:= acumulador /horas;
END;
(************************************************************************************************************************************************************)
FUNCTION maxima(Atemperaturas:TAtemperaturas):real;
VAR
maximo:real;
I:integer;
BEGIN
maximo:=0;
I:=0;
FOR I:=1 TO horas DO
IF Atemperaturas[I] > maximo THEN maximo:=Atemperaturas[I] ELSE maximo:=maximo;
maxima:=maximo;
END;
(************************************************************************************************************************************************************)
FUNCTION minima(Atemperaturas:TAtemperaturas):real;
VAR
minimo:real;
I:integer;
BEGIN
minimo:=0;
I:=0;
FOR I:=1 TO horas DO
IF Atemperaturas[I] < Atemperaturas[1] THEN minimo:=Atemperaturas[I] ELSE minimo:=minimo;
minima:=minimo;
END;
(*****************************************************************************************************************************************************************)
BEGIN
write('Introduzca 24 temperaturas separadas por espacios correspondientes a cada hora del dia:');
leer;
escribir;
m:=media(Atemperaturas);
writeln('La media de las temperaturas a lo largo del dia, es de ',m:2:2,' grados.');
b:=maxima(Atemperaturas);
writeln('La temperatura maxima alcanzada en el dia es de ',b:2:2,' grados');
c:=minima(Atemperaturas);
writeln('La temperatura minima alcanzada en el dia es de ',c:2:2,' grados');
END.

Ejemplo de ejecución

Siguiente

TE

2011-11-17T23:20:00.001+01:00

Practica 1 de tecnologia electronica ya disponible en T electronica practica 1 y teoria de Arrays disponible en pascal arrays

Practica 1

2011-11-17T19:12:00.000+01:00

Introduccion al diseno de circuitos con LTspice. Formas de onda. Carga y descarga del condensador. Circuitos RC integrador y diferenciador.
Formas de onda
1. Crear un nuevo esquematico con LTspice.
2. Anadir un componente gvoltageh con una resistencia de 1 ohmio en serie y el componente ggroundh.
3. Clic con el boton derecho en el componente gvoltage -> Advancedh y seleccionar gSineh. Consultar la documentacion para conocer el funcionamiento de los 7 parametros del componente gSineh.
4. Seleccionar adecuadamente los valores de los parametros para obtener una onda sinusoidal con los siguientes parametros:
a. 4 voltios pico a pico
b. -2 voltios de valor inferior (minimo)
c. 2 kHz de frecuencia
5. Iniciar una simulacion mediante el menu gSimulate -> Runh. La primera vez nos aparece el cuadro de dialogo gEdit Simulation Commandh. Este cuadro de dialogo se puede volver a visualizar si tenemos activa la ventana del esquematico (fichero con extension .asc) y vamos al menu gSimulate -> Edit Simulation Cmdh.
6. Seleccionar una simulacion de tipo gTransienth con gStop Time = 1 msh1 y gMaximum Timestep = 0.1 msh. Al pulsar OK aparece una ventana con fondo negro vacia.
7. Hacer clic en la conexion entre el generador y la resistencia para dibujar la onda sinusoidal correspondiente (tension).
8. Activar la rejilla (grid) en la grafica.
9. Copiar la onda y el esquematico resultantes (hacer uso de gTools -> Copy bitmap to Clipboardh y pegarla a continuacion. Este metodo sirve tanto para el esquematico como para las graficas.

10. Modificar el componente “voltage” (clic con el botón derecho en el componente situado en el esquemático) para reemplazar el componente “Sine” por “Pulse”.
11. Configurar adecuadamente para obtener una onda cuadrada con los mismos parámetros que la onda sinusoidal anterior pero con forma de onda cuadrada. ¡Atención! En los campos “Trise” y “Tfall” no utilizar el valor cero, sino un valor arbitrariamente pequeño (0.0000001) para que el tiempo de subida y de bajada sea muy próximo a cero.
12. Para redibujar la nueva forma de onda hay que ejecutar “Run” la simulación.
13. Copiar la forma de onda cuadrada a continuación.
14. Cerrar el esquemático y la ventana de gráficas.

Carga y descarga del condensador
1. Crear un nuevo esquemático que modele el circuito que se muestra a continuación cuando el interruptor S está en la posición 1. Utilizar C = 10 nF, R = 100 kΩ y V = 10 V.

2. Crear una nueva simulación con “Stop Time” = 7 ms, “Maximum Timestep” = 0.01 ms y marcar la opción “Start external DC supply voltages at 0V”.
3. Dibujar la diferencia de potencial en los extremos del condensador con respecto al tiempo así como la corriente que circula por el circuito (también con respecto al tiempo).
4. Copiar la gráfica resultante a continuación y reflexionar acerca de los resultados. En particular, comprobar que el condensador no permite el paso de la corriente entre sus terminales una vez que se ha completado el proceso de carga del mismo (ha pasado del régimen transitorio al régimen permanente).

De acuerdo a lo visto en las clases de teoría, ¿cuánto tiempo tarda en cargarse el condensador del circuito anterior? Indicar los cálculos a continuación.
5 x R x C = 5 x 100k x 10n = 5x10^-3 s = 5ms

Circuito RC integrador
Cree un nuevo esquemático en LTspice para simular el circuito RC integrador que se muestra en la siguiente figura. Tomar R = 100 kΩ, C = 10 nF y la señal de entrada es una onda cuadrada con los siguientes parámetros: 2 voltios pico a pico 1 voltio de offset de componente de continua 20 ms de período, de los que durante 10 ms la señal toma su valor máximo y durante los 10 ms restantes toma el valor mínimo.

Simular el circuito comenzando en t = 0 y terminando en t = 40τ, donde τ es la constante de tiempo del circuito (utilizar un valor adecuado para “Maximum Timestep”. Obtener las curvas de entrada y salida del circuito y pegarlas a continuación.

¿Cuál es la componente de continua de la señal de entrada? ¿Y de la señal de salida?
Entrada: VERDE
Salida: AZUL

Repetir la simulación anterior tras incrementar la frecuencia de la señal a f = 500 Hz

Repetir la simulación anterior tras incrementar la frecuencia de la señal a f = 5 kHz. Establecer el tiempo total de simulación en 5 ms.

Una vez alcanzado el régimen permanente, ¿cuál es la componente de continua, aproximadamente, de la señal de salida?
Una vez alcanzado el régimen permanente la componente de contínua de la señal de salida es de 1V.

Circuito RC diferenciador
Repetir los mismos pasos realizados para el caso del circuito integrador, pero ahora aplicados al circuito diferenciador (ver figura).

1. La frecuencia de la señal de entrada es f = 50 Hz.

2. La frecuencia de la señal de entrada es f = 500 Hz.

3. La frecuencia de la señal de entrada es f = 5 kHz.

Una vez alcanzado el régimen permanente, ¿cuál es la componente de continua, aproximadamente, de la señal de salida?
La componente de contínua se estabiliza en 0V.

GRACIAS a Janiro por este gran aporte

Tecnología Electrónica

2011-11-17T18:51:00.000+01:00

En esta sección del blog, dejaremos a un lado la programación, bases de datos etc y nos centraremos mas en los circuitos que componen los ordenadores empezando desde 0, para ello nos vamos a centrar en la aplicación LTspice con la que diseñaremos los circuítos en todas las prácticas.

Práctica 1

2011-11-17T18:26:00.000+01:00

Arrays de considera una colección de datos del mismo tipo yuxtapuestos en memoria y referenciados por un identificador.

Ejemplos

Tabla[3]:= 7 -----> Inserta el valor 7 en la fracción de tabla numero 3.

Writeln(‘tabla[3]’)

Para trabajar con arrays, hay que declarar el tipo del array y después hay que crear las variables y seleccionar el tipo establecido anteriormente como podemos ver en los siguiente ejemplos.

TYPE

TAnombres= ARRAY[1..60] OF Tcadena;

TAcursos= ARRAY[1..5] OF INTEGER;

TAprecios=ARRAY[tprecios] OF REAL;

VAR

Anombre : TAnombres;

Acursos: TAcursos;

Ejercicios con Arrays

Ejercicio 1

Ejercicio 4(Inicio A)

2011-11-15T22:07:00.000+01:00

PROGRAM salario(input,output);
(*Programa para calcular el salario neto de un empleado en funcion de las horas trabajadas, restando los impuestos de seguridad social y el IRPF*)
CONST
precioord=5.68;
precioext=8;
ss=6;
VAR

nombre:string(40);
hordinarias:integer;
totalordinarias:real;
hextraacumula:integer;
hextratotal:integer;
hextra:integer;
totalextra:integer;
nocturnidad:integer; (*Si pongo la variable tipo char no me la lee al pedir datos!!!*)
plus:real;
salariobruto:real;
seguridadsocial:real;
irpf:real;
redondeo:integer;
hijos:integer;
salarioneto:real;
n:integer;
a:integer;

BEGIN

write('Nombre:');
read(nombre);
write('Número de horas ordinarias en el mes en curso:');
read(hordinarias);
write('Número de horas extraordinarias en el mes en curso:');
read(hextra);
write('Nocturnidad SI [1] NO [0]:');
read(nocturnidad);
write('Número de hijos a su cargo menores de 18 años:');
read(hijos);
IF hextra>30 THEN writeln('Número de horas extraordinarias mayor al permitido. Avisar al gerente.') ELSE
BEGIN
CASE hordinarias OF
0..160 : BEGIN
totalordinarias:=hordinarias*precioord;
hextratotal:=hextra;
totalextra:=hextratotal*precioext;
END;
161..190 : BEGIN
totalordinarias:=160*precioord;
hextraacumula:=hordinarias-160;
hextratotal:=hextraacumula+hextra;
totalextra:=hextratotal*precioext;
END;
OTHERWISE writeln('Número de horas extraordinarias mayor al permitido. Avisar al gerente.');
END;
CASE nocturnidad OF
1 : plus:=((totalextra+totalordinarias)*10)/100;
0 : plus:=(totalextra+totalordinarias)*0;
END;
salariobruto:=(totalordinarias+totalextra);
seguridadsocial:=(salariobruto*ss)/100;
redondeo:=round(salariobruto);

CASE redondeo OF
0..1000 :
BEGIN
IF (hijos<=5) THEN n:=12-hijos ELSE n:=7;
irpf:=(salariobruto*n)/100;
END;
1001..1250 :
BEGIN
IF (hijos<=5) THEN n:=15-hijos ELSE n:=10;
irpf:=(salariobruto*n)/100;
END;
1251..maxint :
BEGIN
IF (hijos<=5) THEN n:=18-hijos ELSE n:=13;
irpf:=(salariobruto*n)/100;
END;
OTHERWISE write('Error');
END;
salarioneto:=salariobruto-seguridadsocial-irpf;
writeln('');
writeln('----------------------- ------------ -------------------- ----------');
writeln(' Importe Unidad Total');
writeln('----------------------- ------------ -------------------- ----------');
writeln('Horas ordinarias',hordinarias:21,'',precioord:22:2,'',totalordinarias:12:2,'');
writeln('Horas Extra',hextratotal:26,'',precioext:22,'',totalextra:12,'');

writeln('Plus Nocturnidad',plus:55:2,'');
writeln('');
writeln('Salario BRUTO',salariobruto:58:2,'');
writeln('Retención IRPF',n:22,'%',irpf:34:2,'');
writeln('Cuota SS ',ss:27,'%',seguridadsocial:34:2,'');
writeln('-----------------------------------------------------------------------');
writeln('-----------------------------------------------------------------------');
writeln('Salario NETO',salarioneto:59:2,'');
writeln('Sr/a',nombre:68,'');
END;
REPEAT
writeln('Pulse 1 para finalizar');
read(a);
UNTIL a=1;
END.

Ejemplo de ejecución

Anterior

Ejercicio 3(Inicio A)

2011-11-15T21:43:00.000+01:00

PROGRAM fuerza(input,output);
(*Programa para determinar en funcion de los midiclorianos, el nivel de habilidad para usar la fuerza.+20000 Darth Vader, 15000-20000 miembros del consejo, 10000-15000 caballeros jedi, 5000-10000 iniciados,-5000 habitantes normales.*)
VAR
midiclorianosml:real;
total:integer;
d:integer;
BEGIN
write('Introduzca el numero de midiclorianos por ml de sangre:');
read(midiclorianosml);
total:=round(midiclorianosml*1000);
CASE total OF
20000..maxint : writeln('Este habitante de la Galaxia puede llegar a Darth Vader(',total:5,' midiclorianos/l de sangre');
15000..19999 : writeln('Este habitante de la Galaxia puede llegar a Miembro del Consejo(',total:5,'midiclorianos/l de sangre');
10000..14999 : writeln('Este habitante de la Galaxia puede llegar a Caballero Jedi(',total:5,' midiclorianos/l de sangre');
5000..9999 : writeln('Este habitante de la Galaxia puede llegar a Iniciado(',total:5,' midiclorianos/l de sangre');
0..4999 : writeln('Este habitante de la Galaxia es un habitante normal(',total:5,' midiclorianos/l de sangre');
OTHERWISE writeln('El numero de midiclorianos es muy reducido, por favor repita la medicion!!!');
END;
REPEAT writeln('Escriba 0 para finalizar');
readln(d);
UNTIL d=0;
writeln('FIN');
END.

Ejemplo de Ejecución

Anterior Siguiente

Ejercicio 2(Inicio A)

2011-11-15T21:36:00.000+01:00

PROGRAM futbol(input,output);
(*Programa que muestre la situacion de un equipo de futbol en funcion de los puntos,+70 Champions,60-70 EuroCup,45-60 Permanencia, menos de 45 Descenso.*)
VAR
partidos_ganados:integer;
partidos_perdidos:integer;
puntos_totales:integer;
partidos_empatados:integer;
d:integer;
BEGIN

write('Introduzca el numero de partidos ganados:');
read(partidos_ganados);
write('Introduzca el numero de partidos perdidos:');
read(partidos_perdidos);
partidos_empatados:=38-(partidos_perdidos+partidos_ganados);
puntos_totales:=(3*partidos_ganados)+(partidos_empatados);
IF ((partidos_ganados+partidos_perdidos+partidos_empatados)<>38) THEN write('error')
ELSE

CASE puntos_totales OF
71..114 : writeln('El equipo ha obtenido ',puntos_totales:3,' puntos,con lo que es probable que se clasifique para la Champions League');
61..70 : writeln('El equipo ha obtenido ',puntos_totales:3,' puntos,con lo que es probable que se clasifique para la EuroCup');
45..60 : writeln('El equipo ha obtenido ',puntos_totales:3,' puntos,con lo que es probable que consiga la permanencia');
0..44 : writeln('El equipo ha obtenido ',puntos_totales:3,' puntos,con lo que es probable que pierda la categoria');
OTHERWISE writeln('Fallo al introducir los datos, por favor reinicie el programa y vuelva a introducir los datos');
END;
REPEAT writeln('Escriba 0 para finalizar');
readln(d);
UNTIL d=0;
writeln('FIN');

END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 1(Inicio A)

2011-11-15T21:31:00.000+01:00

PROGRAM triangulo(input,output);
(*Programa que pida los lados de un triángulo y saque por pantalla si el tríangulo es equilátero, isosceles o escaleno *)
VAR
a:real;
b:real;
c:real;
BEGIN
write('Escriba el lado 1:');
readln(a);
write('Escriba el lado 2:');
readln(b);
write('Escriba el lado 3:');
readln(c);
IF((a=b)AND(b=c)AND(a=c))THEN
write('El triángulo es equilatero(lado1=lado2=lado3= ',a:2:1,' cm)')
ELSE
IF(a=b)THEN
write('El triángulo es isosceles(lado1=lado2= ',a:2:1,' cm)')
ELSE
IF(a=c)THEN
write('El triángulo es isosceles(lado1=lado3= ',a:2:1,' cm)')
ELSE
IF(b=c)THEN
write('El triángulo es isosceles(lado2=lado3= ',b:2:1,' cm)')
ELSE
IF((a=0)OR(b=0)OR(c=0))THEN
write('No hay triángulo')
ELSE
write('El triángulo es escaleno');
read(c);
END.

Ejemplo de Ejecución

Siguiente

Ejercicio 5(Inicio)

2011-11-15T20:44:00.000+01:00

PROGRAM calculador_de_sueldo_mensual(input,output);

(*Programa que pida nombre,edad,número de hijos y sueldo anual,la salida tiene que indicar su sueldo mensual *)

VAR
nombre:string(15);
edad:integer;
numero_hijos:integer;
sueldoanual:real;
sueldofinal:real;

BEGIN
write('Nombre:');
readln(nombre);
write('Edad:');
readln(edad);
write('Número de hijos:');
readln(numero_hijos);
write('Sueldo anual:');
readln(sueldoanual);
sueldofinal:=sueldoanual/12;
write('Su sueldo mensual es de: ',sueldofinal:2:3,' Euros ');

END.

Anterior

Ejercicio 4(inicio)

2011-11-15T20:42:00.000+01:00

PROGRAM precio_de_pruducto(input,output);

(*Entrada,nombre de un producto,precio en euros, numero de unidades dinero entregado.
Salida,precio total de la compra con iva y sin iva y cambio que hay que entregar al cliente*)

VAR
nombre:string(15);
precio:real;
unidades:integer;
dinero:real;
coste:real;
lower:real;
cambio:real;
impues:real;

BEGIN
write('Nombre del producto:');
readln(nombre);
write('Precio:');
readln(precio);
write('Número de unidades:');
readln(unidades);
write('Dinero a entregar:');
readln(dinero);

coste:=precio*unidades;
impues:=coste * 0.18;
lower:=coste+impues;
cambio:=dinero-lower;

writeln('Producto Unidades Coste sin IVA Coste con IVA Entregado Cambio ');

writeln(' ',nombre,' ',unidades:2,' ',coste:3:3,' ',lower:3:3,' ',dinero:3:3,' ',cambio:3:2);
END.

Anterior Siguiente

Ejercicio 3(Inicio)

2011-11-15T20:39:00.000+01:00

PROGRAM calcular_edad_de_jubilacion(input,output);

(*Entrada nombre apellidos y edad de usuario
Objetivo sr/a.apellido,le faltan aun X años para jubilarse.
Edad de jubilacion 67 años*)
VAR
nombre:string(15);
primer_apellido:string(15);
segundo_apellido:string(15);
edad, X:integer;

BEGIN
write('Nombre:');
readln(nombre);
write('Primer apellido:');
readln(primer_apellido);
write('Segundo apellido:');
readln(segundo_apellido);
write('Edad:');
readln(edad);
X:=67-edad;

write('Sr/Sra. ',primer_apellido,' le faltan aún', X:2, ' años para jubilarse')

END.

Anterior Siguiente

Ejercicio 2(inicio)

2011-11-15T20:36:00.000+01:00

PROGRAM gastos(input,output);

(*Desarrolle un programa que pida nombre,edad y gastos de cañas,transporte durante una semana,saque esos datos por pantalla y haga la suma*)

VAR
nombre:string(15);
edad:integer;
gastos:real;
transporte:real;
total:real;

BEGIN
write('Nombre:');
readln(nombre);
write('Edad:');
readln(edad);
write('Gasto en cañas en una semana:');
readln(gastos);
write('Gasto en transporte en una semana:');
readln(transporte);
total:=gastos+transporte;
write('Sr/Sra. ',nombre,' de ',edad:2,' ha gastado ',gastos:3:2,' en cañas y ',transporte:3:2,' en trasporte, y el total de sus gastos es de: ',total:3:2,' Gracias por utilizar la aplicación. ');

END.

Anterior Siguiente

Ejercicio 1(Inicio)

2011-11-15T20:29:00.000+01:00

PROGRAM area_circulos(input,output);
(*Mostrar una tabla indicando radio,perimetro y area de tres círculos*)
CONST
pi=3.14;
VAR
radio1:real;
radio2:real;
radio3:real;
perimetro1:real;
perimetro2:real;
perimetro3:real;
area1:real;
area2:real;
area3:real;
BEGIN
write('Radio primer círculo');
readln(radio1);
write('Radio segundo círculo');
readln(radio2);
write('Radio tercer círculo');
readln(radio3);
perimetro1:=2*pi*radio1;
perimetro2:=2*pi*radio2;
perimetro3:=2*pi*radio3;
area1:=pi*radio1*radio1;
area2:=pi*radio2*radio2;
area3:=pi*radio3*radio3;
writeln('Radio Perímetro Área');
writeln('====== ========== ======');
writeln(' ',radio1:2:2,' ',perimetro1:2:2,' ',area1:2:2);
writeln(' ',radio2:2:2,' ',perimetro2:2:2,' ',area2:2:2);
writeln(' ',radio3:2:2,' ',perimetro3:2:2,' ',area3:2:2);
END.

Ejemplo de Ejecución

Siguiente

Iniciación en Pascal

2011-11-15T20:21:00.000+01:00

Para empezar a programar en cualquier lenguaje de programación, hay que aprender a programar lo más basico, y poco a poco, ir a más y a programar en más lenguajes de programación, por eso dejo aquí los ejercicios que yo aconsejaría para empezar a programar en Pascal.

Ejercicios de Entrada y Salida
  Ejercicio 1  Ejercicio 2  Ejercicio 3  Ejercicio 4  Ejercicio 5

Sentencias Condicionales
Sentencia IF

La estructura usual de la sentencia If, es la siguiente, aunque en varios ejerdicios tambien podremos ver sentencias IF anidadas.

Pseudocódigo    SI condición ENTONCES acción 1 SI NO acción 2a;

Código IF condición THEN acción ELSE acción 2;

IF anidados IF condición THEN acción ELSE IF .......;

Sentencia Case

La sentencia Case, elige una opción sobre una variable que sea de tipo : integer, char, boolean o subrange.

CASE edad OF
0..10 : write('Niño');
11..16 : write('Adolescente');
17..120 : write('Adulto');
OTHERWISE write('Error');
END;

Ejercicios de sentencias Condicionales

Ejercicio 1 Ejercicio2 Ejercicio3 Ejercicio 4

Bases de Datos

2011-11-14T21:50:00.000+01:00

1. Obtener todos los datos de todos los empleados.

SELECT * FROM emp;
empno | ename | job | mgr | hiredate | sal | comm | deptno
-------+--------+-----------+------+------------+---------+---------+--------
7698 | BLAKE | MANAGER | 7839 | 1981-05-01 | 2850.00 | | 30
7499 | ALLEN | SALESMAN | 7698 | 1981-02-20 | 1600.00 | 300.00 | 30
7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30
7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30
7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | 0.00 | 30
7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | | 30
7839 | KING | PRESIDENT | | 1981-11-17 | 5000.00 | | 10
7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | | 20
7902 | FORD | ANALYST | 7566 | 1981-12-03 | 3000.00 | | 20
7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | | 20
7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | | 10
7788 | SCOTT | ANALYST | 7566 | 1982-12-09 | 3000.00 | | 20
7876 | ADAMS | CLERK | 7788 | 1983-01-12 | 1100.00 | | 20
7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | | 10
(14 rows)

2. Obtener todos los datos de todos los departamentos.

SELECT * FROM dept;
deptno | dname | loc
--------+------------+----------
10 | ACCOUNTING | NEW YORK
20 | RESEARCH | DALLAS
30 | SALES | CHICAGO
40 | OPERATIONS | BOSTON

3. Obtener todos los datos de los administrativos (su trabajo es, en inglés, 'CLERK').

SELECT *FROM emp WHERE job='CLERK';
empno | ename | job | mgr | hiredate | sal | comm | deptno
-------+--------+-------+------+------------+---------+------+--------
7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | | 30
7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | | 20
7876 | ADAMS | CLERK | 7788 | 1983-01-12 | 1100.00 | | 20
7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | | 10
(4 rows)

4. Idem, pero ordenado por el nombre.

SELECT *FROM emp WHERE job='CLERK' ORDER BY ename;

-------+--------+-------+------+------------+---------+------+--------

7876 | ADAMS | CLERK | 7788 | 1983-01-12 | 1100.00 | | 20

7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | | 30

7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | | 10

7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | | 20

(4 rows)

5. Obten el mismo resultado de la pregunta anterior, pero modifcando la sentencia SQL.

SELECT empno, ename, job, mgr, hiredate, sal, deptno FROM emp WHERE job='CLERK' ORDER BY ename;
empno | ename | job | mgr | hiredate | sal | deptno
-------+--------+-------+------+------------+---------+--------
7876 | ADAMS | CLERK | 7788 | 1983-01-12 | 1100.00 | 20
7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | 30
7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | 10
7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | 20
(4 rows)

14. Obten los salarios y las comisiones de los empleados del departamento 30.

SELECT sal, comm FROM emp WHERE deptno=30;
sal | comm
---------+---------
2850.00 |
1600.00 | 300.00
1250.00 | 500.00
1250.00 | 1400.00
1500.00 | 0.00
950.00 |
(6 rows)

22. Halla los empleados que tienen una comisión superior a la mitad de su salario.

SELECT ename, comm FROM emp WHERE comm>0.5*SAL;

ename | comm
--------+---------
MARTIN | 1400.00
(1 row)

23. Halla los empleados que no tienen comisión, o que la tengan menor o igual que el 25 % de su
salario.

SELECT ename, comm FROM emp WHERE comm<=0.25*sal;
ename | comm
--------+--------
ALLEN | 300.00
TURNER | 0.00
(2 rows)

24. Obtén una lista de nombres de empleados y sus salarios, de forma que en la salida aparezca en
todas las filas \Nombre:" y \Salario:" antes del respectivo campo. Hazlo de forma que selecciones
exactamente tres expresiones.

SELECT 'Nombre: '||ename nombre,'Salario: '|| sal salario,'Salario total: '|| sal+comm salario_total FROM emp;

nombre | salario | salario_total

----------------+------------------+------------------------

Nombre: BLAKE | Salario: 2850.00 |

Nombre: ALLEN | Salario: 1600.00 | Salario total: 1900.00

Nombre: WARD | Salario: 1250.00 | Salario total: 1750.00

Nombre: MARTIN | Salario: 1250.00 | Salario total: 2650.00

Nombre: TURNER | Salario: 1500.00 | Salario total: 1500.00

Nombre: JAMES | Salario: 950.00 |

Nombre: KING | Salario: 5000.00 |

Nombre: JONES | Salario: 2975.00 |

Nombre: FORD | Salario: 3000.00 |

Nombre: SMITH | Salario: 800.00 |

Nombre: CLARK | Salario: 2450.00 |

Nombre: SCOTT | Salario: 3000.00 |

Nombre: ADAMS | Salario: 1100.00 |

Nombre: MILLER | Salario: 1300.00 |

(14 rows)

25. Hallar el código, salario y comisión de los empleados cuyo código sea mayor que 7500.

SELECT mgr, sal, comm FROM emp WHERE empno>7500;
mgr | sal | comm
------+---------+---------
7839 | 2850.00 |
7698 | 1250.00 | 500.00
7698 | 1250.00 | 1400.00
7698 | 1500.00 | 0.00
7698 | 950.00 |
| 5000.00 |
7839 | 2975.00 |
7566 | 3000.00 |
7839 | 2450.00 |
7566 | 3000.00 |
7788 | 1100.00 |
7782 | 1300.00 |
(12 rows)

26. Obtén todos los datos de los empleados que estén (considerando una ordenación ASCII por
nombre) a partir de la J, inclusive.

SELECT*FROM emp WHERE ename>'J' ORDER BY ename;

-------+--------+-----------+------+------------+---------+---------+--------

7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | | 30

7566 | JONES | MANAGER | 7839 | 1981-04-02 | 2975.00 | | 20

7839 | KING | PRESIDENT | | 1981-11-17 | 5000.00 | | 10

7654 | MARTIN | SALESMAN | 7698 | 1981-09-28 | 1250.00 | 1400.00 | 30

7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | | 10

7788 | SCOTT | ANALYST | 7566 | 1982-12-09 | 3000.00 | | 20

7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | | 20

7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | 0.00 | 30

7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30

27. Obtén el salario, comisión y salario total (salario+comisión) de los empleados con comisión,
ordenando el resultado por número de empleado.

SELECT sal, comm , sal+comm Salario_total FROM emp WHERE comm>0 ORDER BY empno;
sal | comm | salario_total
---------+---------+---------------
1600.00 | 300.00 | 1900.00
1250.00 | 500.00 | 1750.00
1250.00 | 1400.00 | 2650.00
(3 rows)

28. Lista la misma información, pero para los empleados que no tienen comisión.

SELECT sal, comm , sal+comm Salario_total FROM emp WHERE comm=0 ORDER BY empno;
sal | comm | salario_total
---------+------+---------------
1500.00 | 0.00 | 1500.00
(1 row)

29. Muestra el nombre de los empleados que, teniendo un salario superior a 1000, tengan como jefe
al empleado cuyo código es 7698.

SELECT ename FROM emp WHERE sal > 1000 and mgr = 7698;
ename
-------
ALLEN
WARD
MARTIN
TURNER
(4 rows)

30. Halla el conjunto complementario del resultado del ejercicio anterior.

SELECT ename FROM emp WHERE sal < 1000 and mgr <> 7698 OR mgr IS NULL;

ename

-------

BLAKE

JAMES

KING

JONES

FORD

SMITH

CLARK

SCOTT

ADAMS

MILLER

(10 rows)

32. Hallar los empleados del departamento 10 cuyo nombre no contiene la cadena LA.

SELECT ename FROM emp WHERE deptno=10 AND ename LIKE '%LA%';
ename
-------
CLARK
(1 row)

33. Obtén los empleados que no son supervisados por ningún otro.

SELECT ename FROM emp WHERE mgr is NULL;
ename
-------
KING
(1 row)

34. Obtén los nombres de los departamentos que no sean Ventas (SALES) ni investigación (RESEARCH).
Ordena el resultado por la localidad del departamento.

SELECT dname FROM dept WHERE dname<>'SALES'AND dname<>'RESEARCH' ORDER BY loc;
dname
------------
OPERATIONS
ACCOUNTING
(2 rows)

35. Deseamos conocer el nombre de los empleados y el código del departamento de los administra-
tivos(CLERK) que no trabajan en el departamento 10, y cuyo salario es superior a 800, ordenado
por fecha de contratación.

SELECT ename FROM emp WHERE job='CLERK' AND deptno<>10 AND sal>800;
ename
-------
JAMES
ADAMS
(2 rows)

36. Para los empleados que tengan comisión, obtén sus nombres y el cociente entre su salario y su
comisión (excepto cuando la comisión sea cero), ordenando el resultado por nombre.

SELECT ename, sal/comm cociente FROM emp WHERE comm > 0 ORDER BY ename;

ename | cociente

--------+------------------------

ALLEN | 5.3333333333333333

MARTIN | 0.89285714285714285714

WARD | 2.5000000000000000

(3 rows)

37. Lista toda la información sobre los empleados cuyo nombre completo tenga exactamente 5 car-
acteres.

SELECT *FROM emp WHERE ename LIKE'______'; (6 _)

38. Lo mismo, pero para los empleados cuyo nombre tenga al menos cinco letras.

SELECT*FROM emp WHERE ename>='_____'; (5_)

39. Halla los datos de los empleados que, o bien su nombre empieza por A y su salario es superior
a 1000, o bien reciben comisión y trabajan en el departamento 30.

SELECT ename FROM emp WHERE (ename like 'A%' anD sal>1000) OR (comm=0 AND deptno=30);

40. Halla el nombre, el salario y el sueldo total de todos los empleados, ordenando el resultado
primero por salario y luego por el sueldo total. En el caso de que no tenga comisión, el sueldo
total debe reflejar solo el salario.

SELECT ename, sal, sal+ comm Sueldo_total FROM emp ORDER BY sal , sal+comm;

41. Obtén el nombre, salario y la comisión de los empleados que perciben un salario que está entre
la mitad de la comisión y la propia comisión.

SELECT ename, sal, comm FROM emp WHERE sal BETWEEN comm/2 AND comm;

42. Obtén el complementario del anterior.

SELECT ename, sal, comm FROM emp WHERE sal NOT BETWEEN comm/2 AND comm;

43. Lista los nombres y empleos de aquellos empleados cuyo empleo acaba en MAN y cuyo nombre
empieza por A.

SELECT ename, job FROM emp WHERE job LIKE'%MAN' AND ename LIKE'A%';

44. Intenta resolver la pregunta anterior con un predicado simple, es decir, de forma que en la
cláusula WHERE no haya conectores lógicos como AND, OR, etc. Si ayuda a resolver la pregunta, se
puede suponer que el nombre del empleado tiene al menos cinco letras.

SELECT ename, job FROM emp WHERE ename||job LIKE 'A%MAN';

45. Halla los nombres de los empleados cuyo nombre tiene como máximo cinco caracteres.

SELECT ename FROM emp WHERE ename LIKE '_____';

46. Suponiendo que el año próximo la subida del sueldo total de cada empleado será del 6 %, y el
siguiente del 7 %, halla los nombres y el salario total actual, del año próximo y del siguiente, de
cada empleado. Indique además con SI o NO, si el empleado tiene comisión. Como en la pregunta
40, si no tiene comisión, el total se considera igual al salario. Se supone que no existen comisiones
negativas.

SELECT ename, sal, sal+ comm Salario_actual, sal+comm+(sal+comm)*0.6 Salario_proximo, sal+comm+(sal+comm)*0.7 Salario_dos_proximo, 'Si' Comision FROM emp WHERE comm>0 UNION SELECT ename, sal, sal+ comm Salario_actual, sal+comm+(sal+comm)*0.6 Salario_proximo, sal+comm+(sal+comm)*0.7 Salario_dos_proximo, 'No' Comision FROM emp WHERE comm IS NULL;

--------+---------+----------------+-----------------+---------------------+----------

SMITH | 800.00 | | | | No

SCOTT | 3000.00 | | | | No

JONES | 2975.00 | | | | No

FORD | 3000.00 | | | | No

CLARK | 2450.00 | | | | No

ALLEN | 1600.00 | 1900.00 | 3040.000 | 3230.000 | Si

MILLER | 1300.00 | | | | No

ADAMS | 1100.00 | | | | No

JAMES | 950.00 | | | | No

KING | 5000.00 | | | | No

WARD | 1250.00 | 1750.00 | 2800.000 | 2975.000 | Si

MARTIN | 1250.00 | 2650.00 | 4240.000 | 4505.000 | Si

BLAKE | 2850.00 | | | | No

(13 rows)

47. Lista los nombres y fecha de contratación de aquellos empleados que no son vendedores (SALESMAN).

SELECT ename, hiredate FROM emp WHERE job<>'SALESMAN';

48. Obtén la información disponible de los empleados cuyo número es uno de los siguientes: 7844,
7900, 7521, 7521, 7782, 7934, 7678 y 7369, pero que no sea uno de los siguientes: 7902, 7839, 7499
ni 7878. La sentencia no debe complicarse innecesariamente, y debe dar el resultado correcto
independientemente de lo empleados almacenados en la base de datos.

SELECT*FROM emp WHERE((empno=7844) OR (empno=7900) OR (empno=7521) OR (empno=7782) OR (empno=7934) OR (empno=7678) OR (empno=7369))AND((empno<>7902)OR(empno<>7839)OR(empno<>7499)OR(empno<> 7878));

-------+--------+----------+------+------------+---------+--------+--------

7521 | WARD | SALESMAN | 7698 | 1981-02-22 | 1250.00 | 500.00 | 30

7844 | TURNER | SALESMAN | 7698 | 1981-09-08 | 1500.00 | 0.00 | 30

7900 | JAMES | CLERK | 7698 | 1981-12-03 | 950.00 | | 30

7369 | SMITH | CLERK | 7902 | 1980-12-17 | 800.00 | | 20

7782 | CLARK | MANAGER | 7839 | 1981-06-09 | 2450.00 | | 10

7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 | | 10

(6 rows)

49. Ordena los empleados por su código de departamento, y luego de manera descendente por su
número de empleado.

SELECT ename, deptno, empno FROM emp ORDER BY deptno, empno desc;

50. Para los empleados que tengan como jefe a un empleado con código mayor que el suyo, obtén
los que reciben de salario más de 1000 y menos de 2000, o que están en el departamento 30.

SELECT ename, mgr, sal FROM emp WHERE mgr>empno AND ((sal<2000 AND sal>1000)OR(deptno=30));

ename | mgr | sal

--------+------+---------

BLAKE | 7839 | 2850.00

ALLEN | 7698 | 1600.00

WARD | 7698 | 1250.00

MARTIN | 7698 | 1250.00

(4 rows)

Script de creacion de base de datos

2011-11-14T21:36:00.001+01:00

CREATE TABLE dept (
deptno numeric(2,0) NOT NULL,
dname character varying(14),
loc character varying(13),
CONSTRAINT dept_pkey PRIMARY KEY (deptno)
);

CREATE TABLE emp (
empno numeric(4,0) NOT NULL,
ename character varying(10),
job character varying(9),
mgr numeric(4,0),
hiredate date,
sal numeric(7,2),
comm numeric(7,2),
deptno numeric(2,0),
CONSTRAINT emp_pkey PRIMARY KEY (empno),
CONSTRAINT emp_deptno_fkey FOREIGN KEY (deptno) REFERENCES dept(deptno),
CONSTRAINT emp_mgr_fkey FOREIGN KEY (mgr) REFERENCES emp(empno)
);

INSERT INTO dept (deptno, dname, loc) VALUES (10, 'ACCOUNTING', 'NEW YORK');
INSERT INTO dept (deptno, dname, loc) VALUES (20, 'RESEARCH', 'DALLAS');
INSERT INTO dept (deptno, dname, loc) VALUES (30, 'SALES', 'CHICAGO');
INSERT INTO dept (deptno, dname, loc) VALUES (40, 'OPERATIONS', 'BOSTON');

insert into emp values (7839, 'KING' , 'PRESIDENT', NULL, to_date('17/11/81','dd/mm/yy') , 5000, NULL, 10);
insert into emp values (7566, 'JONES' , 'MANAGER' , 7839, to_date('02/04/81','dd/mm/yy') , 2975, NULL, 20);
insert into emp values (7902, 'FORD' , 'ANALYST' , 7566, to_date('03/12/81','dd/mm/yy') , 3000, NULL, 20);
insert into emp values (7369, 'SMITH' , 'CLERK' , 7902, to_date('17/12/80','dd/mm/yy') , 800, NULL, 20);
insert into emp values (7698, 'BLAKE' , 'MANAGER' , 7839, to_date('01/05/81','dd/mm/yy') , 2850, NULL, 30);
insert into emp values (7499, 'ALLEN' , 'SALESMAN' , 7698, to_date('20/02/81','dd/mm/yy') , 1600, 300, 30);
insert into emp values (7521, 'WARD' , 'SALESMAN' , 7698, to_date('22/02/81','dd/mm/yy') , 1250, 500, 30);
insert into emp values (7654, 'MARTIN' , 'SALESMAN' , 7698, to_date('28/09/81','dd/mm/yy') , 1250, 1400, 30);
insert into emp values (7782, 'CLARK' , 'MANAGER' , 7839, to_date('09/06/81','dd/mm/yy') , 2450, NULL, 10);
insert into emp values (7788, 'SCOTT' , 'ANALYST' , 7566, to_date('09/12/82','dd/mm/yy') , 3000, NULL, 20);
insert into emp values (7844, 'TURNER' , 'SALESMAN' , 7698, to_date('08/09/81','dd/mm/yy') , 1500, 0, 30);
insert into emp values (7876, 'ADAMS' , 'CLERK' , 7788, to_date('12/01/83','dd/mm/yy') , 1100, NULL, 20);
insert into emp values (7900, 'JAMES' , 'CLERK' , 7698, to_date('03/12/81','dd/mm/yy') , 950, NULL, 30);
insert into emp values (7934, 'MILLER' , 'CLERK' , 7782, to_date('23/01/82','dd/mm/yy') , 1300, NULL, 10);

Ejercicio 7(Recursividad)

2011-11-12T14:49:00.000+01:00

Plantee e implemente una función recursiva en PASCAL para determinar el
término N de la sucesión de Fibonacci. Además de la función, implemente un
programa principal apropiado para probar su funcionamiento.

PROGRAM recursiva36(input,output);
(*Programa que contenga una funcion recursiva que determine el termino N de la sucecion de Fibonacci*)
VAR
termino,a:integer;
(****************************************************)
FUNCTION fib(termino:integer):integer;
BEGIN
IF termino<=2 THEN fib:=1 ELSE
fib:=fib(termino-1)+fib(termino-2);
END;
(*****************************************************)
BEGIN
write('Escriba el termino de la sucesion de fibonacci:');
read(termino);
a:=fib(termino);
writeln('El termino es:',a:2);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 2 (Recursividad)

2011-11-12T12:04:00.000+01:00

Plantee e implemente una función recursiva en PASCAL para calcular la N-
ésima potencia de un número entero. Además de la función, implemente un
programa principal apropiado para probar su funcionamiento.

PROGRAM enesi(input,output);
(*Progama que incluya una funcion recursiva que calcule la potencia n de un numero*)
VAR
n,numero,a:integer;
(************************************************************)
PROCEDURE datos;
BEGIN
write('Introduzca un numero:');
read(numero);
write('Introduzca el numero al que hay que elevarlo:');
read(n);
END;
(*************************************************************)
FUNCTION enesima(numero,n:integer):integer;
BEGIN
IF n=0 THEN enesima:=1 ELSE
enesima:=numero*enesima(numero,n-1);
END;
(*************************************************************)
BEGIN
datos;
a:=enesima(numero,n);
writeln(a);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 4(Recursividad)

2011-11-12T11:13:00.000+01:00

Plantee e implemente una función recursiva en PASCAL que calcule y muestre
la tabla de multiplicar de un número entero a partir de dicho número y el
máximo multiplicador. Además de la función, implemente un programa
principal apropiado para probar su funcionamiento

PROGRAM tablaR(input,output);
(*Prograa que haga la tabla de multiplicar de un numero entero pedido y hasta un maximo multiplicador pedido*)
VAR
numero,multiplicador:integer;
(******************************************)
PROCEDURE datos;
BEGIN
write('Introduzca un numero entero:');
read(numero);
write('Introduzca el maximo multiplicador:');
read(multiplicador);
END;
(*******************************************)
PROCEDURE TablaM(numero,multiplicador:integer);
BEGIN
IF multiplicador>1 THEN TablaM(numero,multiplicador-1);
writeln(numero:2,'*',multiplicador:2,'=',numero*multiplicador);
END;
(*******************************************)
BEGIN
datos;
TablaM(numero,multiplicador);
END.

Ejemplo de ejecución

Anterior Siguiente

Ejercicio 1(matlab)

2011-11-11T21:57:00.000+01:00

->f.m
%archivo que define a f(x)=(xÂ³+6*x)/(-2*xÂ²+5*x-3)
function y=f(x)
y=(x^3+6*x)/(-2*x^2+5*x-3);
end

->practica1.m

%Ejercicio de limites. CÃ¡lculo de asÃntotas y representaciÃ³n grÃ¡fica
syms x; pretty(f(x));
%pause
%
%fplot('f(x)', [-20,20, -30,5]) %Dibuja las asÃntotas verticales
%pause
%
%ezplot(f(x), [-20,20])
%pause
%
%
%Asintotas horizontales
L1 = limit(f(x),x,inf) %#ok<NOPTS> %existe asÃntota por la derecha si L1 es real
L2 = limit(f(x),x,-inf) %#ok<NOPTS> %asÃntota por la derecha si L2 es real
%disp('Apartado a): no existen asÃntotas horizontales')
%pause
%Asintotas verticales
[num,den] = numden(f(x))
%
%pause
%
raices_den = solve(den)
%pause
%
limit(f(x),raices_den(1))%el resultado significa que los limites laterales son distintos
%pause
%
L3_derch = limit(f(x),x,raices_den(1), 'right') %existe asÃntota vertical por la derecha en x=1 si L3_derch es infinito o -infinito
L3_izq = limit(f(x),x,raices_den(1), 'left') %existe asÃntota vertical por la izquierda en x=1 si L3_derch es infinito o -infinito
%pause
%
limit(f(x),x,raices_den(2)) %el resultado significa que los limites laterales son distintos
%pause
%
L4_derch = limit(f(x),x,raices_den(2), 'right') %existe asÃntota vertical por la derecha en x=3/2 si L4_derch es infinito o -infinito
L4_izq = limit(f(x),x,raices_den(2), 'left') %existe asÃntota vertical por la izquierda en x=3/2 si L4_derch es infinito o -infinito
%
%pause
%
AV1 = double(raices_den(1)) % convertimos las variables simbolicas en numericas
%
AV2 = double(raices_den(2)) %convertimos las variables simbolicas en numericas
%
disp('Apartado b): existen dos asÃntotas verticales de ecuaciones:')
disp(['x = ', num2str(AV1) ]), disp(['x = ', num2str(AV1) ])
%pause
%
%Representacion grafica de y=f(x) junto con sus asintotas verticales
ezplot(f(x), [-10,10])
hold on;
plot([1, 1], [-20, 100], 'g:')
plot([3/2, 3/2], [-20, 100], 'y:')
axis([-10, 10, -20, 100])
%pause
%Asintotas oblicuas(derecha)
m1 = limit(f(x)/x, x, inf) %existe asintota oblicua por la derecha si m1 es real
%El valor m1 es la pendiente de la asintota oblicua.
n1 = limit(f(x)-m1*x, x, inf) %n1 es la ordenada en el origen de la asintota obicua por la derecha.
disp('la asintota oblicua por la derecha es:')
y = m1*x+n1
%pause
v=[-10,10]; plot(v, m1*v+n1, 'r--')
%Asintotas oblicuas (izquierda)
m2 = limit(f(x)/x, x, -inf) %existe asintota oblicua por la izquierda si m1 es real
%El valor m2 es la pendiente de la asintota oblicua.
n2 = limit(f(x)-m2*x, x, -inf) %n1 es la ordenada en el origen de la asintota obicua por la izquierda.
disp('la asintota oblicua por la izquierda es:')
y = m2*x+n2
%pause
w=[-10,10]; plot(w, m2*v+n2, 'r--')