1) Escribe una funcin en pseudocdigo que devuelva el resultado de un nmero elevado a un

exponente dado.
Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Funcion potencia (base:numerica, exponente:numerica):numerica

Var resultado: numerica
Inicio
resultado<-base^exponente
devolver resultado
Fin-Funcion
Algoritmo principal
Var resultado, base, exponente: numerica
Inicio
Escribir "Introduce la base"
Leer base
Escribir "Introduce el exponente"
Leer exponente
resultado<-potencia(base, exponente)
escribir resultado
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12

SubProceso resultado <- potencia ( base, exponente )

resultado<-base^exponente
FinSubProceso
Proceso ejercicio_funciones_1
Escribir "Introduce la base"
Leer base
Escribir "Introduce el exponente"
Leer exponente
resultado<-potencia(base, exponente)
Escribir resultado
FinProceso

2) Escribe una funcin en pseudocdigo que devuelva el trmino N (siendo N un nmero entero positivo)
de la serie de Fibonacci, esta sigue la siguiente serie: 1, 1, 2, 3, 5, 8, 13, 21 y as sucesivamente. Date
cuenta, que para obtener un numero, suma los dos nmeros anteriores. Por ejemplo, si introducimos un
3, la funcin nos devuelve el 2.
Esconder
Papel:

1
2
3
4

Funcion Fibonacci (posicion: numerica):numerica

Var contador, num1, num2, suma
Inicio
num1<-0
num2<-1

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

suma<-1
contador<-1
Mientras (contador<posicion)
suma<-num1+num2
num1<-num2
num2<-suma
contador<-contador+1
FinMientras
devolver suma
Fin-Funcion
Algoritmo principal
Var posicion, resultado: numerica
Inicio
leer posicion
resultado<-Fibonacci(posicion)
escribir resultado
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

SubProceso suma<- fibonacci ( posicion )

num1<-0
num2<-1
suma<-1
contador<-1
Mientras (contador<posicion)
suma<-num1+num2
num1<-num2
num2<-suma
contador<-contador+1
FinMientras
FinSubProceso
Proceso ejercicio_funciones_2
Leer posicion
resultado<-fibonacci(posicion)
Escribir resultado
FinProceso

3) Escribe una funcin en pseudocdigo que devuelva el rea de un crculo dado su radio. Recuerda
que para calcular el area, la formula es * r2
Esconder
Papel:

1
2

Funcion area_circulo (radio: numerico):numerico

Var area: numerico
Inicio

3
4
5
6
7
8
9
10
11
12
13
14
15
16

PI<-3.14
area<-PI*(radio^2)
devolver area
Fin-Funcion
Algoritmo principal
Var radio, area: numerica
Inicio
escribir "Escribe el radio"
leer radio
area<-area_circulo(radio)
escribir area
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11

SubProceso area <- area_circulo ( radio )

PI<-3.14
area<-PI*(radio^2)
FinSubProceso
Proceso ejercicio_funciones_3
Escribir "Escribe el radio"
leer radio
area<-area_circulo(radio)
Escribir area
FinProceso

4) Escribe una funcin en pseudocdigo que devuelva el factorial de un nmero N (siendo N un nmero
entero positivo). Haz despus un algoritmo principal que pida por teclado dos nmeros y escriba en
pantalla los factoriales de cada nmero comprendido entre los dos anteriores. El factorial de 5 es el
resultado de 5*4*3*2*1
Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12

Funcion factorial (numero: numerica):numerica

Var contador, suma: numerica
Inicio
suma<-numero
Desde contador<-numero-1 hasta 1 In -1
suma<-suma*contador
FinDesde
Fin-Funcion
Algoritmo principal
Var numero, resultado: numerica
Inicio
escribir "Introduce un numero"
leer numero
resultado<-factorial(numero)

13
14
15
16
17

escribir resultado
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12
13

SubProceso suma <- factorial ( numero )

suma<-numero
Para contador<-numero-1 hasta 1 con paso -1
suma<-suma*contador
FinPara
FinSubProceso
Proceso ejercicio_funciones_5
escribir "Introduce un numero"
leer numero
resultado<-factorial(numero)
escribir resultado
FinProceso

5) Escribe una funcin en pseudocdigo que devuelva si un nmero dado es primo o no. Para que un
numero sea primo solo es divisible entre 1 y s mismo (por ejemplo, 13, 17, 19). Utilizando la funcin,
escribe un programa que escriba todos los nmeros primos entre 1 y un nmero ledo desde el teclado.
Piensa que debe devolver la funcin.
Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Funcion primo (cuenta_primos: numerica):booleano

