Bienvenidos a este nuevo capítulo de este Curso Gratis de Programación #12 Estructuras Algorítmicas: For (Para)

¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?

ESTRUCTURAS ALGORITMICAS

Las estructuras de operación de programas son un grupo de formas de trabajo, que permiten, mediante la manipulación de variables, realizar ciertos procesos específicos que nos lleven a la solución de problemas. Estas estructuras se clasifican de acuerdo con su complejidad en:

Estructuras Cíclicas

Se llaman problemas repetitivos o cíclicos a aquellos en cuya solución es necesario utilizar un mismo conjunto de acciones que se puedan ejecutar una cantidad especifica de veces. Esta cantidad puede ser fija (previamente determinada por el programador) o puede ser

variable (estar en función de algún dato dentro del programa).

Concepto de estructura de repetición 

Hasta ahora hemos trabajado, instrucciones de entrada, salida, expresiones y operadores, asignaciones, instrucciones secuenciales y de selección. Hay una gran variedad de situaciones que requieren que una o varias instrucciones se repitan varias veces, ya sean cálculos u otro tipo de instrucciones. Las instrucciones iterativas o de repetición, abren la posibilidad de realizar una secuencia de instrucciones más de una vez. En este capítulo estudiaremos las distintas formas que existen en pseudocódigo, para lograr la repetición de al menos una instrucción.

Concepto de bucle e iteración 

Un bucle, es una sección de código que se repite. Es decir, cuando se termina de ejecutar la última instrucción del conjunto, el flujo de control retorna a la primera sentencia y comienza una nueva repetición de las sentencias que forman esa sección de código. Se denomina iteración al hecho de repetir la ejecución de una secuencia de acciones, la iteración se asocia a un número entero que indica el número de veces que se repite un trozo de código. Por ejemplo, si se desea sumar notas de alumnos, se necesitan dos sentencias, una para leer desde el teclado la nota, y otra que realice sumas parciales, es decir:

…….

Suma ⭠ 0 // se inicializa una sola vez

// sentencias que se repiten Leer ( nota)
Suma ⭠ suma + nota

Es necesario conocer alguna manera de detener la repetición, ya sea que se conozca el número de notas a procesar, para este ejemplo, o por medio de una expresión o condición que se va modificando dentro del bloque de sentencias que forman el bucle. De lo contrario la iteración no acabaría nunca.

Entonces una Iteración es…

Entonces una Iteración es el hecho de repetir la ejecución de una secuencia de acciones. permiten ejecutar una secuencia de instrucciones. cuando se termina de ejecutar la última instrucción del conjunto, el flujo de control retorna a la primera sentencia y comienza una nueva repetición. 

Los bucles van a servir para poder repetir ciertas sentencias de código, bien un número determinado de veces, bien mientras se cumpla una condición. Los ordenadores son buenos haciendo tareas repetitivas: siguen exactamente las instrucciones dadas y lo hacen muy rápidamente.

Pero imagina que tuvieras que escribir las mismas instrucciones para cada repetición. Cuánto tiempo perderías, ¿no?. Además, cada nueva repetición aumentarías las posibilidades de cometer un fallo al escribir. Y lo que es peor, imagina que luego quieres cambiar algo del código que se repite, tendrías que hacerlo cada vez que lo has escrito. Imagina que tienes que controlar un robot y tiene que andar en línea recta una serie de pasos.

Ejemplos

Podrías crear un código como el siguiente:

Andar paso
Andar paso
Andar paso
Andar paso

Eso haría que el robot anduviera 4 pasos. ¿Y si tiene que andar 10 pasos, repites 10 veces la misma línea? No es necesario, porque para eso tenemos las estructuras repetitivas. Así, podríamos escribir:

Repite 10 veces
    Andar paso

Eso es genial, porque me evita tener que escribir un montón de código. Pero, ¿y si tiene que andar hasta llegar a una pared? No sabemos los pasos que tiene que andar. En ese caso existen estructuras repetitivas que permiten repetir tu código mientras una condición se cumpla.

Mientras no llegue a la pared
    Andar paso

También podríamos expresarlo de otra forma, en la que nos aseguramos que al menos se anda un paso.

Repetir
    Andar paso
Mientras no llegue a la pared

La diferencia entre el bucle ‘mientras’ y el bucle ‘repetir mientras’ es básicamente esa: en el ‘mientras’, si el robot está pegado a la pared no andaría, porque al comprobar si ha llegado a la pared vería que sí y se pararía. Sin embargo en el bucle ‘repetir mientras’ siempre andaría un paso, ya que comprueba si ha llegado a la pared al final.

