[go lang] 배열, 슬라이스, 맵

정적 배열

배열의 타입 이름은 [#count]<type> 형태로 int 원소 5개를 담는 배열의 타입 이름은 [5]int, bool 원소 100개를 담는 배열의 타입 이름은 [100]bool이 된다. 타입 이름 뒤에 {와 }로 초기화 리스트를 줄 수 있다.

func main() {
    var array [5]int
    even := [4]int{2, 4, 6, 8}
    vertexes := [3]Vertex{{1, 2}, {2, 3}}
}

슬라이스

슬라이스의 타입 이름은 []<type> 형태로 int 원소를 담는 슬라이스의 타입 이름은 []int, bool 원소를 담는 슬라이스의 타입 이름은 []bool이 된다. 배열과 달리 전체 원소 개수를 지정하지 않는다.

func main() {
    // 배열로부터 범위를 지정
    primes := [5]int{2, 3, 5, 7, 11}
    s := primes[:3]

    // 슬라이스 리터럴로 초기화
    vertexes := []Vertex{{1, 2}, {2, 3}, {3, 4}}
    // 원소를 추가, 메모리 부족하다면 자동으로 할당
    vertexes = append(vertexes, {7, 6}, {2, 3})

    // range 키워드를 통해 인덱스와 원소의 복사본을 순서대로 조회
    for i, v := range vertexes {
        fmt.Println(i, v)
    }

    // make(type, count)로 새로운 슬라이스
    ticTacToe := make([][]bool, 3)
    for i := range ticTacToe {
        ticTacToe = make([]bool, 3)
    }
}

맵

맵의 타입 이름은 map[KeyType]ValueType 이다. var m map[string]Vecter 와 같은 선언만으로 맵 m을 바로 이용할 수 없다. 맵을 이용하기 위해서는 make를 이용해 맵을 할당받거나 맵 리터럴을 이용해 선언과 함께 초기화하여야 한다.

func main() {
    var m map[string]Vertex
    m = make(map[string]Vertex)

    student := map[string]Student{
        "A000001": {"Jiseok Son", 98},
        "A000002": {"Who Is", 80}
    }
    delete(student, "A000002")

    s, ok := student["A000002"] // nil, false
}

예제: 에라토스테네스의 체 알고리즘

func ListPrimes(upperLimit int) {
    isPrime := make([]bool, upperLimit+1)
    for i := range isPrime {
        isPrime[i] = true
    }
    for i := 2; i*i <= upperLimit; i++ {
        if !isPrime[i] {
            continue
        }
        for j := i * i; j <= upperLimit; j += i {
            isPrime[j] = false
        }
    }
    for i := 2; i <= upperLimit; i++ {
        if isPrime[i] {
            fmt.Printf("%d ", i)
        }
    }
    fmt.Println()
}

예제: 스도쿠 풀이 백트래킹

func NumAvailable(board [][]int, y, x, n int) bool {
    for i := range 9 {
        if board[y][i] == n || board[i][x] == n {
            return false
        }
    }
    yb, xb := y/3*3, x/3*3
    for i := range 3 {
        for j := range 3 {
            if board[yb+i][xb+j] == n {
                return false
            }
        }
    }
    return true
}

func SolveSudoku(board [][]int, y, x int) bool {
    for ; y < 9; y++ {
        for ; x < 9; x++ {
            if board[y][x] != 0 {
                continue
            }
            for n := 1; n <= 9; n++ {
                if !NumAvailable(board, y, x, n) {
                    continue
                }
                board[y][x] = n
                if SolveSudoku(board, y, x) {
                    return true
                }
                board[y][x] = 0
            }
            return false
        }
        x = 0
    }
    return true
}