11 - Estructura de programación repetitiva for (con tres argumentos)

En este concepto veremos que tiene otras dos secciones opcionales la estructura repetitiva for.

Representación gráfica:

Con esta estructura el for requiere una variable entera que cumple la función de un CONTADOR de vueltas. En la sección indicada como "inicialización contador", se suele colocar el nombre de la variable que hará de contador, asignándole a dicha variable un valor inicial. En la sección de "condición" se coloca la condición que deberá ser verdadera para que el ciclo continúe (en caso de un falso, el ciclo se detendrá). Y finalmente, en la sección de "incremento contador" se coloca una instrucción que permite modificar el valor de la variable que hace de contador (para permitir que alguna vez la condición sea falsa y finalice el for)

Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for toma el valor indicado en la sección de de "inicialización contador". Inmediatamente se verifica, en forma automática, si la condición es verdadera. En caso de serlo se ejecuta el bloque de operaciones del ciclo, y al finalizar el mismo se ejecuta la instrucción que se haya colocado en la tercer sección del for.
Seguidamente, se vuelve a controlar el valor de la condición, y así prosigue hasta que dicha condición entregue un falso.

Si conocemos la cantidad de veces que se repite el bloque es muy sencillo emplear un for, por ejemplo si queremos que se repita 50 veces el bloque de instrucciones puede hacerse así:

La variable del for puede tener cualquier nombre. En este ejemplo se la ha definido con el nombre f.
Analicemos el ejemplo:

- La variable f  toma inicialmente el valor 1.
- Se controla automáticamente el valor de la condición: como f vale 1 y esto es menor 
o igual que 50, la condición da verdadero.
- Como la condición fue verdadera, se ejecutan la/s operación/es.
- Al finalizar de ejecutarlas, se retorna a la instrucción f++ (el operador ++ incrementa en uno la variable f,
es lo mismo que escribir f = f + 1), por lo que la variable f se incrementa en uno. 
- Se vuelve a controlar (automáticamente) si f es menor o igual a 50. 
Como ahora su valor es 2, se ejecuta nuevamente el bloque de instrucciones e 
incrementa nuevamente la variable del for al terminar el mismo.
- El proceso se repetirá hasta que la variable f sea incrementada al valor 51. 
En este momento la condición será falsa, y el ciclo se detendrá.

La variable f PUEDE ser modificada dentro del bloque de operaciones del for, aunque esto podría causar problemas de lógica si el programador es inexperto.
La variable f puede ser inicializada en cualquier valor y finalizar en cualquier valor. Además, no es obligatorio que la instrucción de modificación sea un incremento del tipo contador (f++).
Cualquier instrucción que modifique el valor de la variable es válida. Si por ejemplo se escribe f=f+2 en lugar de f++, el valor de f será incrementado de a 2 en cada vuelta, y no de a 1. En este caso, esto significará que el ciclo no efectuará las 50 vueltas sino sólo 25.

Problema 1:

Realizar un programa que imprima en pantalla los números del 1 al 100.

Diagrama de flujo:

Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque, imprimimos el contenido de f, al finalizar el bloque repetitivo se incrementa la variable f en 1, como 2 no es superior a 100 se repite el bloque de instrucciones.
Cuando la variable del for llega a 101 sale de la estructura repetitiva y continúa la ejecución del algoritmo que se indica después del for.
La variable f (o como sea que se decida llamarla) debe estar definida como una variable más.

Programa: ejercicio042.go

package main

import "fmt"

func main() {
    for f := 1; f <= 100; f++ {
        fmt.Print(f,"-")
    }
}

