14 - Estructura de datos tipo array (arreglo)

Hemos empleado variables para almacenar números enteros, reales y cadenas de caracteres:

int
float32
float64
string

En este concepto veremos otros tipos de variables que permiten almacenar un conjunto de datos en una única variable.

Un arreglo o vector en el lenguaje Go es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo.
Con un único nombre se define un arreglo y por medio de un subíndice hacemos referencia a cada elemento del mismo (componente)

El tamaño del arreglo debe definirse en forma explícita y no puede variar durante su ejecución.

Problema 1:

Se desea guardar los sueldos de 5 operarios.
Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento los 5 sueldos almacenados en memoria.
Empleando un arreglo solo se requiere definir un único nombre y accedemos a cada elemento por medio del subíndice.

Programa: ejercicio0

package main

import "fmt"

func main() {
    var sueldos [5]int
    for f := 0; f < 5; f++ {
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[f])
    }
    fmt.Println("Listado de sueldos.")
    fmt.Println(sueldos)
}

Para la declaración del array le agregamos corchetes abiertos y cerrados con un valor que indica la cantidad de sueldos que podrá almacenar (en este ejemplo reservamos espacio para cinco sueldos):

    var sueldos [5]int

Para cargar cada componente del arreglo debemos indicar entre corchetes que elemento estamos accediendo:

    for f := 0; f < 5; f++ {
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[f])
    }

La estructura de programación que más se adapta para cargar en forma completa las componentes de un arreglo es un for, ya que sabemos de antemano la cantidad de valores a cargar, de todos modos no es obligatorio tener que utilizar un for.

Cuando f vale cero estamos accediendo a la primer componente del arreglo (en nuestro caso sería):

        fmt.Scan(&sueldos[0])

Lo mas común es utilizar una estructura repetitiva for para recorrer cada componente del arreglo.

Utilizar el for nos reduce la cantidad de código, si no utilizo un for debería en forma secuencial implementar el siguiente código:

        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[0])
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[1])
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[2])
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[3])
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[4])

La impresión en la consola de nuestra pantalla podemos hacerla en forma directa llamando a la función Print o Println del paquete fmt.:

    fmt.Println(sueldos)

Pero en otras situaciones tendremos que acceder elementos a elemento para procesarlo al vector, imaginemos si se necesita mostrar las componentes del arreglo sueldo uno en cada línea de la pantalla, el código para la impresión será:

package main

import "fmt"

func main() {
    var sueldos [5]int
    for f:=0; f<5; f++ {
        fmt.Print("Ingrese valor del sueldo:")
        fmt.Scan(&sueldos[f])
    }
    fmt.Println("Listado de sueldos.")
    //fmt.Println(sueldos)
    for f := 0; f < 5; f++ {
        fmt.Println(sueldos[f])
    }
}

Tener en cuenta que la línea:

    //fmt.Println(sueldos)

Transforma en comentario dicha instrucción y el compilador no la tiene en cuenta (no existe para el compilador y nos sirva a los programadores para disponer comentarios en nuestro programa)

Ahora para resolver el programa mediante un ciclo for accedemos elemento a elemento y lo mostramos uno por línea por pantalla.

Problema 2:

Definir un arreglo de 5 componentes de tipo float32 que representen las alturas de 5 personas.
Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio y cuántas más bajas.

Programa: ejercicio066.go

package main

import "fmt"

func main() {
    var alturas [5]float32
    var suma float32
    for f := 0; f < 5; f++ {
        fmt.Print("Ingrese la altura de la persona:")
        fmt.Scan(&alturas[f])
        suma = suma + alturas[f]
    }
    promedio := suma / 5
    fmt.Println("Promedio de las alturas:", promedio)
    may := 0
    men := 0
    for f := 0; f < 5; f++ {
        if alturas[f] > promedio {
            may++
        } else {
            if alturas[f] < promedio {
                men++
            }
        }        
    }
    fmt.Println("Cantidad de personas mayores al promedio:", may)
    fmt.Println("Cantidad de personas menores al promedio:", men)    
}