La vida diaria está llena de ejemplos en los que podríamos aplicar estructuras repetitivas:

  • Repite ‘decir Hola’ hasta que alguien conteste (repetir-mientras)
  • Repetir por siempre ‘inspirar y expirar’ (condición que nunca es falsa)
  • Mientras haya ejercicios de programación ‘hacer siguiente ejercicio’ (mientras)
  • Haz 10 repeticiones de abdominales (repetir con contador)

Básicamente tenemos 2 tipos de bucles o estructuras repetitivas, que han quedado reflejadas en los ejemplos anteriores.

 Concepto de acumulador (Centinela) 

Un acumulador es un campo de memoria dinámica cuyo valor se incrementa sucesivas veces en cantidades variables. Se utiliza en aquellos casos en que se desee obtener un total de un conjunto de cantidades, siendo preciso inicializarlo a cero. También puede utilizarse en aquellas situaciones en las que hay que obtener un total como producto de distintas cantidades, en este caso hay que inicializar la variable a 1. En el ejemplo de las notas de los alumnos de un curso, si se desease calcular el promedio de notas en ese curso, la variable suma, representa un acumulador:

Suma ⭠ 0 // se inicializa una sola vez

//sentencias que se repiten Leer (nota)
Suma ⭠ suma + nota

 Tener presente que la variable acumulador suma, se inicializa a 0.

Ejemplos…

Si no sabemos cuántas filas tenemos que insertar en la tabla pero queremos parar cuando lleguemos al final de la página. En este caso es mejor usar un bucle con condición. Estas estructuras repiten el cuerpo del bucle mientras se cumpla la condición, a la que llamaremos centinela o condición centinela. Su estructura básica es la siguiente:

Mientras condición
    Cuerpo
Fin Mientras

De esta forma se repetirán las instrucciones del cuerpo mientras la condición sea cierta, por ejemplo: mientras no se alcance el final de la fila inserta filas en la tabla. Otro ejemplo:

Mientras haya celdas en blanco
    pintar celda “azul”
    pintar celda “rojo”
    pintar celda “verde”
Fin Mientras

En los bucles mientras el ordenador comprueba si la condición se satisface, en cuyo caso ejecuta las tareas del cuerpo. Esto continuará así hasta que no se satisfaga la condición, parando entonces la ejecución de esas tareas. Es por esto muy importante tener muy claro que en algún momento tienes que hacer que la condición no se cumpla; de lo contrario el bucle se repetirá sin fin.

La variante hacer-mientras o repetir-mientras lo que hace es pasar la condición al final, de forma que el cuerpo se va a ejecutar siempre al menos una vez.

Repetir
    pintar celda “azul”
    pintar celda “rojo”
    pintar celda “verde”
Mientras haya celdas en blanco

Concepto de contador 

Un contador es un campo de memoria dinámica cuyo valor se incrementa en una cantidad fija, positiva o negativa, y generalmente asociado a un bucle. En general un contador se utiliza:

  • Para contar el número de veces que es necesario repetir una acción (variable de control de un bucle)
  • Para contar un suceso en particular solicitado por los requerimientos del problema (asociado a un bucle o independientemente). 

Un contador toma un valor inicial (0, en la mayoría de los casos) antes de comenzar su función, y cada vez que se presenta el suceso a contar, se incrementa su valor (1 en la mayoría de los casos). Tanto el acumulador como el contador, son variables que realizan funciones específicas dentro de un programa.

Por un lado tenemos los bucles con contador, que repiten las instrucciones que contiene el cuerpo de la estructura un número determinado de veces. Su estructura básica es la siguiente:

Repetir n veces
    Cuerpo
Fin Repetir

Considera el cuerpo del bucle como el conjunto de instrucciones que quieres que se repitan.

También es posible que lo encuentres en el siguiente formato:

Para i desde 1 hasta 10 con paso 1
    Cuerpo
Fin Para

Cuando un ordenador recibe este tipo de estructuras establece un contador a 0 y ejecuta las instrucciones del cuerpo. Después de cada iteración, es decir, después de ejecutar el cuerpo del bucle, aumenta el contador. El proceso se repite hasta que el contador llegue a l número indicado, en cuyo caso termina. Por todo esto es bueno utilizar los bucles con contador cuando sabemos a priori el número de veces que queremos realizar una tarea: imprimir 3 copias de un documento, insertar 8 filas en una tabla, etc. Mira un ejemplo:

Repetir 10 veces
    pintar celda “azul”
    pintar celda “rojo”
    pintar celda “verde”
Fin Repetir

Estructuras para-cada

Existe otra forma más de dar instrucciones de repetición a un ordenador. Podríamos definir por ejemplo una secuencia de colores en una lista y decirle al ordenador que repita una serie de instrucciones para cada uno de los elementos de esa lista. Finalmente, hay una variante de este tipo de bucles que sirve cuando tenemos una lista con un número determinado de elementos y queremos hacer algo con cada uno de esos elementos, por ejemplo, «para cada producto de la lista de la compra suma su precio».

Para cada color en lista_de_colores
    pintar celda color
Fin Para

esta forma es más corta que las anteriores porque los colores con los que debemos pintar están ya en la lista. Se hace uso de la variable color que va cambiando a cada iteración del bucle, cogiendo de forma secuencial los valores de la lista.

Los bucles se usan mucho en programación porque ahorran tiempo, reducen errores y son más fáciles de leer. Es importante que te familiarices con cada uno de los tipos de bucles que se usan. Hacerlo hará de ti mejor programador:

  • Un bucle es una estructura cuyas instrucciones (cuerpo) se escriben una vez pero pueden repetirse.
  • Cada ejecución de esas instrucciones se denomina iteración.
  • Los bucles para (bucles controlados por contador) se repiten un número determinado de veces.
  • Las estructuras repetitivas mientras (bucles controlados por condición) se repiten hasta que su condición cambie.
  • Los bucles for-each (bucles controlados por colección) se repiten para cada elemento de la colección.

Instrucciones de repetición while, do y for

Este tipo de instrucciones son también llamadas bucles, instrucciones de ciclo o de repetición, y pueden anidarse al igual que las instrucciones if. De acuerdo con Deitel y Deitel (2012):

Java cuenta con tres instrucciones de repetición (también llamadas instrucciones de ciclo) que permiten a los programas ejecutar instrucciones de forma repetida, siempre y cuando una condición (llamada la condición de continuación del ciclo) siga siendo verdadera. Las instrucciones de repetición son while, do-while y for […]. Las instrucciones while y for realizan la acción (o grupo de acciones) en sus cuerpos, cero o más veces; si, en un principio, la condición de continuación del ciclo es falsa, no se ejecutará la acción (o grupo de acciones). La instrucción do-while realiza la acción (o grupo de acciones) en su cuerpo, una o más veces. Las palabras if, else, switch, while, do y for son palabras clave en Java. (p. 106).

  • En lo que respecta a la instrucción while, esta es una de las tres formas de aplicación de bucles o instrucciones de repetición, y es la única que permite hacer todo tipo de repeticiones, aun cuando existan otras dos formas. Su forma básica es:

while(expresión)
instrucción
siguiente instrucción.

Mientras que la expresión es true, se ejecuta instrucción, y luego se vuelve a evaluar expresión. Cuando el bucle termine, el bloque se devuelve a la siguiente instrucción.

  • La instrucción for se utiliza, principalmente, para iteraciones simples. Su sintaxis es:

for (inicialización; comprobación; actualización)
instrucción
siguiente instrucción.

  • La instrucción do es una estructura de bucle que garantiza que, al menos, se dará una ejecución y es la que se utiliza con menos frecuencia. Su sintaxis es:

do
instrucción
while(expresión)
siguiente instrucción.

FOR

En muchas ocasiones se conoce el número de veces que se desea que un bucle se repita. Se utiliza una variable como índice que se incrementa o decrementa en forma automática al finalizar cada ciclo. Para ejecutar el bucle, se evalúa una condición que debe ser verdadera. La condición más comúnmente usada es que el valor del índice sea menor o igual a un valor final. Si esto se cumple, entonces se ejecuta el bucle.  Al finalizar, se incrementa o decrementa el índice y se vuelve a evaluar la condición. Cuando la condición es falsa, se ignora el bucle y se continúa con el resto del algoritmo.

Ejemplos…

desde v <- Vi hasta Vf <inc/dec> hacer
sentencia 1
sentencia 2
sentencia n
fin-desde

La variable v es una variable entera que debe ser declarada. Los valores vi y vf son los valores inicial y final que tomará la variable v.  En el formato de esta estructura, hay que elegir entre incrementar o decrementar la variable de control v, ya que no pueden ocurrir al mismo tiempo ambas opciones.  Si el incremento es por el valor 1, entonces se puede obviar la sentencia inc 1 en la estructura. Se pueden utilizar indistintamente las palabras reservadas desde/fin-desde y para/fin-para.