Var contador_divisores, divisor: numerica
Inicio
contador_divisores<-0
Desde divisor<-trunc(cuenta_primos^0.5) hasta 1 In -1
si (cuenta_primos MOD divisor=0) Entonces
contador_divisores<-contador_divisores+1
finSi
FinDesde
Si (contador_divisores>2) Entonces
devolver false
sino
devolver true
FinSi
Fin-Funcion
Algoritmo principal
Var limite, cuenta_primos: numerica
Inicio
Escribir "Introduce el limite"
Leer limite
desde cuenta_primos<-1 hasta limite In 1
Si(primo(cuenta_primos)=true) entonces

20
21
22
23
24
25
26
27

escribir cuenta_primos
FinSi
Findesde
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

SubProceso resultado<- primo ( cuenta_primos )

contador_divisores<-0
para divisor<-trunc(cuenta_primos^0.5) hasta 1 con paso -1
si (cuenta_primos MOD divisor=0) Entonces
contador_divisores<-contador_divisores+1
finSi
Finpara
Si (contador_divisores>=2) Entonces
resultado<-Falso
sino
resultado<-Verdadero
FinSi
FinSubProceso
Proceso ejercicio_funciones_5
Escribir "Introduce el limite"
Leer limite
Para cuenta_primos<-1 hasta limite Con Paso 1
Si(primo(cuenta_primos)=Verdadero) entonces
escribir cuenta_primos
FinSi
FinPara
FinProceso

6) Escribe una funcin en pseudocdigo que dado un nmero decimal (en base 10), entre 0 y 15,
devuelva el valor equivalente en sistema de numeracin binario(en este caso, un numero binario de
4 dgitos). Os aconsejo que los dgitos binarios sean una cadena, para que se puedan concatenar entre
s. Por ejemplo, si introducimos un 7, nos devuelva 0111. Si se introduce un numero menos que 0 o
mayor que 16, no mostrara un mensaje de error.
Esconder
Papel:

1
2
3
4
5

Funcion DecABin (numero: numerica):cadena

Var contador: numerica
digito, resultado: cadena
Inicio
contador<-1
Mientras contador<5 Hacer

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

si numero mod 2= 0 Entonces

digito<-"0"
Sino
digito<-"1"
FinSi
numero<-trunc (numero/2)
resultado<-digito+resultado
contador<-contador+1
FinMientras
Fin-Funcion
Algoritmo principal
Var numero: numerica
resultado:cadena
Inicio
Escribir "Introduce un numero"
Leer numero
si (numero>=0 y numero<16) Entonces
resultado<-DecABin(numero)
escribir resultado
Sino
Escribir "Introduce un numero entre 0 y 15"
FinSi
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

SubProceso resultado <- DecAbin ( numero )

contador<-1
Mientras contador<5 Hacer
si numero mod 2= 0 Entonces
digito<-"0"
Sino
digito<-"1"
FinSi
numero<-trunc (numero/2)
resultado<-digito+resultado
contador<-contador+1
FinMientras
FinSubProceso
Proceso ejercicio_funciones_6
Escribir "Introduce un numero"
Leer numero
si (numero>=0 y numero<16) Entonces
resultado<-DecAbin(numero)
escribir resultado
Sino
Escribir "Introduce un numero entre 0 y 15"

19
20
21
22
23
24

FinSi
FinProceso

7) Escribe una funcin en pseudocdigo llamada ConversionMoneda () que permita convertir una
cantidad de dinero dada en dolares, libras o yenes a Euros. Estas son las equivalencias aproximadas:

1 libra=1,22 euros

1 dolar=0,75 euros

1 yen=0.009 euros

Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Funcion conversor (moneda: cadena, cantidad: numerica):numerica

Var total: numerica
Inicio
si (moneda="libra") Entonces
total<-cantidad*1.22
FinSi
si (moneda="dolar") Entonces
total<-cantidad*0.75
FinSi
si (moneda="yen") Entonces
total<-cantidad*0.009
FinSi
Fin-Funcion
Algoritmo principal
Var moneda: cadena
cantidad, total: numerica
Inicio
//NOTA: las 2 siguientes lineas van en una linea
Escribir "Introduce la moneda que quieras pasar a euros:
libra,dolar o yen"
Leer moneda
Escribir "Introduce una cantidad"
Leer cantidad
total<-conversor(moneda, cantidad)
Escribir total
Fin

