Practica algoritmos

Práctica 3. ALGORITMOS.
2ª PARTE
2 Sesiones Semanas: 25 de oct. y 1 de nov. Entrega: semana 8 de noviembre

OBJETIVOS:
Revisar el concepto de algoritmo y entender la necesidad del diseño de algoritmos en el estudio y
resolución de programas
Aprender algunos de los métodos o herramientas más utilizadas en la representación de algoritmos
Comprender y diferenciar perfectamente los distintos tipos de instrucciones utilizados en el diseño
de algoritmos
Conocer y manejar con habilidad los distintos tipos de estructuras de control

No olvides que antes de pasar a la fase de diseño deberemos analizar
exhaustivamente el problema

Repasando la práctica anterior encontramos que son diversas las maneras de realizar el diseño de un
algoritmo. Por un lado tenemos representaciones gráficas como son los diagramas de flujo y los
diagramas de cajas, y por otro la representación similar al lenguaje natural, el pseudocódigo.

A continuación vamos a ver cuales son las formas o símbolos básicos para representar cada una de las
diversas estructuras.

3-1

3-2 Fundamentos de la Programación 1

ESTRUCTURA SECUENCIAL

DIAGRAMA DE CAJAS DIAGRAMA DE FLUJO PSEUDOCÓDIGO

1
Intrucción_1
2
Intrucción_2
. Instrucción_3
...
. Instrucción_n
n

PYTHON
Intrucción_1
Intrucción_2
Instrucción_3
...
Instrucción_n

ESTRUCTURA ALTERNATIVA SIMPLE


condición si (condición) entonces
V F
S1
falso verdadero fsi
condición
Sentencias Sentencias
de la parte de la parte o también:
si si no S1 S2
si (condición) entonces
S1
si_no
S2
fsi
PYTHON
if condición :
S1

o también:

if condición :
S1
else:
S2

Ingeniería Informática
Ingeniería Técnica en Informática de Gestión
Ingeniería Técnica en Informática de Sistemas

Algoritmos. 2ª Parte 3-3

ESTRUCTURA ALTERNATIVA MÚLTIPLE


condición caso (expresión) hacer
V
1 condición e1: acción S1
e2: acción S2
otros
2 3 n e3: acción S3
.
.
en: acción Sn
S1 S2 S3 … Sn Sx S1 S2 S3 … Sn
si_no
otra acción
fcaso

PYTHON

if condición :
S1
elif condición :
S2
elif condición :
S3
else :
Sn

ESTRUCTURA REPETITIVA O ITERATIVA
REPETICIÓN CON CONDICIÓN INICIAL 0 – n veces

condición
falso condición mientras (condición) hacer
sentencias
verdadero fmientras
cuerpo
sentencias

PYTHON
while condición :
sentencias

Departamento de Ciencia de la Computación e Inteligencia Artificial


REPETICIÓN CON CONDICIÓN FINAL 1 – n veces

sentencias
cuerpo
repetir
sentencias
falso
hasta (condición) frepetir;
verdadero condición

condición

PYTHON
No existe en Python tal cual. Pero se puede emular fácilmente con la estructura
while:

sentencia_extra
while condición :
sentencias

REPETICIÓN CON CONTADOR

DIAGRAMA DE DIAGRAMA DE FLUJO PSEUDOCÓDIGO
CAJAS

inicialización
contador

condición
falso para variable:=valor_inicial hasta valor_final
condición [incremento|decremento valor] hacer
cuerpo sentencias
verdadero fpara;

sentencias

increment
o contador

PYTHON
for variable in range(inicio, fin+1) :
sentencias



Ejercicio Resuelto 1. Describir las estructuras de un algoritmo cuyo diagrama de cajas es:

Solución:
...
mientras (condición1) hacer
sentencia1;
sentencia2;
mientras (condición2) hacer
sentencia3;
sentencia4;
fmientras;
si (condición3) entonces
repetir
sentencia5;
sentencia6;
sentencia7;
sentencia8;
hasta (condicion4) frepetir;
si_no sentencia9;
fsi
sentencia10;
fmientras;

Ejercicio Propuesto 1. Describir las estructuras de un algoritmo cuyo diagrama de cajas es:



La escritura o diseño de un algoritmo mediante el uso de pseudocódigo, exige la “identación” o
“sangría” del texto en el margen izquierdo de las diferentes líneas, lo que facilita el entendimiento y
comprensión del diseño realizado.

Texto

Margen izquierdo

Ejercicio Resuelto 2. Diseña un algoritmo que dada una cantidad en céntimos de euro, escriba la
cantidad mínima de monedas que correspondería. Teniendo en cuenta los siguientes tipos de
monedas:1 céntimo, 2céntimos, 5 céntimos, 10 céntimos, 20 céntimos, 50 céntimos, 100
céntimos y 200 céntimos.

Versión1 (ALC)
algoritmo: resuelto2-ver1
var mientras cantidad>=20 hacer
cantidad,m1cent,m2cent,m5cent,m10cent,m20cen cantidad:=cantidad-20;
t,m50cent,m100cent,m200cent :entero ; m20cent:=m20cent+1;
fvar fmientras ;
m1cent:=0; mientras cantidad>=10 hacer
m2cent:=0; cantidad:=cantidad-10;
m5cent:=0; m10cent:=m10cent+1;
m10cent:=0; fmientras ;
m20cent:=0; mientras cantidad>=5 hacer
m50cent:=0; cantidad:=cantidad-5;
m100cent:=0; m5cent:=m5cent+1;
m200cent:=0; fmientras ;
escribe('Cantidad de centimos: '); mientras cantidad>=2 hacer
leelin(cantidad); cantidad:=cantidad-2;
mientras cantidad>=200 hacer m2cent:=m2cent+1;
cantidad:=cantidad-200; fmientras;
m200cent:=m200cent+1; m1cent:=cantidad
fmientras ; escribelin(m200cent,' monedas de 2 euros.');
mientras cantidad>=100 hacer escribelin(m100cent,' monedas de 1 euro.');
cantidad:=cantidad-100; escribelin(m50cent,' monedas de 50 cnts.');
m100cent:=m100cent+1; escribelin(m20cent,' monedas de 20 cnts.');
fmientras ; escribelin(m10cent,' monedas de 10 cnts.');
mientras cantidad>=50 hacer escribelin(m5cent,' monedas de 5 cnts.');
cantidad:=cantidad-50; escribelin(m2cent,' monedas de 2 cnts.');
m50cent:=m50cent+1; escribelin(m1cent,' monedas de 1 cnt.');
fmientras ; falgoritmo.