desde v <- 1 hasta 5 hacer
<sentencias>
fin-desde

En este caso, la variable v se inicializa en 1 y, luego de ejecutar todas las sentencias que están comprendidas dentro de la estructura (bucle), automáticamente se incrementa en 1. Después de ejecutar varias iteraciones, cuando el valor de la variable v alcanza el valor 6, no se realizan más iteraciones y se prosigue con la próxima instrucción que está a continuación de la sentencia fin-desde. El siguiente ejemplo tiene el mismo efecto:

desde v <- 5 hasta 9 hacer
<sentencias>
fin-desde

La variable de control v se inicializa en 5, el bucle se repite 5 veces hasta que v es igual a 10. En este punto, la condición de que v sea menor o igual a 9 es falsa y, en consecuencia, se finaliza la estructura desde.

desde v <- 1 hasta 5 inc 2 hacer
<sentencias>
fin-desde

la variable v se inicializa con el valor 1 y con la ejecución de cada bucle se incrementa en 2 unidades. El bucle se repite 3 veces para los valores 1, 3 y 5 de la variable v, y finaliza cuando esta tiene un valor mayor a 5. También se puede aplicar la misma lógica de repetición, pero decrementando la variable índice, como en el siguiente ejemplo:

desde v <- 10 hasta 2 dec 2 hacer
<sentencias>
fin-desde

Diagramas

la variable v se inicializa con el valor 10 y con la ejecución de cada bucle se decrementa en 2 unidades. Cuando v es menor que 2, entonces se finaliza la estructura repetitiva. El bucle se repite 5 veces para los valores 10, 8, 6, 4 y 2 de la variable v, y finaliza cuando esta tiene un valor menor a 2.

Existen distintas alternativas para representar el diagrama de flujo de la estructura repetitiva desde. Algunos autores simplifican la representación de esta estructura utilizando algún símbolo propio

Ejercicio 1

Permita ingresar N números por teclado y que muestre por pantalla el mayor y menor de ellos.

algoritmo mayor_ menor _ numero_para 
var
	entero: N, num, mayor, menor, i 