Si ejecutamos el programa tenemos un resultado similar a esto:

Definimos un arreglo donde almacenaremos las cinco alturas con valores reales (con parte decimal):

    var alturas [5]float32

En la primer parte del algoritmo procedemos a ingresar por teclado las 5 alturas de personas y acumular sus valores:

    for f := 0; f < 5; f++ {
        fmt.Print("Ingrese la altura de la persona:")
        fmt.Scan(&alturas[f])
        suma = suma + alturas[f]
    }

Calculamos y mostramos el promedio de las alturas:

    promedio := suma / 5
    fmt.Println("Promedio de las alturas:", promedio)

Por último comparamos cada componente del arreglo con la variable promedio, si el valor almacenado supera al promedio incrementamos un contador en caso que sea menor al promedio incrementamos otro contador:

    may := 0
    men := 0
    for f := 0; f < 5; f++ {
        if alturas[f] > promedio {
            may++
        } else {
            if alturas[f] < promedio {
                men++
            }
        }        
    }
    fmt.Println("Cantidad de personas mayores al promedio:", may)
    fmt.Println("Cantidad de personas menores al promedio:", men)    

Importante:

En este problema podemos observar una ventaja de tener almacenadas todas las alturas de las personas. Si no conociéramos los arreglos tenemos que cargar otra vez las alturas por teclado para compararlas con el promedio.
Mientras el programa está en ejecución tenemos el arreglo alturas a nuestra disposición. Es importante tener en cuenta que cuando finaliza la ejecución del programa se pierde el contenido de todas las variables (simples y de tipo arreglo)

Problema 3:

Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la mañana y 4 por la tarde)
Confeccionar un programa que permita almacenar los sueldos de los empleados agrupados por turno (definir los dos vectores con componentes de tipo float)
Imprimir los gastos en sueldos de cada turno.

Programa: ejercicio067.go

package main

import "fmt"

func main() {
    var turnoMan [4]float32
    var turnoTar [4]float32
    var total1 float32
    var total2 float32    
    fmt.Println("Sueldos de empleados del turno de la mañana.")
    for f := 0; f < len(turnoMan); f++ {
        fmt.Print("Ingrese sueldo:")
        fmt.Scan(&turnoMan[f])
        total1 = total1 + turnoMan[f]
    }    
    fmt.Println("Sueldos de empleados del turno de la tarde.")
    for f := 0; f < len(turnoTar); f++ {
        fmt.Print("Ingrese sueldo:")
        fmt.Scan(&turnoTar[f])
        total2 = total2 + turnoTar[f]
    }
    fmt.Println("Total de gastos del turno de la mañana:", total1)
    fmt.Println("Total de gastos del turno de la tarde:", total2)    
}

Definimos dos variables de tipo arreglo donde almacenaremos los sueldos de los empleados de cada turno:

    var turnoMan [4]float32
    var turnoTar [4]float32

Hay un comando en el lenguaje Go que nos retorna el tamaño del arreglo: len

Si tenemos que variar el tamaño del arreglo solo deberemos hacer un cambio donde se lo define al arreglo ya que en el resto podemos acceder al valor devuelto por len.

Mediante dos estructuras repetitivas procedemos a cargar cada arreglo y acumular los respectivos sueldos por turno:

    fmt.Println("Sueldos de empleados del turno de la mañana.")
    for f := 0; f < len(turnoMan); f++ {
        fmt.Print("Ingrese sueldo:")
        fmt.Scan(&turnoMan[f])
        total1 = total1 + turnoMan[f]
    }    
    fmt.Println("Sueldos de empleados del turno de la tarde.")
    for f := 0; f < len(turnoTar); f++ {
        fmt.Print("Ingrese sueldo:")
        fmt.Scan(&turnoTar[f])
        total2 = total2 + turnoTar[f]
    }

Mostramos los valores acumulados:

    fmt.Println("Total de gastos del turno de la mañana:", total1)
    fmt.Println("Total de gastos del turno de la tarde:", total2)    