PseInt:

1
2
3

SubProceso total <- conversor ( moneda, cantidad )

si (moneda="libra") Entonces
total<-cantidad*1.22

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

FinSi
si (moneda="dolar") Entonces
total<-cantidad*0.75
FinSi
si (moneda="yen") Entonces
total<-cantidad*0.009
FinSi
FinSubProceso
Proceso ejercicio_funciones_7
//NOTA: las siguientes 2 lineas van en una linea
Escribir "Introduce la moneda que quieras pasar a euros:
libra,dolar o yen"
Leer moneda
Escribir "Introduce una cantidad"
Leer cantidad
total<-conversor(moneda, cantidad)
Escribir total
FinProceso

8) Los empleados de una fabrica trabajan en dos turnos, Diurno y Nocturno. Se desea calcular el jornal
diario de acuerdo a con las siguientes reglas:

La tarifa de las horas diurnas es de 10

La tarifa de las horas nocturnas es de 13,5

En caso de ser festivo, la tarifa se incrementa en un 10% en caso de turno diurno y en un 15%
para el nocturno.

Escribe una funcin en pseudocdigo llamada jornal() que tome como parmetros el n de horas, el
turno y el tipo de da (Festivo, Laborable) y nos devuelva el sueldo a cobrar. Escribe tambin un
algoritmo principal que pida el nombre del trabajador, el da de la semana, turno y n de horas
trabajadas, nos escriba el sueldo a cobrar usando la funcin anterior.
Ten en cuenta, que en la funcin nos pide el tipo de da pero en el algoritmo le pedimos al da es decir,
que debemos saber si el dia que introduce el usuario es festivo o no.
Esconder
Papel:

1
2
3
4
5
6
7
8

Funcion jornal (n_horas:numerica, turno:cadena,

tipo_dia:cadena):numerica
Var sueldo:numerico
Inicio
si (turno="diurno" y tipo_dia="laborable") Entonces
sueldo<-n_horas*10
Sino
si (turno="diurno" y tipo_dia="festivo") Entonces
sueldo<-n_horas*(10*1.1)
FinSi

9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

FinSi
si (turno="nocturno" y tipo_dia="laborable") Entonces
sueldo<-n_horas*13.5
Sino
si (turno="nocturno" y tipo_dia="festivo") Entonces
sueldo<-n_horas*(13.5*1.1)
FinSi
FinSi
devolver sueldo
Fin-Funcion
Var trabajador, turno, dia, tipo_dia: cadena
n_horas, sueldo: numerico
Inicio
Escribir "Introduce el nombre del trabajador"
Leer trabajador
Escribir "Introduce el numero de horas"
Leer n_horas
Escribir "Introduce en turno: diurno o nocturno"
Leer turno
Escribir "Introduce el dia"
Leer dia
Segun dia Hacer
"lunes":
tipo_dia<-"laborable"
"martes":
tipo_dia<-"laborable"
"miercoles":
tipo_dia<-"laborable"
"jueves":
tipo_dia<-"laborable"
"viernes":
tipo_dia<-"laborable"
"sabado":
tipo_dia<-"festivo"
"domingo":
tipo_dia<-"festivo"
FinSegun
sueldo<-jornal(n_horas, turno, tipo_dia)
Escribir "El trabajador " trabajador " cobra " sueldo " euros"
Fin

PseInt:

SubProceso sueldo <- jornal ( n_horas, turno, tipo_dia )

si (turno="diurno" y tipo_dia="laborable") Entonces

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

sueldo<-n_horas*10
Sino
si (turno="diurno" y tipo_dia="festivo") Entonces
sueldo<-n_horas*(10*1.1)
FinSi
FinSi
si (turno="nocturno" y tipo_dia="laborable") Entonces
sueldo<-n_horas*13.5
Sino
si (turno="nocturno" y tipo_dia="festivo") Entonces
sueldo<-n_horas*(13.5*1.1)
FinSi
FinSi
FinSubProceso
Proceso ejercicio_8
Escribir "Introduce el nombre del trabajador"
Leer trabajador
Escribir "Introduce el numero de horas"
Leer n_horas
Escribir "Introduce en turno: diurno o nocturno"
Leer turno
Escribir "Introduce el dia"
Leer dia
Segun dia Hacer
"lunes":
tipo_dia<-"laborable"
"martes":
tipo_dia<-"laborable"
"miercoles":
tipo_dia<-"laborable"
"jueves":
tipo_dia<-"laborable"
"viernes":
tipo_dia<-"laborable"
"sabado":
tipo_dia<-"festivo"
"domingo":
tipo_dia<-"festivo"
FinSegun
sueldo<-jornal(n_horas, turno, tipo_dia)
Escribir "El trabajador " trabajador " cobra " sueldo " euros"
FinProceso