Podemos definir por inferencia el contador del for f en el mismo momento que se carga el valor inicial (con eso el compilador identifica que queremos crear una variable de tipo int, los tres argumentos del for van separados por un punto y coma:

    for f := 1; f <= 100; f++ {
        fmt.Print(f,"-")
    }

La variable f solo se puede utilizar dentro del bloque repetitivo for.

Si queremos podemos definir la variable f previa al for y luego asignarle un valor:

    var f int
    for f = 1; f <= 100; f++ {
        fmt.Print(f,"-")
    }

Debe quedar claro que ahora dentro del for le asignamos un 1 con el operador =

Problema 2:

: Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre posteriormente la suma de los valores ingresados y su promedio.

Diagrama de flujo:

En este caso, a la variable del for (f) sólo se la requiere para que se repita el bloque de instrucciones 10 veces.

Programa: ejercicio043.go

package main

import "fmt"

func main() {
    var valor int
    suma := 0
    for f := 1; f <= 10; f++ {
        fmt.Print("INgrese valor:")
        fmt.Scan(&valor)
        suma = suma + valor
    }
    fmt.Println("La suma es:", suma)
    promedio := suma / 10
    fmt.Println("El promedio es:", promedio)
}

El problema requiere que se carguen 10 valores y se sumen los mismos.
El promedio se calcula fuera del for luego de haber cargado los 10 valores.

Problema 3:

Escribir un programa que lea 10 notas de alumnos y nos informe cuántos tienen notas mayores o iguales a 7 y cuántos menores.

Para resolver este problema se requieren tres contadores:

aprobados (Cuenta la cantidad de alumnos aprobados)
reprobados (Cuenta la cantidad de reprobados)
f (es el contador del for)

Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y verificar con una estructura condicional si el contenido de la variable nota es mayor o igual a 7 para incrementar el contador aprobados, en caso de que la condición retorne falso debemos incrementar la variable reprobados.

Diagrama de flujo:

Los contadores aprobados y reprobados deben imprimirse FUERA de la estructura repetitiva.
Es fundamental inicializar los contadores aprobados y reprobados en cero antes de entrar a la estructura for.

Programa: ejercicio044.go

package main

import "fmt"

func main() {
    var nota int
    aprobados := 0
    reprobados := 0
    for f := 1; f <= 10; f++ {
        fmt.Print("Ingrese nota:")
        fmt.Scan(&nota)
        if nota >= 7 {
            aprobados++
        } else {
            reprobados++
        }
    }
    fmt.Println("Cantidad de aprobados:", aprobados)
    fmt.Println("Cantidad de reprobados:", reprobados)
}

Tener en cuenta que el incremento de un contador en 1 se puede hacer de dos formas (operador matemático ++):

f++;
aprobados++;
reprobados++;

O por medio de una asignación:

f=f+1;
aprobados = aprobados + 1;
reprobados = reprobados + 1;

Cualquiera de las dos formas genera el mismo resultado de incrementar en uno la variable.

Problema 4:

Escribir un programa que pida cargar 10 números enteros y luego muestre cuántos valores ingresados fueron múltiplos de 3 y cuántos de 5. Debemos tener en cuenta que hay números que son múltiplos de 3 y de 5 a la vez.

Diagrama de flujo:

Tengamos en cuenta que el operador matemático % retorna el resto de dividir un valor por otro, en este caso: valor % 3 retorna el resto de dividir el valor que ingresamos por teclado, por tres.
Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12 el resto de dividirlo por 3 es 0. Generalizando: cuando el resto de dividir por 3 al valor que ingresamos por teclado es cero, se trata de un múltiplo de dicho valor.

Ahora bien ¿por qué no hemos dispuesto una estructura if anidada? Porque hay valores que son múltiplos de 3 y de 5 a la vez. Por lo tanto con if anidados no podríamos analizar los dos casos.
Es importante darse cuenta cuando conviene emplear if anidados y cuando no debe emplearse.

Programa: ejercicio045.go

package main

import "fmt"

func main () {
    var valor int
    mult3 := 0
    mult5 := 0
    for f := 1; f <= 10; f++ {
        fmt.Print("Ingrese un valor:")
        fmt.Scan(&valor)
        if valor % 3 == 0 {
            mult3 = mult3 + 1
        } 
        if valor % 5 == 0 {
            mult5 = mult5 + 1
        }        
    }
    fmt.Println("Cantidad de valores ingresados múltiplos de 3:", mult3)
    fmt.Println("Cantidad de valores ingresados múltiplos de 5:", mult5);    
}

Antes del for definimos e inicializamos dos contadores de tipo int:

    mult3 := 0
    mult5 := 0

Es importante notar que cada vuelta del for se verifican los dos if:

        if valor % 3 == 0 {
            mult3 = mult3 + 1
        } 
        if valor % 5 == 0 {
            mult5 = mult5 + 1
        }        

Problema 5:

Escribir un programa que lea n números enteros y calcule la cantidad de valores mayores o iguales a 1000.
Lo primero que se hace es cargar una variable que indique la cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la estructura repetitiva for.
La estructura for permite que el valor inicial o final dependa de una variable cargada previamente por teclado.

Diagrama de flujo:

Tenemos un contador llamado cantidad y f que es el contador del for.
La variable entera n se carga previo al inicio del for, por lo que podemos fijar el valor final del for con la variable n.
Por ejemplo si el operador carga 5 en n la estructura repetitiva for se ejecutará 5 veces.
La variable valor se ingresa dentro de la estructura repetitiva, y se verifica si el valor del mismo es mayor o igual a 1000, en dicho caso se incrementa en uno el contador cantidad.
Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene almacenado la cantidad de valores ingresados mayores o iguales a 1000.

Programa: ejercicio046.go

package main

import "fmt"

func main() {
    var n, valor int
    fmt.Print("Cuantos valores ingresará:")
    fmt.Scan(&n)
    cantidad := 0
    for f := 1; f <= n; f++ {
        fmt.Print("Ingrese valor:")
        fmt.Scan(&valor)
        if valor >= 1000 {
            cantidad++
        }
    }
    fmt.Print("La cantidad de valores ingresados mayores o iguales a 1000 son:",cantidad)
}

Problemas propuestos

Ha llegado nuevamente la parte fundamental, que es el momento donde uno desarrolla individualmente un algoritmo para la resolución de un problema.

• Confeccionar un programa que lea n pares de datos, cada par de datos corresponde a la medida de la base y la altura de un triángulo. El programa deberá informar:
  a) De cada triángulo la medida de su base, su altura y su superficie.
  b) La cantidad de triángulos cuya superficie es mayor a 12.