inicio 
	mostrar("lngrese la cantidad de números con los que va trabajar") 
	leer(N) 
	mostrar("lngrese un número") 
	leer(num) 
	mayor <- num 
	menor <- num 
	para i <-2 hasta N hacer 
		mostrar("lngrese un número") 
		leer(num) 
		si mayor < num entonces 
			mayor <- num 
		fin-si 
		si menor > num entonces 
			menor <- num 
		fin-si 
	fin-para 
	mostrar("El mayor número ingresado es , mayor) 
	mostrar("El menor número ingresado es , menor) 
fin 

Ejercicio 2

Permita ingresar N números enteros por teclado y que muestre por pantalla los promedios de los números positivos y negativos.

algoritmo promedio_numeros_positivos_negativos 
var
	entero: N, cantidadpositivos, cantidadNegativos, sumaPositivos, 
sumaNegativos, i 
	real: num 
inicio 
	mostrar("lngrese Ia cantidad de números con 10s que va trabajar") 
	leer(N) 
	cantidadpositivos <-0
	cantidadNegativos  <-0
	sumaPositivos  <-0
	sumaNegativos  <-0 
	para i hasta N hacer 
		mostrar("lngrese un número") 
		leer(num) 
		si num > 0 entonces 
			cantidadpositivos <- cantidadpositivos + 1 
			sumaPositivos <- sumaPositivos + num 
		fin-si 
		si num < 0 entonces 
			cantidadNegativos <- cantidadNegativos + 1 
			sumaNegativos <- sumaNegativos + num 
		fin-si 
	fin-para 
	si cantidadpositivos > 0 entonces 
		mostrar("El promedio de 10s números positivos es ", 
		sumapositivos/cantidadpositivos) 
	sl-no 
		mostrar("No se han ingresado números positivos") 
	fin-si 
	si cantidadNegativos > 0 entonces 
		mostrar("El promedio de 10s números negativos es " 
		sumaNegativos/cantidadNegativos) 
	sl-no 
		mostrar("No se han ingresado números negativos") 
	fin-si 
fin

Ejercicio 3

Permita ingresar N calificaciones de alumnos y mostrar la cantidad de alumnos aprobados.

algoritmo calificaciones_alumnos 
var 
	entero: N, nota, cantidadAprobados, i 
inicio 
	leer(N) 
	cantidadAprobados <- 0 
	desde i <-  1 hasta N hacer 
		leer(nota) 
		si nota >= 5 entonces 
			cantidadAprobados <-  cantidadAprobados + 1 
		fin-si 
	fin-desde 
	mostrar(cantidadAprobados) 
fin 

EQUIVALENCIA ENTRE LAS ESTRUCTURAS REPETITIVAS

Dependiendo del problema para solucionar, es posible que alguna de las estructuras de repetición se adapte más fácilmente que otra, pero siempre es posible reemplazarla realizando algunas variaciones sencillas. si se deseara acumular en una variable la suma de los 10 primeros números enteros positivos que ingresa un usuario desde el teclado, podríamos tener los siguientes algoritmos:

Usando la estructura mientras:

suma <-0 
Contador <- 1 
mientras contador <-10 hacer 
	leer(dato) 
	suma <-suma + dato 
	contador <-contador + 1 
fin-mientras 

Usando la estructura repetir-hasta:

suma <-0 
Contador <- 1 
repetir 
	leer(dato) 
	Suma <- suma + dato 
	contador <- contador + 1 
hasta-que contador > 10

Usando la estructura desde/para:

suma <-0 
para contador 1 hasta 10 hacer 
	leer(dato) 
	Suma <- suma + dato 
fin -para 

Ejercicio 4

Se dispone de una lista de N números ingresados por teclado, se desea determinar y mostrar por pantalla el valor del número mayor que se haya ingresado. Una posible codificación podría ser:

Algoritmo DeterminaMayor Var
	entero: N, cant real: dato, mayor
 
inicio leer (N)
	leer ( dato) mayor ⭠ dato
	desde cant ⭠ 2 hasta N hacer leer ( dato)
	   si mayor < dato entonces 
                mayor ⭠ dato
	   fin-si
	fin-desde mostrar ( mayor)
fin

Ejercicio 5

Se dispone de una lista de N números ingresados por teclado, se desea determinar y mostrar por pantalla el valor del número mayor y del menor que se hayan ingresado al mismo tiempo.

Algoritmo DeterminaMayor_Menor Var
	entero: N, cant
	real: dato, mayor, menor
	inicio leer (N)
		leer ( dato) mayor ⭠ dato menor ⭠ dato
		desde cant ⭠ 2 hasta N hacer leer ( dato)
		   si mayor < dato entonces 
                      mayor ⭠ dato
		   fin-si
		   si menor > dato entonces 
                      menor ⭠ dato
		   fin-si 
		fin-desde
                mostrar ( mayor, menor) 
        fin

Ejercicio 6

Se leen desde el teclado 100 números, se desea determinar y mostrar por pantalla la media de los números positivos y la media de los números negativos que se hubiesen ingresado, al mismo tiempo.

 Algoritmo DeterminaMedia_Positivos_Negativos Var
	entero: cantP, cantN, total real: dato, sumaPos, sumaNeg
	inicio
		cantP ⭠ 0
		cantN ⭠ 0
		sumaPos ⭠ 0
		sumaNeg ⭠ 0
		desde total ⭠ 1 hasta 100 hacer 
                     leer ( dato)
		     si dato > 0 entonces 
                         cantP ⭠ cantP+1
		         sumaPos ⭠ sumaPos + dato 
                     fin-si
		     si  dato < 0 entonces
		        sumaNeg ⭠ sumaNeg + dato cantN ⭠ cantN + 1
		     fin-si 
                 fin-desde 
		mostrar ( „la media de los valores negativos es: „,sumaNeg/cantN) mostrar ( „la media de los valores positivos es:‟, sumaPos/cantN)
 
          fin

Ejercicio 7

leer las calificaciones de N alumnos de una clase de Informática. Y se desea contar la cantidad de alumnos aprobados (nota 5 o mayor a 5).

Una posible codificación puede ser:
 
	Algoritmo DeterminaNumero_Aprobados Var
		entero: N, cant, nota, cantApro
 
	inicio
		leer (N) // cantidad de alumnos cantApro ⭠ 0
		desde cant ⭠ 1 hasta N hacer leer ( nota)
		si nota > = 5 entonces cantAmayor ⭠ cantApro + 1
		fin-si
		fin-desde
		mostrar ( cantApro) 
fin

Ejercicio 8

Mostrar por pantalla solamente las letras mayúsculas ingresadas por teclado. Realizar 20 ingresos.

Una codificación puede ser:
 
	Algoritmo MuestraMayúsculas Var
		caracter: dato entero: cant
	inicio cant ⭠ 0 repetir
 
		leer ( dato)
		si (dato > = „A‟ y dato < = „Z‟) o (dato > = „a‟ y dato < = „z‟) entonces mostrar ( dato)
		fin-si
		cant ⭠ cant +1 
                hasta-que cant > = 20 
fin

Ejercicio 9

Realizar 50 ingresos de caracteres por teclado. Si el carácter ingresado, es una minúscula mostrarla por pantalla, si la letra es mayúscula convertirla a minúscula para luego mostrarla por pantalla. Una codificación puede ser:

	Algoritmo MuestraMinúsculas Var
		caracter: dato entero: cont
	inicio cont ⭠ 0 repetir
		leer ( dato)
		si (dato > = „a‟ y dato < = „z‟) entonces mostrar ( dato)
		fin-si
		si (dato > = „A‟ y dato < = „Z‟) entonces dato ⭠ dato + 32
		mostrar (dato) fin-si
		cont ⭠ cont +1
                hasta-que cant > = 50 
fin

EXPLICACION:

Los caracteres se almacenan en memoria mediante una codificación en 0 y 1. A cada carácter le corresponde un número entero que se representa en código ASCII. La tabla ASCII, contiene números enteros con los que se corresponden las letras minúsculas, las mayúsculas, los números (de 0 a 9), los signos de puntuación, etc.

Las letras mayúsculas les corresponden números enteros consecutivos, la letra A mayúscula le corresponde el número 65, la letra B el 66, la letra C el 67 y así hasta llegar a la letra Z mayúscula. A las letras minúsculas, también les corresponden números enteros consecutivos. La letra a minúscula le corresponde el número 97, la letra b el 98, la letra c el 99 y así hasta llegar a la letra z minúscula.

Para la misma letra, mayúscula y minúscula, existe una constante igual a 32. Es decir entre la A y la letra a minúscula existen 32 posiciones de la tabla. Lo mismo ocurre para la letra B y b. Cuando la letra se coloca entre comillas simple, se está haciendo referencia al número entero que representa su codificación en ASCII. Por lo tanto no es necesario recordar la constante 32, basta con saber la siguiente relación

…… Var
entero: cont
. ………

cont ⭠ „a‟ – „A‟ // cont contiene 32 cont ⭠ „t‟ – „T‟ // cont contiene 32 y así para cualquier letra mayúscula y minúscula. Entonces, cuando la estructura selectiva si/si-no detecta en la expresión que el carácter ingresado es una letra mayúscula, entonces a su valor entero ASCII le suma 32 para convertirla en la misma letra pero en su forma minúscula. Todos los caracteres que no sean minúsculas o mayúsculas ( se convierten) se cuentan como ingreso válido para alcanzar la cifra 50.

Ejercicio 10

Ingresos de caracteres por teclado y mostrarlos por pantalla. El programa termina, con la primer vocal ( sea mayúscula sea minúscula) que se ingrese. Una codificación puede ser:

	Algoritmo MuestraCaracter Var
		caracter: dato
		lógico: flag // bandera inicio
		flag ß verdadero
		mientras flag = verdadero hacer
 
		leer ( dato)
		según-sea dato hacer caso „a‟ : flag ß falso caso „A‟ : flag ß falso caso „e‟ : flag ß falso caso „E‟ : flag ß falso caso „i‟ : flag ß falso caso „I‟ : flag ß falso caso „o‟ : flag ß falso caso „O‟ : flag ß falso caso „u‟ : flag ß falso caso „U‟ : flag ß falso
		fin-segun
		si flag = verdadero entonces mostrar ( dato)
		fin-si
               fin-mientras 
fin

Ejercicio 11

Ingresar 3 números desde el teclado, los números representan dimensiones de los lados de un triángulo. El programa mostrará por pantalla un mensaje indicando si el triángulo es equilátero ( 3 lados iguales), isósceles ( dos lados iguales) o escaleno (3 lados distintos). El programa termina cuando se introduzca la palabra salir.

Algoritmo Clasifica_triangulos Var
		Real: lado1, lado2, lado3 Cadena: clave
 
		inicio
		clave ß XXX
		mientras no (clave = „salir‟) hacer
 
		leer ( lado1, lado2, lado3)
		si (lado1 =lado2) y (lado2 = lado3) entonces mostrar ( „equilátero‟)
		si-no
			si ( lado1 < > lado2) y ( lado2 < > lado3) entonces mostrar („ escaleno‟)
			si-no
			mostrar ( „isósceles‟) fin-si
		fin-si
		mostrar ( „para terminar introduzca la palabra salir en minúscula‟) leer( clave)
                fin-mientras 
fin

Ejercicio 12

Calcular el promedio de un alumno que tiene 7 calificaciones en la materia de Diseño

Estructurado de Algoritmos

Inicio
  Sum=0
  Leer Nom
  Hacer para c = 1 a 7
     Leer calif
     Sum = sum + calif
  Fin-para
  prom = sum /7
  Imprimir prom
Fin.

Ejercicio 13

Leer 10 números y obtener su cubo y su cuarta.

Inicio
  Hacer para n = 1 a 10
    Leer num
  cubo = num * num * num
  cuarta = cubo * num
  Imprimir cubo, cuarta
  Fin-para
Fin.

Ejercicio 14

Leer 10 números e imprimir solamente los números positivos

Inicio
  Hacer para n = 1 a 10
    Leer num
    Si num > 0 entonces
      Imprimir num
    fin-si
  Fin-para
Fin.

Ejercicio 15

Leer 20 números e imprimir cuantos son positivos, cuantos negativos y cuantos neutros.

Inicio
 cn = 0
 cp = 0
 cneg = 0
 Hacer para x = 1 a 20
  Leer num
  Si num = 0 entonces 
  cn = cn + 1
  si no
   Si num > 0 entonces
    cp = cp + 1
   si no
   cneg = cneg + 1
   Fin-si
  Fin-si
 Fin-para
 Imprimir cn, cp, cneg
Fin.

Ejercicio 16

Leer 15 números negativos y convertirlos a positivos e imprimir dichos números.

Inicio
  Hacer para x = 1 a 15
    Leer num
    pos = num * -1
    Imprimir num, pos
  Fin-para
Fin.

Ejercicio 17

Suponga que se tiene un conjunto de calificaciones de un grupo de 40 alumnos. Realizar un algoritmo para calcular la calificación media y la calificación mas baja de todo el grupo.

Inicio
  sum = 0
  baja = 9999
  Hacer para a = 1 a 40
    Leer calif
    sum = sum + calif
    Si calif < baja entonces
      baja = calif
    fin-si
  Fin-para
  media = sum / 2
  Imprimir media, baja
fin

Ejercicio 18

Calcular e imprimir la tabla de multiplicar de un numero cualquiera. Imprimir el multiplicando, el multiplicador y el producto.

Inicio
  Leer num
  Hacer para X = 1 a 10
    resul = num * x
    Imprimir num, “ * “, X, “ = “, resul
  Fin-para
fin.

Ejercicio 19

Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un día desde las 0:00:00 horas hasta las 23:59:59 horas

Inicio
  Hacer para h = 1 a 23
    Hacer para m = 1 a 59
     Hacer para s = 1 a 59
      Imprimir h, m, s
     Fin-para
   Fin-para
  Fin-para
fin.

Problemas Propuestos

1) Una persona debe realizar un muestreo con 50 personas para determinar el promedio de peso de los niños, jóvenes, adultos y viejos que existen en su zona habitacional. Se determinan las categorías con base en la sig, tabla:

CATEGORIA Niños Jóvenes AdultosEDAD 0 – 1213 – 29 30 – 59
Viejos60 en adelante 

2) Al cerrar un expendio de naranjas, 15 clientes que aun no han pagado recibirán un 15% de descuento si compran más de 10 kilos. Determinar cuánto pagara cada cliente y cuanto percibirá la tienda por esas compras.