Versión2 (ALC)
algoritmo: resuelto2-ver2 m10cent:=cantidad/10;
var cantidad:=cantidad resto 10;
cantidad,m1cent,m2cent,m5cent,m10cent, fsi;
m20cent,m50cent,m100cent,m200cen:entero; si cantidad>=5 entonces
fvar m5cent:=cantidad/5;
escribe('Cantidad de centimos: '); cantidad:=cantidad resto 5;
leelin(cantidad); fsi;
si cantidad>=200 entonces si cantidad>=2 entonces
m200cent:=cantidad/200; m2cent:=cantidad/2;
cantidad:=cantidad resto 200; cantidad:=cantidad resto 2;
fsi; fsi;
si cantidad>=100 entonces m1cent:=cantidad;
m100cent:=cantidad/100; escribelin(m200cent,' monedas de 2
cantidad:=cantidad resto 100; euros.');
fsi; escribelin(m100cent,' monedas de 1 euro.');
si cantidad>=50 entonces escribelin(m50cent,' monedas de 50 cnts.');
m50cent:=cantidad/50; escribelin(m20cent,' monedas de 20 cnts.');
cantidad:=cantidad resto 50; escribelin(m10cent,' monedas de 10 cnts.');
fsi; escribelin(m5cent,' monedas de 5 cnts.');
si cantidad>=20 entonces escribelin(m2cent,' monedas de 2 cnts.');
m20cent:=cantidad/20; escribelin(m1cent,' monedas de 1 cnt.');
cantidad:=cantidad resto 20; falgoritmo.
fsi;
si cantidad>=10 entonces

Versión1(Python) Versión2(Python)
m1cent=0
m2cent=0 m1cent=0
m5cent=0 m2cent=0
m10cent=0 m5cent=0
m20cent=0 m10cent=0
m50cent=0 m20cent=0
m100cent=0 m50cent=0
m200cent=0 m100cent=0
print('Cantidad de centimos: ') m200cent=0
cantidad=int(raw_input()) print 'Cantidad de centimos: '
while cantidad>=200 : cantidad=int(raw_input())
cantidad=cantidad-200 if cantidad>=200 :
m200cent=m200cent+1 m200cent=cantidad/200
while cantidad>=100 : cantidad=cantidad % 200
m1cent=cantidad cantidad=cantidad % 2
print m200cent,' monedas de 2 euros.' m1cent=cantidad
print m100cent,' monedas de 1 euro.' print m200cent,' monedas de 2 euros.'
print m50cent,' monedas de 50 cnts.' print m100cent,' monedas de 1 euro.'
print m20cent,' monedas de 20 cnts.' print m50cent,' monedas de 50 cnts.'
print m1cent,' monedas de 1 cnt.' print m2cent,' monedas de 2 cnts.'
print m1cent,' monedas de 1 cnt.'



Ejercicio Resuelto 3.Se desea realizar una estadística de los pesos de los alumnos de un colegio de
acuerdo a la siguiente tabla:
- Alumnos de menos de 40 kg.
- Alumnos entre 40 y 50 kg.
- Alumnos de más de 50 y menos de 60 kg.
- Alumnos de más o igual a 60 kg.
La entrada de los pesos de los alumnos se terminará cuando se introduzca el valor -99. Al final se
desea obtener cuántos alumnos hay en cada uno de los baremos.

Versión repetir (ALC)
algoritmo :resuelto3
var
menosde40,entre40y50,entre50y60,masde60:entero;
pesoalumno:real;
fvar
menosde40:=0;
entre40y50:=0;
entre50y60:=0;
masde60:=0;
repetir
escribe('Introduce el peso: ');
leelin(pesoalumno);
si pesoalumno<>-99 entonces
si pesoalumno<40 entonces
menosde40:=menosde40+1
sino
si pesoalumno>=40 y pesoalumno<=50 entonces
entre40y50:=entre40y50+1
si_no
si pesoalumno>50 y pesoalumno<60 entonces
sino masde60:=masde60+1
fsi
fsi
fsi
fsi
hasta pesoalumno=-99 frepetir
escribelin('La cantidad de alumnos con peso <40Kg es ',menosde40);
escribelin('La cantidad de alumnos con peso >=40 y <=50 es ',entre40y50);
escribelin('La cantidad de alumnos con peso >50 y <60 es ',entre50y60);
escribelin('La cantidad de alumnos con peso >=60 es ',masde60);
falgoritmo.

Versión mientras (ALC)
algoritmo: resuelto3
var
menosde40,entre40y50,entre50y60,masde60:entero;
pesoalumno:real;
fvar
menosde40:=0;
entre40y50:=0;
entre50y60:=0;
masde60:=0;
escribe('Introduce el peso: ')
leelin(pesoalumno)
mientras pesoalumno<>-99 hacer
si pesoalumno>0 entonces
si pesoalumno<40 entonces menosde40:=menosde40+1
sino
si pesoalumno>=40 y pesoalumno<=50 entonces
sino
si pesoalumno>50 y pesoalumno<60 entonces
sino masde60:=masde60+1
fsi
fsi
fsi
fsi
escribe('Introduce el peso: ')
leelin(pesoalumno)
fmientras
escribelin('La cantidad de alumnos con peso <40Kg es ',menosde40)
escribelin('La cantidad de alumnos con peso >=40 y <=50 es ',entre40y50)
escribelin('La cantidad de alumnos con peso >50 y <60 es ',entre50y60)
escribelin('La cantidad de alumnos con peso >=60 es ',masde60)
falgoritmo.
Versión mientras (PYTHON, no existe repetir)



menosde40=0
entre40y50=0
entre50y60=0
masde60=0
print('Introduce el peso: ')
pesoalumno=float(raw_input())
while pesoalumno!=-99 :
if pesoalumno>0 :
if pesoalumno<40 :
menosde40=menosde40+1
else:
if pesoalumno>=40 and pesoalumno<=50 :
entre40y50=entre40y50+1
else:
if pesoalumno>50 and pesoalumno<60 :
entre50y60=entre50y60+1
else :
masde60=masde60+1
print('Introduce el peso: ')
pesoalumno=float(raw_input())
print'La cantidad de alumnos con peso <40Kg es ',menosde40
print'La cantidad de alumnos con peso >=40 y <=50 es ',entre40y50
print'La cantidad de alumnos con peso >50 y <60 es ',entre50y60
print'La cantidad de alumnos con peso >=60 es ',masde60

Diseña un algoritmo que muestre los múltiplos de 3 comprendidos entre 1 y n,
Ejercicio Resuelto 4.
siendo n un número que se introducirá por teclado. El programa se repetirá hasta que el
número introducido sea 0.
print('Introduce un número (0 para finalizar): ')
n=int(raw_input())
print 'Los múltiplos de 3 entre 1 y ',n,' son'
while n<>0 :
for i in range (1,n+1) :
if (i % 3)==0 :
print i,' '
print('Introduce un número (0 para finalizar): ')
n=int(raw_input())

A partir del diagrama de cajas del ejercicio anterior (propuesto 1), realiza su
Ejercicio Propuesto 2.
diagrama de flujo correspondiente.

Diseña un algoritmo que recoja dos fechas de nacimiento e indique cuál
corresponde al individuo mayor.

Realizar un algoritmo que lea un conjunto de números hasta que se
introduzca el valor cero. El programa visualizará el número de números pares e impares
introducidos.

Supongamos que una empresa que fabrica repuestos ha detectado como
defectuosos los productos con numero de serie comprendidos entre (14681 y 15681), (70001 y
79999), (88888 y 111111). Realizar un programa que permita leer un número de serie y nos
diga si es o no defectuoso. El programa se ejecutará hasta que el número de serie introducido
sea 0.

Ejercicio Propuesto 6.Realizar un programa que calcule el producto de dos números usando sumas.
Hay que tener en cuenta que los números pueden ser positivos o negativos y que el primero ha
de ser entero y el segundo real.

Realizar un algoritmo que nos lea una hora con minutos y segundos y nos
escriba la hora de un segundo después. Es necesario validar los datos leídos.



Ejercicio Propuesto 8. Diseña un algoritmo que visualice en pantalla cada una de las siguientes
figuras.
* * *
** ** ***
*** *** *****
**** **** *******
***** ***** *********
****** ****** ***********

Las instrucciones repetitivas son aquellas que nos permiten variar o alterar la secuencia normal de
ejecución de un programa haciendo posible que un grupo de acciones se ejecute más de una vez de forma
consecutiva. Este tipo de instrucciones tamibién recibe el nombre de bucle o lazos.
En los bubles se suelen utilizar algunas variables para unas tareas específicas, llamándolas en esos
casos contadores, acumuladores o interruptores. Comentamos a continuación en que consiste cada
uno de ellos:

- Contadores:
Un contador no es más que una variable destinada a contener un valor que se irá
incrementando o decrementando en una cantidad fija y constante y que es almacenado en memoria
principal. Se suelen utilizar para el control de procesos repetitivos.
Todo contador debe tomar un valor inicial antes de ser utilizado.

- Acumuladores:
Un acumulador o totalizador es una variable destinada a contener o almacenar cantidades
variables provenientes de los resultados obtenidos en operaciones aritméticas previamente realizadas de
manera sucesiva, lo que nos permitirá obtener el total acumulado de dichas cantidades. Tienen las mismas
características que los contadores, a excepción de que su objetivo no es controlar procesos repetitivos.
Al igual que los contadores deberán ser inicialiados, pero hay que tener en cuenta en que
operación matemática van a ser utilizados.

- Interruptores (switches):
Los interruptores, también denominados conmutadores o indicadores, son variables que
pueden tomar dos únicos valores considerados como lógicos y opuestos entre sí a lo largo de todo el
programa (0 o 1, 1 o –1, Verdadero o Falso, on/off, etc.).
Su objetivo es recordar en un determinado lugar del programa una ocurrencia o suceso
acaecido o no con antelación, o hacer que dos acciones diferentes se ejecuten alternativamente en un
proceso repetitivo. También deben ser inicializados. No se debe abusar de su utilización cuando no sea
necesario.


Practica algoritmos

Más contenido relacionado

Similar a Practica algoritmos

Más de infobran

Practica algoritmos