• Desarrollar un programa que solicite la carga de 10 números e imprima la suma de los últimos 5 valores ingresados.
• Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al 50)
• Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos muestre la tabla de multiplicar del mismo (los primeros 12 términos)
  Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9, hasta el 36.
• Realizar un programa que lea los lados de n triángulos, e informar:
  a) De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados iguales), isósceles (dos lados iguales), o escaleno (ningún lado igual)
  b) Cantidad de triángulos de cada tipo.
  c) Tipo de triángulo que posee menor cantidad.
• Escribir un programa que pida ingresar coordenadas (x,y) que representan puntos en el plano.
  Informar cuántos puntos se han ingresado en el primer, segundo, tercer y cuarto cuadrante. Al comenzar el programa se pide que se ingrese la cantidad de puntos a procesar.
• Se realiza la carga de 10 valores enteros por teclado. Se desea conocer:
  a) La cantidad de valores ingresados negativos.
  b) La cantidad de valores ingresados positivos.
  c) La cantidad de múltiplos de 15.
  d) El valor acumulado de los números ingresados que son pares.
• Se cuenta con la siguiente información:
  Las edades de 5 estudiantes del turno mañana.
  Las edades de 6 estudiantes del turno tarde.
  Las edades de 11 estudiantes del turno noche.
  Las edades de cada estudiante deben ingresarse por teclado.
  a) Obtener el promedio de las edades de cada turno (tres promedios)
  b) Imprimir dichos promedios (promedio de cada turno)
  c) Mostrar por pantalla un mensaje que indique cual de los tres turnos tiene un promedio de edades mayor.

Solución

ejercicio047.go

package main

import "fmt"

func main() {
    var n, base, altura int
    cantidad := 0
    fmt.Print("Cuantos triángulos procesará:")
    fmt.Scan(&n)
    for f := 1; f <= n; f++ {
        fmt.Print("Ingrese el valor de la base:")
        fmt.Scan(&base)
        fmt.Print("Ingrese el valor de la altura:")
        fmt.Scan(&altura);
        superficie := base * altura / 2
        fmt.Println("Superficie del triángulo:", superficie)
        if superficie > 12 {
            cantidad++
        }
    }
    fmt.Print("La cantidad de triángulos con superficie superior a 12 son:", cantidad)
}





ejercicio048.go

package main

import "fmt"

func main() {
    var valor int
    suma := 0
    for f := 1; f <= 10; f++ {
        fmt.Print("Ingrese un valor")
        fmt.Scan(&valor)
        if f>5 {
            suma = suma + valor
        }
    }
    fmt.Print("La suma de los últimos 5 valores es:", suma)
}




ejercicio049.go

package main

import "fmt"

func main() {
    for f := 5; f <= 50; f = f + 5 {
        fmt.Print(f,"-")
    }
}




ejercicio050.go

package main

import "fmt"

func main() {
    var valor int
    fmt.Print("Ingrese un valor entre 1 y 10:")
    fmt.Scan(&valor)
    for f := valor; f <= valor * 12; f = f + valor {
        fmt.Print(f,"-")
    }
}




ejercicio051.go

package main

import "fmt"