3) En un centro de verificación de automóviles se desea saber el promedio de puntos contaminantes de los primeros 25 automóviles que lleguen. Asimismo se desea saber los puntos contaminantes del carro que menos contamino y del que más contamino.

4) Un entrenador le ha propuesto a un atleta recorrer una ruta de cinco kilómetros durante 10 días, para determinar si es apto para la prueba de 5 Kilómetros o debe buscar otra especialidad. Para considerarlo apto debe cumplir por lo menos una de las siguientes condiciones:

  • – Que en ninguna de las pruebas haga un tiempo mayor a 16 minutos.
  • – Que al menos en una de las pruebas realice un tiempo mayor a 16 minutos.
  • – Que su promedio de tiempos sea menor o igual a 15 minutos.

5) Un Zoólogo pretende determinar el porcentaje de animales que hay en las siguientes tres categorías de edades: de 0 a 1 año, de mas de 1 año y menos de 3 y de 3 o mas años. El zoológico todavía no esta seguro del animal que va a estudiar. Si se decide por elefantes solo tomara una muestra de 20 de ellos; si se decide por las jirafas, tomara 15 muestras, y si son chimpancés tomara 40.

No te detengas, sigue avanzando

Aquí tienes un propósito para este 2024 que debes considerar seriamente: si has querido mejorar tus habilidades en hacking, Ciberseguridad y programación ahora es definitivamente el momento de dar el siguiente paso. ¡Desarrolla tus habilidades aprovechando nuestros cursos a un precio increíble y avanza en tu carrera!