Problemas propuestos

• Desarrollar un programa que permita ingresar un arreglo de 8 elementos, e informe:
  El valor acumulado de todos los elementos del arreglo.
  El valor acumulado de los elementos del arreglo que sean mayores a 36.
  Cantidad de valores mayores a 50.
  
• Realizar un programa que pida la carga de dos arreglos numéricos enteros de 4 elementos. Obtener la suma de los dos arreglos, dicho resultado guardarlo en un tercer arreglo del mismo tamaño. Sumar componente a componente.
• Se tienen las notas del primer parcial de los alumnos de dos cursos, el curso A y el curso B, cada curso cuenta con 5 alumnos.
  Realizar un programa que muestre el curso que obtuvo el mayor promedio general.
• Cargar un arreglo de 10 elementos y verificar posteriormente si el mismo está ordenado de menor a mayor.

Solución

ejercicio068.go

package main

import "fmt"

func main() {
    var vec [8]int
    sumaTotal := 0
    sumaMayor36 := 0
    cant := 0
    for f := 0; f < len(vec); f++ {
        fmt.Print("Ingrese elemento:")
        fmt.Scan(&vec[f])
        sumaTotal = sumaTotal + vec[f]
        if vec[f] > 50 {
            cant++
        }
        if vec[f] > 36 {
            sumaMayor36 = sumaMayor36 + vec[f]
        }        
    }
    fmt.Println("La suma de los 8 elementos es:", sumaTotal)
    fmt.Println("La suma de los elementos mayores a 36:", sumaTotal)    
    fmt.Println("La cantidad de valores mayores a 50 es:", cant)
}




ejercicio069.go

package main

import "fmt"

func main() {
    var vec1 [4]int
    var vec2 [4]int
    var vecSuma[4]int
    fmt.Println("Carga del primer vector.")
    for f := 0; f < len(vec1); f++ {
        fmt.Print("Ingrese elemento:")
        fmt.Scan(&vec1[f])
    }
    fmt.Println("Carga del segundo vector.")
    for f := 0; f < len(vec2); f++ {
        fmt.Print("Ingrese elemento:")
        fmt.Scan(&vec2[f])
    }
    for f := 0; f < len(vecSuma); f++ {
        vecSuma[f] = vec1[f] + vec2[f]
    }
    fmt.Println("Vector resultante")
    fmt.Println(vecSuma)
}




ejercicio070.go

package main

import "fmt"

func main() {
    var cursoa [5]int
    var cursob [5]int
    suma1 := 0
    fmt.Println("Carga de notas del curso A")
    for f := 0; f < len(cursoa); f++ {
        fmt.Print("Ingrese nota:")
        fmt.Scan(&cursoa[f])
        suma1 = suma1 + cursoa[f]
    }
    suma2 := 0
    fmt.Println("Carga de notas del curso B")
    for f := 0; f < len(cursob); f++ {
        fmt.Print("Ingrese nota:")
        fmt.Scan(&cursob[f])
        suma2 = suma2 + cursob[f]
    }
    promedioa := suma1 / 5
    promediob := suma2 / 5
    fmt.Println("Promedio curso A:", promedioa)
    fmt.Println("Promedio curso B:", promediob)
    if promedioa>promediob {
        fmt.Println("El curso A tiene un promedio mayor.")
    } else {
        fmt.Println("El curso B tiene un promedio mayor.")
    }    
}




ejercicio071.go

package main

import "fmt"

func main() {
    var vec [10]int
    for f := 0; f < len(vec); f++ {
        fmt.Print("Ingrese elemento:")
        fmt.Scan(&vec[f])
    }
    orden := 1
    for f := 0; f < len(vec) - 1; f++ {
        if vec[f+1] < vec[f] {
            orden=0;
        }
    }
    if orden==1 {
        fmt.Print("Esta ordenado de menor a mayor")
    } else {
        fmt.Print("No esta ordenado de menor a mayor")
    }    
}