func main() {
    var n int
    var lado1, lado2, lado3 int
    cant1 := 0
    cant2 := 0
    cant3 := 0
    fmt.Print("Ingrese la cantidad de triángulos:")
    fmt.Scan(&n);
    for f := 1; f <= n; f++ {
        fmt.Print("Ingrese lado 1:")
        fmt.Scan(&lado1)
        fmt.Print("Ingrese lado 2:")
        fmt.Scan(&lado2)
        fmt.Printf("Ingrese lado 3:")
        fmt.Scan(&lado3)
        if lado1 == lado2 && lado1 == lado3 {
            fmt.Println("Es un triángulo equilatero.")
            cant1++
        } else {
            if lado1 == lado2 || lado1 == lado3 || lado2 == lado3 {
                fmt.Println("Es un triángulo isósceles.")
                cant2++
            } else {
                fmt.Println("Es un triángulo escaleno.")
                cant3++
            }
        }
    }
    fmt.Println("Cantidad de triángulos equilateros:", cant1)
    fmt.Println("Cantidad de triángulos isósceles:", cant2)
    fmt.Println("Cantidad de triángulos escalenos:", cant3)
    if cant1 < cant2 && cant1 < cant3 {
        fmt.Print("Hay menor cantidad de triángulos equilateros.")
    } else {
        if cant2 < cant3 {
            fmt.Print("Hay menor cantidad de triángulos isósceles")
        } else {
            fmt.Print("Hay menor cantidad de triángulos escalenos")
        }
    }
}




ejercicio052.go

package main

import "fmt"

func main() {
    var n int
    var x,y int
    cant1 := 0
    cant2 := 0
    cant3 := 0
    cant4 := 0
    fmt.Print("Cantidad de puntos:")
    fmt.Scan(&n)
    for f := 1; f <= n; f++ {
        fmt.Print("Ingrese coordenada x:")
        fmt.Scan(&x)
        fmt.Print("Ingrese coordenada y:")
        fmt.Scan(&y)
        if x > 0 && y > 0 {
            cant1++
        } else {
            if x < 0 && y > 0 {
                cant2++
            } else {
                if x < 0 && y < 0 {
                    cant3++
                } else {
                    if x > 0 && y < 0 {
                        cant4++
                    }
                }
            }
        }
    }
    fmt.Println("Cantidad de puntos en el primer cuadrante:", cant1)
    fmt.Println("Cantidad de puntos en el segundo cuadrante:", cant2)
    fmt.Println("Cantidad de puntos en el tercer cuadrante:", cant3)
    fmt.Println("Cantidad de puntos en el cuarto cuadrante:", cant4)
}




ejercicio053.go

package main

import "fmt"

func main() {
    var valor int
    negativos :=0
    positivos :=0
    mult15 := 0
    sumapares :=0
    for f := 1; f <= 10; f++ {
        fmt.Print("Ingrese valor:")
        fmt.Scan(&valor)
        if valor < 0 {
            negativos++
        } else {
            if valor > 0 {
                positivos++
            }
        }
        if valor % 15 == 0 && valor != 0 {
            mult15++
        }
        if valor % 2 == 0 && valor != 0 {
            sumapares=sumapares+valor+1
        }
    }
    fmt.Println("Cantidad de valores negativos:", negativos)
    fmt.Println("Cantidad de valores positivos:", positivos)
    fmt.Println("Cantidad de valores múltiplos de 15:", mult15)
    fmt.Println("Suma de los valores pares:", sumapares)
}




ejercicio054.go

package main

import "fmt"

func main() {
    var edad int
    suma1 := 0
    suma2 := 0
    suma3 := 0
    for f := 1; f <= 5; f++ {
        fmt.Print("Ingrese edad:")
        fmt.Scan(&edad)
        suma1 = suma1 + edad
    }
    pro1 := suma1 / 5;
    fmt.Println("Promedio de edades del turno mañana:", pro1)
    for f := 1; f <= 6; f++ {
        fmt.Print("Ingrese edad:")
        fmt.Scan(&edad)
        suma2 = suma2 + edad
    }
    pro2 := suma2 / 6
    fmt.Println("Promedio de edades del turno tarde:", pro2)
    for f := 1; f <= 11; f++ {
        fmt.Print("Ingrese edad:")
        fmt.Scan(&edad)
        suma3 = suma3 + edad
    }
    pro3 := suma3 / 11
    fmt.Println("Promedio de edades del turno noche:", pro3)
    if pro1 < pro2 && pro1 < pro3 {
        fmt.Print("El turno mañana tiene un promedio menor de edades.")
    } else {
        if pro2 < pro3 {
            fmt.Print("El turno tarde tiene un promedio menor de edades.")
        } else {
            fmt.Print("El turno noche tiene un promedio menor de edades.")
        }
    }
}