// 3. hét – Kétdimenziós tömbök (mátrixok) Go nyelven
// Futtatás: go run ./h03/matrix
package main

import "fmt"

func print(m [][]int) {
	for _, row := range m {
		for _, v := range row {
			fmt.Printf("%4d", v)
		}
		fmt.Println()
	}
}

// diagonalSums: főátló (i == j) és mellékátló (i + j == n-1) összege.
func diagonalSums(m [][]int) (int, int) {
	n, main, anti := len(m), 0, 0
	for i := 0; i < n; i++ {
		main += m[i][i]
		anti += m[i][n-1-i]
	}
	return main, anti
}

func newMatrix(rows, cols int) [][]int {
	m := make([][]int, rows)
	for i := range m {
		m[i] = make([]int, cols)
	}
	return m
}

func transpose(m [][]int) [][]int {
	t := newMatrix(len(m[0]), len(m))
	for i := range m {
		for j := range m[i] {
			t[j][i] = m[i][j]
		}
	}
	return t
}

// multiply: (n×k)·(k×m) – O(n·k·m)
func multiply(a, b [][]int) [][]int {
	n, k, m := len(a), len(b), len(b[0])
	c := newMatrix(n, m)
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			for x := 0; x < k; x++ {
				c[i][j] += a[i][x] * b[x][j]
			}
		}
	}
	return c
}

func main() {
	m := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
	fmt.Println("m:")
	print(m)
	d1, d2 := diagonalSums(m)
	fmt.Println("főátló összege =", d1, ", mellékátló összege =", d2)

	r := [][]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("r (2x3) transzponáltja:")
	print(transpose(r))
	fmt.Println("r · I:")
	print(multiply(r, [][]int{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}))

	// Valódi 2D tömb: [3][4]int – egyetlen folytonos memóriaterület, sorfolytonosan
	var grid [3][4]int
	for i := 0; i < 3; i++ {
		for j := 0; j < 4; j++ {
			grid[i][j] = i*4 + j // éppen a sorfolytonos index
		}
	}
	fmt.Println("[3][4]int:", grid)

	// Szeletek szelete: a sorok hossza eltérhet (mint Java-ban)
	jagged := [][]int{{1, 2, 3}, {4, 5}, {6, 7, 8, 9}}
	fmt.Println("jagged:")
	print(jagged)

	flat := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	cols := 3
	fmt.Println("flat[1*3 + 2] = A[1][2] =", flat[1*cols+2])
}