Estructura de datos tipo array - con dos dimensiones (matriz)

Una matriz es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo.
Con un único nombre se define la matriz y por medio de DOS subíndices hacemos referencia a cada elemento de la misma (componente)

Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada elemento debemos indicar primero la fila y luego la columna, por ejemplo en la componente 1,4 se almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben ser del mismo tipo.
Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores (array unidimensionales)

Problema 1:

Programa: ejercicio075.go

package main

import "fmt"

func main() {
    var mat [3][5]int
    for f :=0 ; f < 3; f++ {
        for c := 0; c < 5; c++ {
            fmt.Print("Ingrese componente:")
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println("Impresión de la matriz completa con la función Println")
    fmt.Println(mat)
    fmt.Println("Impresión elemento a elemento")
    for f := 0; f < 3; f++ {
        for c := 0; c < 5; c++ {
            fmt.Print(mat[f][c], " ")
        }
        fmt.Println();
    }    
}

Definimos una matriz.
Para definir una matriz en el lenguaje Go debemos disponer como primer subíndice la cantidad de filas y como segundo subíndice la cantidad de columnas:

    var mat [3][5]int

Para cargar sus 15 componentes (cada fila almacena 5 componentes y tenemos 3 filas), lo más cómodo es utilizar un for anidado, el primer for que incrementa el contador "f" lo utilizamos para recorrer las filas y el contador interno llamado "c" lo utilizamos para recorrer las columnas.

Cada vez que se repite en forma completa el for interno se carga una fila completa, primero se carga la fila cero en forma completa, luego la fila uno y finalmente la fila 2.
Siempre que accedemos a una posición de la matriz debemos disponer dos subíndices que hagan referencia a la fila y columna mat[f][c]):

    for f :=0 ; f < 3; f++ {
        for c := 0; c < 5; c++ {
            fmt.Print("Ingrese componente:")
            fmt.Scan(&mat[f][c])
        }
    }

Para imprimir la matriz podemos hacerlo tan sencillo como llamar a la función Println y pasarle la matriz:

    fmt.Println("Impresión de la matriz completa con la función Println")
    fmt.Println(mat)

O acceder a cada elemento e imprimir uno a uno:

    fmt.Println("Impresión elemento a elemento")
    for f := 0; f < 3; f++ {
        for c := 0; c < 5; c++ {
            fmt.Print(mat[f][c], " ")
        }
        fmt.Println();
    }

Cada vez que se ejecuta todas las vueltas del for interno tenemos en pantalla una fila completa de la matriz, por eso pasamos a ejecutar un salto de línea (con esto logramos que en pantalla los datos aparezcan en forma matricial):

        fmt.Println();

Problema 2:

Crear y cargar una matriz de 4 filas por 4 columnas. Imprimir la diagonal principal.

              x    -    -    -
              -    x    -    -
              -    -    x    -
              -    -    -    x

Programa: ejercicio076.go

package main

import "fmt"

func main() {
    var mat [4][4]int
    for f :=0 ; f < 4; f++ {
        for c := 0; c < 4; c++ {
            fmt.Print("Ingrese componente:")
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println("Matriz completa.")
    fmt.Println(mat)    
    fmt.Println("Elementos de la diagonal principal.")
    for k := 0; k < 4; k++ {
        fmt.Print(mat[k][k]," ")
    }    
}

La definición de la matriz y su carga e impresión completa no varían con el ejemplo anterior:

    var mat [4][4]int
    for f :=0 ; f < 4; f++ {
        for c := 0; c < 4; c++ {
            fmt.Print("Ingrese componente:")
            fmt.Scan(&mat[f][c])
        }
    }

Para imprimir la diagonal principal de la matriz lo más conveniente es utilizar un for que se repita 4 veces y disponer como subíndice dicho contador (los elementos de la diagonal principal coinciden los valores de la fila y columna):

    fmt.Println("Elementos de la diagonal principal.")
    for k := 0; k < 4; k++ {
        fmt.Print(mat[k][k]," ")
    }

Recordar que si bien es muy común utilizar dos for para procesar matrices, en muchas situaciones si tenemos que acceder a una sola fila, una sola columna, una diagonal etc. se utilice un solo for o inclusive sin for.

Problema 3:

Crear y cargar una matriz de 3 filas por 4 columnas. Imprimir la primer fila. Imprimir la última fila e imprimir la primer columna.

Programa: ejercicio077.go

package main

import "fmt"

func main() {
    var mat [3][4]int
    for f :=0 ; f < 3; f++ {
        for c := 0; c < 4; c++ {
            fmt.Print("Ingrese componente:")
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println("Matriz completa")
    fmt.Println(mat)
    fmt.Println("Primer fila de la matriz.")
    for c := 0; c < 4; c++ {
        fmt.Print(mat[0][c]," ")
    }
    fmt.Println()
    fmt.Println("Ultima fila de la matriz")
    for c := 0; c < 4; c++ {
        fmt.Print(mat[2][c]," ")
    }
    fmt.Println()
    fmt.Println("Primer columna de la matriz")
    for f := 0; f < 3; f++ {
        fmt.Print(mat[f][0]," ")
    }
    fmt.Println()
}

Luego de cargar por teclado la matriz, disponemos un for para recorrer las columnas, ya que la fila siempre será la cero. Como son cuatro los elementos de la primer fila el for se repite esta cantidad de veces:

    fmt.Println("Primer fila de la matriz.")
    for c := 0; c < 4; c++ {
        fmt.Print(mat[0][c]," ")
    }

Para imprimir la última fila el algoritmo es similar, disponemos un for que se repita 4 veces y en el subíndice de la fila disponemos el valor 2 (ya que la matriz tiene 3 filas):

    fmt.Println("Ultima fila de la matriz")
    for c := 0; c < 4; c++ {
        fmt.Print(mat[2][c]," ")
    }

Para imprimir la primer columna el for debe repetirse 3 veces ya que la matriz tiene 3 filas. Dejamos constante el subíndice de la columna con el valor cero:

    fmt.Println("Primer columna de la matriz")
    for f := 0; f < 3; f++ {
        fmt.Print(mat[f][0]," ")
    }

Problemas propuestos

Crear una matriz de 2 filas y 5 columnas. Realizar la carga de componentes por columna (es decir primero ingresar toda la primer columna, luego la segunda columna y así sucesivamente)
Imprimir luego la matriz.
Crear una matriz de 3x4. Realizar la carga y luego imprimir el elemento mayor.
Definir una matriz de 2 filas y 5 columnas. Realizar su carga e impresión.
Intercambiar los elementos de la primera fila con la segunda y volver a imprimir la matriz.

Solución

ejercicio078.go

package main

import "fmt"

func main() {
    var mat [2][5]int
    for c :=0 ; c < 5; c++ {
        for f := 0; f < 2; f++ {
            fmt.Print("Ingrese elemento de la fila ", f, " y columna ", c, ":");
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println(mat)    
}




ejercicio079.go

package main

import "fmt"

func main() {
    var mat [3][4]int
    for f :=0; f < 3; f++ {
        for c := 0; c < 4; c++ {
            fmt.Print("Ingrese elemento:")
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println("Matriz completa")
    fmt.Println(mat)
    may := mat[0][0]
    for f := 0; f < 3; f++ {
        for c := 0; c < 4; c++ {
            if mat[f][c] > may {
                may = mat[f][c]
            }
        }
    }
    fmt.Print("Elemento mayor de la matriz: ", may)    
}




ejercicio080.go

package main

import "fmt"

func main() {
    var mat [2][5]int
    for f := 0; f < 2; f++ {
        for c := 0; c < 5; c++ {
            fmt.Print("Ingrese elemento:")
            fmt.Scan(&mat[f][c])
        }
    }
    fmt.Println("Matriz completa")
    fmt.Println(mat)
    var aux int
    for c := 0; c < 5; c++ {
        aux = mat[0][c]
        mat[0][c] = mat[1][c]
        mat[1][c] = aux
    }
    fmt.Println("Matriz completa luego de intercambiar primer fila con la segunda.")
    fmt.Println(mat)    
}

Retornar