9) Algoritmo que dado un nmero entero (este numero no podra ser menor o igual que 0), determine el
nmero de cifras que tiene. Por ejemplo, si introduzco un 253, me devuelva un 3.
Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Funcion Cuenta_cifras ( numero ):numerica

Var numero_auxiliar, cifras: numerica
Inicio
numero_auxiliar<-numero
cifras<-0
Mientras (numero_auxiliar>0)
numero_auxiliar<-trunc(numero_auxiliar/10)
cifras<-cifras+1
FinMientras
FinSubProceso
Algoritmo principal
Var numero, numero_cifras: numerica
Inicio
Escribir "Escribe un numero"
Leer numero
si (numero<=0) Entonces
Escribir "Introduce un numero mayor que 0"
sino
numero_cifras<-Cuenta_cifras(numero)
Escribir "El numero " numero " tiene " numero_cifras "
cifras"
FinSi
Fin

PseInt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

SubProceso cifras <- Cuenta_cifras ( numero )

numero_auxiliar<-numero
cifras<-0
Mientras (numero_auxiliar>0) Hacer
numero_auxiliar<-trunc(numero_auxiliar/10)
cifras<-cifras+1
FinMientras
FinSubProceso
Proceso ejercicio_funciones_9
Escribir "Escribe un numero"
Leer numero
si (numero<=0) Entonces
Escribir "Introduce un numero mayor que 0"
sino
numero_cifras<-Cuenta_cifras(numero)
Escribir "El numero " numero " tiene " numero_cifras "
cifras"
FinSi

17
18
19

FinProceso

10) Escribe una funcin en pseudocdigo que dibuje una pirmide invertida en pantalla como la de la
figura. La altura se pasar como parmetro. Si se pasa una altura =0 o negativa, la funcin devolver
1; en caso contrario devolver 0 (xito).
Ejemplo para altura = 5

*********
*******
*****
***
*
Esconder
Papel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Funcion pir_inver(altura: numerica):numerica

Var numast, espacios, nespacios, i, j, cod: numerica
Inicio
numast<-3+2*(altura-2)
nespacios<-numast
espacios=""
si altura=0 Entonces
cod<- (-1)
Sino
Desde i<-numast hasta 1 In -2
numast<-i
Desde k<-0 hasta numast-nespacios In 1
espacios<-espacios+" "
FinDesde
Escribir Sin Saltar espacios
Desde j<-1 hasta numast In 1
Escribir Sin Saltar "*"
FinDesde
nespacios<-nespacios-2
Escribir ""
FinDesde
cod<-0
FinSi
Fin-Funcion
Algoritmo principal
Var altura, resultado: numerica
Inicio
Escribir "Introduce la altura de la pirmide invertida"
leer altura
resultado<-pir_inver(altura)
si resultado=-1 entonces
Escribir "ha introducido una altura 0"
Sino
Escribir ""

30
31
32
33
34
35
36
37
38

Escribir "introducion de datos correcta"

FinSi
Fin

PSeInt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

SubProceso cod<-pir_inver(altura)
numast<-3+2*(altura-2)
nespacios<-numast
espacios=""
si altura=0 Entonces
cod<- (-1)
Sino
Para i<-numast hasta 1 con paso -2
numast<-i
para k<-0 hasta numast-nespacios Con Paso 1
espacios<-espacios+" "
FinPara
Escribir Sin Saltar espacios
para j<-1 hasta numast con paso 1
Escribir Sin Saltar "*"
FinPara
nespacios<-nespacios-2
Escribir ""
FinPara
cod<-0
FinSi
FinSubProceso
Proceso ejercicio_10
Escribir "Introduce la altura de la pirmide invertida"
leer altura
resultado<-pir_inver(altura)
si resultado=-1 entonces
Escribir "ha introducido una altura 0"
Sino
Escribir ""
Escribir "introducion de datos correcta"
FinSi
FinProceso

Espero que os sea de ayuda.