TUTORIAL DE PROGRAMACIÓN
--
Buen intento...
Bueno, pues aquí estoy de vuelta. Tocan ahora las Estructuras Iterativas.
¿Que qué es lo que hacen? Pues se dedican a repetir un pedazo de código hasta que se cumple alguna condición que hayamos indicado. Una de las grandes ventajas que ofrece la programación es que no es necesario que realicemos la misma tarea una y otra vez. Podemos hacer las cosas una única vez y luego ponemos el programa a repetirlo tantas veces como queramos... Como vemos en la imagen, lo mismo da 8 que 80 :)
En Java tenemos las siguientes; FOR, WHILE y DO ... WHILE, pero vamos a no adelantar acontecimientos. Seguimos en Pseudocódigo, de modo que por el momento trabajaremos con:
- DESDE ... HASTA
- MIENTRAS
- REPETIR ... HASTA.
Analicemos cada orden por separado:
- DESDE ... HASTA
Ejemplo: 1) Implementa un algoritmo que muestre todos los múltiplos de 6 entre 6 y 150, ambos inclusive.
Inicio
A: entero, B: entero
B = 1
Desde A=6 hasta A<=150 Incremento 6
Imprimir (B + "*6 = " + A)
B = B+1
Fin-desde
Fin
Como se puede ver en el ejemplo la estructura de la orden es:
Desde VARIABLE=X Hasta VARIABLE=Y INCREMENTO=Z
...
Fin-Desde
Para usar esta orden hay que hacer lo siguiente. En primer lugar se elige una variable que se ira modificando según se vaya repitiendo la orden (cada repetición es un ciclo) y se le da un valor inicial.
Luego se indica con que valor ha de terminar el bucle (un valor de esa misma variable).
Y para terminar se establece cómo cambiará la variable con cada ciclo (+1, +20, -40 ...)
En el ejemplo de arriba vemos como para hallar los múltiplos de 6 hasta se inicia una de las variables, en este caso "A" con el valor 6 y se le hace mostrar (imprimir) su valor. Con cada vuelta se le suma 6 al valor inicial...
Vuelta 1 ------ A = 6+0 = 6 (Nota que la primera vez no se suma el incremento.)
Vuelta 2 ------ A = 6+6 = 12
Vuelta 3 ------ A = 6+6+6 = 18
Vuelta 4 ------ A = 6+6+6+6 = 24
... Y se sigue así hasta llegar a A=156 que es cuando se cumple la condición "Hasta" y se termina la repetición.
- MIENTRAS
Siguiendo con el mismo ejemplo1) Implementa un algoritmo que muestre todos los múltiplos de 6 entre 6 y 150, ambos inclusive.
Inicio
A: entero, B: entero
Imprimir (Este programa muestra todos los múltiplos de 6 entre 6 y 150, incluyendo ambos:)
A = 6
B = 1
Mientras (A<=150)
Imprimir (B + "*6 = " + A)
B = B+1
A = B*6
Fin-mientras
Fin
La estructura de la orden Mientras es esta:
Mientras (Condición)
...
Fin-Mientras
En este caso el código que pongamos se repetirá hasta que se cumpla la condición. Volviendo al ejemplo vemos que en este caso no tenemos un INCREMENTO por defecto dentro de la propia orden, pero lo podemos hacer nosotros mismos. Obserba como cada vez que se cumple un ciclo se vuelve a calcular el valor de A y a B se le suma 1.
Vuelta 1 ------ Se Imprime ( 1*6 = 6 ) Luego se calcula: B=2 A=12
Vuelta 2 ------ Se Imprime ( 2*6 = 12) Luego se calcula: B=3 A=18
Vuelta 3 ------ Se Imprime ( 3*6 = 18) Luego se calcula: B=4 A=24
Y así se sigue hasta alcanzar el A=156.
- REPETIR ... HASTA
Inicio
A: entero
A = 6
Repetir
Imprimir (B + "*6 = " + A)
B = B+1
A = B*6
Hasta (A>=150)
Fin-repetir
Fin
Es igual al MIENTRAS con la única diferencia de que esta orden se ejecutara al menos una vez, aunque no se cumpla la condición porque esta se evalúa al final y no al principio como en los otros dos casos.
Y estas son las estructuras iterativas. No difíciles de comprender; como dije al principio lo que hacen es repetir un trozo de código mientras no se cumple una condición.
Para utilizar estas ordenes solo debes tener cuidado de no caer en un bucle infinito; es decir, que se llegue al caso en que una orden no termine nunca porque jamás se cumplirá la condición:
Ejemplo de bucle infinito:
Para A=10 hasta A=20 Incremento -1
Podemos ver que con cada vuelta los resultados de A serán decrecientes (10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2 ...) y que nunca se llegará al valor A=20, por lo que este bucle seguirá eternamente.
EJEMPLOS DE ESTRUCTURAS ITERATIVAS EN PSEUDOCÓDIGO
-Cuando veas <- lo que quiero decir es = . Ese es el signo de asignación de un valor, ok?
-Imprimir es Mostrar por pantalla.
-Leer significa Pedir un dato al usuario.
______________________________________________
2) Implementa un algoritmo que muestre todos los múltiplos de n entre n y m·n, ambos inclusive, donde n y m son números introducidos por el usuario.
Inicio
N: real, M: real, Aux: real, B: entero
Imprimir ("Este programa muestra todos los múltiplos de n entre n y m·n, ambos inclusive.")
Imprimir ("Introduzca el valor de n (n es un número real):")
Leer N
Imprimir ("introduzca el valor de m (m es un número real):")
Leer M
B <- 1
Aux <- N
Desde N = N hasta M, Incremeto=N
Imprimir (B + (*) + Aux + " = " + N)
B <- B+1
Fin-desde
Fin
____________________________________________________________________
____________________________________________________________________
3) Implementa un algoritmo que muestre todos los números potencia de 2 entre 20 y 230, ambos inclusive
Inicio
A: entero, B: entero,
A <- 0
B <- 0
Mientras (A<=20)
A <- 2^B
B <- B+1
Fin-mientras
Si (A>230) entonces
Imprimir ("No hay numeros potencia de 2 entre 20 y 230. La primera potencia, entera y positiva, de 2 superior a 20 es: 2^" + B + " = " + A)
Si no
Imprimir ("Este programa muestra todas las potencias (enteras y positivas) de 2 entre 20 y 230, ambos inclusive.")
Mientras A<230
Imprimir ("2^" + B " = " + A)
B <- B+1
Fin-mientras
Fin
____________________________________________________________________
____________________________________________________________________
4) Queremos hacer un algoritmo que calcule el factorial de un número entero positivo. El factorial de n se denota con n!, pero no existe ningún operador que permita efectuar este cálculo directamente. Sabiendo que n! = 1 · 2 · 3 · . . . · (n − 1) · n y que 0! = 1, haz un algoritmo que pida el valor de n y muestre por pantalla el resultado de calcular n!.
Inicio
N: entero, Aux: entero, Result: entero
Imprimir ("Introduzca un número positivo entero para hallar su factorial:")
Leer N
Si (N<0) entonces
Imprimir ("El número no puede ser negativo.")
Si no
Result=1
Si (N=0)
Imprimir ("0! = " + Result)
Si no
Desde Aux=1 hasta N
Result <- Result*Aux
Fin-desde
Imprimir ( N + "! = " Result)
Fin-si
Fin-si
Fin
____________________________________________________________________
____________________________________________________________________
5) El número de combinaciones que podemos formar tomando m elementos de un conjunto con n elementos es: C(m,n) = n! / (n − m)!m! . Diseña un algoritmo que pida el valor de n y m y calcule Cm n . (Ten en cuenta que n ha de ser mayor o igual que m.) (Puedes comprobar la validez de tu programa introduciendo los valores n = 15 y m = 10: el resultado es 3003.)
Inicio
Enteros: N, M, ResultN, ResultM, ResultNM, Aux, Total
Imprimir ("Este programa calcula el numero de combinaciones posibles tomando m elementos de un conjuto n. C=(m,n)")7
Imprimir ("Introduzca n:")
Leer N
Imprimir ("Introduzca m:")
Leer M
Si M<N entonces
Imprimir ("El subconjunto no puede ser mayor que el conjunto")
Si no
#Calculamos n! y m!
ResultN <- 1
ResultM <- 1
ResultNM <- 1
Para Aux=1 hasta N
RestultN <- ResultN*Aux
Fin-para
Para Aux=1 hasta M
ResultM <- ResultM*Aux
Fin-para
Para Aux=1 hasta (N-M)
ResutlNM <- ResultNM*Aux
Fin-para
Total <- ResultN/(ResultNM*ResultM)
Imprimir ("C(m,n) = " + Total)
Fin
____________________________________________________________________
____________________________________________________________________
6)Diseña un algoritmo que solicite la lectura de un número entre 0 y 10 (ambos inclusive). Si el usuario teclea un número fuera del rango válido, el programa solicitará nuevamente la introducción del valor cuantas veces sea necesario.
Inicio
Real: N
Imprimir ("Introduzca un número entre 0 y 10:")
Leer N
Mientras (N<0 OR N>10)
Imprimir ("El numero no es valido. Introduzca un número entre 0 y 10:")
Fin-mientras
Fin
____________________________________________________________________
____________________________________________________________________
7)Diseña un algoritmo que solicite la lectura, letra a letra, de un texto que no contenga letras mayúsculas. Si el usuario teclea una letra mayúscula, el algoritmo solicitará nuevamente la introducción del texto cuantas veces sea preciso.
Inicio.
Alfanumerico: Letra, Aux
Imprimir (Introduzca texto. Si introduce una mayuscula deberá volver a empezar o terminar el programa.)
Repetir
Imprimir (Introduzca texto. SIN MAYUSCULAS:)
Leer Letra
Mientras (Letra <> A OR B OR C OR ... OR Y OR Z)
Imprimir (Introduzca texto. SIN MAYUSCULAS:)
Leer Letra
Fin-mientras
Imprimir (¡No puede introducir letras mayusculas! Si desea terminar el programa pulse S, pulse cualquier otra letra para volver a empezar)
Leer Aux
Hasta Aux = S
Fin
____________________________________________________________________
____________________________________________________________________
8) Haz un algoritmo que muestre todos los números pares comprendidos entre 0 y 200 (ambos inclusive).
Inicio
Entero: Num
Imprimir ("Estos son los números pares entre 0 y 200:")
Para NUM=0 hasta 200 Incremento 2
Imprimir (Num)
Fin-para
Fin
____________________________________________________________________
____________________________________________________________________
9)Haz un algoritmo que muestre, en orden inverso, todos los números pares comprendidos entre 0 y 200 (ambos inclusive).
Inicio
Entero: Num
Imprimir ("Estos son los números pares entre 0 y 200 en orden descendente:")
Para Num=200 hasta 0 Incremento -2
Imprimir (Num)
Fin-para
Fin
____________________________________________________________________
____________________________________________________________________
10) Escribe un programa que muestre los números pares que hay entre dos números que introduzca el usuario por teclado.
Inicio
Entero: Num1, Num2, Aux
Imprimir ("Este programa muestra los números pares que hay entre dos numeros enteros.")
Imprimir ("Introduzca el primer numero:")
Leer Num1
Imprimir ("Introduzca el 2º múmero:")
Leer num2
Imprimir ("Los números pares comprendidos entre" + Num1 + " y " + Num2 " son:")
Si Num1>Num2 entonces
Aux <- Num1
Num1 <- Num2
Num2 <- Aux
Fin-si
Si MOD(Num1/2)=0 entoces
Para Aux=Num1 hasta Num2 Incremento 2
Imprimir (Aux)
Fin-para
Si no
Num1 <- Num1+1
Para Aux=Num1 hasta Num2 Incremento 2
Imprimir (Aux)
Fin-para
Fin-si
Fin
____________________________________________________________________
____________________________________________________________________
11) Haz un algoritmo que pida el valor de dos enteros n y m y que muestre por pantalla el valor del sumatorio desde i=n hasta m de i.
Inicio
Entero: N, M, Result, Aux
Imprimir ("Este programa calcula el sumatorio desde i=n hasta m de i.")
Imprimir ("Introduzca n:")
Leer N
Imprimir ("Introduzca m:")
Leer M
Si N>M entonces
Aux <- N
N <- M
M <- Aux
Fin-si
Result <- 0
Para Aux=N hasta M
Result <- Result+Aux
Fin-para
Fin
____________________________________________________________________
____________________________________________________________________
12)Haz un algoritmo que pida el valor de dos enteros n y m y que muestre por pantalla el valor del sumatorio desde i=n hasta m de i2.
Inicio
Entero: N, M, Result, Aux
Imprimir ("Este programa calcula el sumatorio desde i=n hasta m de i.")
Imprimir ("Introduzca n:")
Leer N
Imprimir ("Introduzca m:")
Leer M
Si N>M entonces
Aux <- N
N <- M
M <- Aux
Fin-si
Result <- 0
Para Aux=N hasta M
Result <- Result+Aux²
Fin-para
Fin
____________________________________________________________________
____________________________________________________________________
13) Haz un algoritmo que pida el valor de dos enteros n y m y calcule el sumatorio de todos los números pares comprendidos entre ellos (incluyéndolos en el caso de que sean pares).
Inicio
Entero: N, M, Aux, Result
Imprimir (Este programa calcula el sumatorio de todos los numeros pares comprendidos entre N y M)
Imprimir (Introduzca el valor de N, numero entero:)
Leer N
Imprimir (Introduzca el valor de M, numero entero:)
Leer M
Si N>M entonces
Aux <- N
N <- M
M <- Aux
Fin-si
Result <- 0
Si MOD(N/2)=0 entonces
Para Aux=N hasta M Incremento 2
Result = Result+Aux
Si no
Para Aux=N+1 hasta M Incremento 2
Result = Result+Aux
Fin-si
Imprimir ("El sumatorio de los pares entre " + N + " y " + M + " es: " + Result)
Fin
____________________________________________________________________
____________________________________________________________________
14) Haz un algoritmo que calcule el máximo común divisor (mcd) de dos enteros positivos. El mcd es el número más grande que divide exactamente a ambos números.
Inicio
Entero: A, B, Aux
Imprimir ("Calcula el MCD de dos números".)
Imprimir ("Introduzca 1er Nº:")
Leer A
Imprimir ("Introduzca 2º Nº:")
Leer B
Imprimir ("El MCD de A y B es:")
Si A<B entonces
Aux <- A
A <- B
B <- Aux
Fin-si
Mientras Mod(A/B)<>0
Aux <- B
B <- MOD(A/B)
A <- Aux
Fin-Mientras
Imprimir (B)
Fin
____________________________________________________________________
____________________________________________________________________
15) Haz un algoritmo que calcule el máximo común divisor (mcd) de tres enteros positivos. El mcd de tres números es el número más grande que divide exactamente a los tres.
Inicio
Entero: Num1, Num2, Num3, Aux1, Aux2
Imprimir ("Este programa calcula el MCD de tres números".)
Imprimir ("Introduzca 1er Nº:")
Leer Num1
Imprimir ("Introduzca 2º Nº:")
Leer Num2
Imprimir ("Introduzca 3er Nº:")
Leer Num3
Imprimir ("El MCD de " + Num1 + ", " + Num2 + " y " + Num3 + "es:")
Aux2 <- 0
Mientras Aux2<=1
Si Num1<Num2 entonces
Aux1 <- Num1
Num1 <- Num2
Num2 <- Aux1
Fin-si
Mientras Num1 MOD Num2<>0
Aux1 <- Num2
Num2 <- Num1 MOD Num2
Num1 <- Aux1
Fin-Mientras
Num1 <- Num3
Aux2 <- Aux2+1
Fin-mientras
Imprimir (Num2)
Fin
____________________________________________________________________
____________________________________________________________________
16) Haz un algoritmo que vaya leyendo números y mostrándolos por pantalla hasta que el usuario introduzca un número negativo. En ese momento, el algoritmo mostrará un mensaje de despedida y finalizará su ejecución.
Inicio
Real: N
Mientras N>=0
Imprimir ("Introduzca un número:")
Leer N
Imprimir ("Nº: " + N)
Fin-mientras
Imprimir ("Aufwiedersehen!")
Fin
____________________________________________________________________
____________________________________________________________________
17) Haz un algoritmo que vaya leyendo números hasta que el usuario introduzca un número negativo. En ese momento, el algoritmo mostrará por pantalla el número mayor de cuantos ha visto.
Inicio
Real: N, Aux
Imprimir ("Este programa recoge numeros y devuelve el mayor cuando se introduce uno negativo.")
Imprimir ("Introduzca un número:")
Leer N
Aux <- N
Mientras N>=0
Imprimir ("Introduzca otro número:")
Leer N
Imprimir ("Nº: " + N)
Si Aux<N entonces
Aux <- N
Fin-si
Fin-mientras
Imprimir ("El mayor de los numeros introducidos fue: " + Aux)
Fin
__________
Bueno, y creo que con estos ejemplos ya es suficiente. Con esto se termina la parte de pseudocódigo de modo que en la próxima entrada empezaré a explicar la programación en Java utilizando ya el lenguaje en condiciones. Programaré y lo explicaré todo con la ayuda del IDE NetBeans.
En la próxima entrada: -Programando en JAVA: Primeros Pasos.
Saludos.
No hay comentarios:
Publicar un comentario