Python Practicando. Desde 0 hasta Desarrollador en Python

Aprende Python, donde iniciamos desde 0, sin conocimientos previos hasta desarrollar aplicaciones con mucha practica!

Calificación: 4,6 de 5 (20.833 calificaciones) 249.493 estudiantes Creado por Alvaro Chirou • 1.800.000+ Enrollments WorldwideWalter Coto || +450,000 Estudiantes Español.

Lo que aprenderás

  • Ejercitar la lógica de programación
  • Comprender cómo la vida cotidiana puede ser fácilitada o simulada con código
  • Aprender programación desde cero
  • Usar Visual Studio Code como Editor de Código
  • Conocer y aprender el lenguaje de programación Python
  • Ser un programador desde cero, sin conocimiento en otro lenguaje o con algo previo
  • Mejorar las habilidades de programación, mejorar procesos y fácilitar la comprensión de código
  • Preparar un entorno dónde programar en Python
  • Operaciones aritméticas y jerarquía de Python
  • Manejo de cadenas en Python
  • Digitar datos por teclado con Python
  • Mostrar Datos por Pantalla al usuario en Python
  • Operadores Relacionales de Python
  • Operadores Lógicos de Python
  • Condicionales en Python
  • Estructuras de Datos: Listas, Tuplas y Diccionarios
  • Iteraciones y bucles repetitivos de Python
  • Segmentar Código y hacerlo más eficaz con las Funciones en Python
  • Gestionar posibles errores que puedan dar tus programas
  • Programación Orientada a Objetos
  • HTML y CSS
  • Selenium Web Driver con Python
  • Ejercitar todo lo Aprendido con Ejercicios

Este curso incluye:

  • 25,5 horas de vídeo bajo demanda
  • 21 artículos
  • 148 recursos descargables
  • Acceso en dispositivos móviles y TV
  • Certificado de finalización

Python es Hoy uno de los lenguajes más utilizados por Excelencia.

Esto se debe por su simpleza al momento de Desarrollar aplicaciones.

Por su capacidad de procesamiento a altas velocidades con grandes volúmenes de información.

Es un increíble lenguaje con el cual si no sabes programar, podrás aprender.

Y si ya sabes desarrollar, te aconsejo aprenderlo ya que en el mercado cada vez se solicitan más desarrolladores en Python.

Aspirar al trabajo que desean, o mejorar sus ingresos con un aumento de salario.

Python se utiliza para muchisimas cosas como:

  • Machine Learning
  • Data Science
  • Inteligencia Artificial.
  • Y mucho más!

En este curso te acompañare en el proceso por el cual aprenderás las bases del lenguaje, para luego determinar qué camino quieres seguir.

Te invito que me acompañes a conocer este Gran Lenguaje!

Aprende con nuestros más de 100 cursos que tenemos disponibles para vos

¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?

Sobre los autores

Álvaro Chirou

Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 1.800.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma. Puedes serguirme en mis redes:

Laprovittera Carlos

Soy Laprovittera Carlos. Con más de 20 años de experiencia en IT brindo Educación y Consultoría en Seguridad de la Información para profesionales, bancos y empresas. Puedes saber más de mi y de mis servicios en mi sitio web: laprovittera.com y seguirme en mis redes:

¿Quieres iniciarte en hacking y ciberseguridad pero no sabes por dónde empezar? Inicia leyendo nuestra guia gratuita: https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/ que te lleva de 0 a 100. Desde los fundamentos más básicos, pasando por cursos, recursos y certificaciones hasta cómo obtener tu primer empleo.

SIGUE APRENDIENDO GRATIS CON NUESTRAS GUIAS

Cómo Iniciarse en Hacking y Ciberseguridad en 2024

Curso Gratis Linux – Capitulo 1 – Introducción a Linux

Curso Gratis de Redes – Capitulo 1 – Tipos de redes y servicios

Como iniciarse en TRY HACK ME – Complete Beginner #1

OSINT #1 Más de 200 Search Tools