Advent of Code 2020 Day 3 Part 1

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

func parse() map[int][]byte {
    f, err := os.Open("input.txt")
    if err != nil {
        log.Println(err)
    }
    defer func() {
        err = f.Close()
        if err != nil {
            log.Println(err)
        }
    }()

    fb, err := ioutil.ReadAll(f)
    if err != nil {
        log.Println(err)
    }

    var (
        rows     = make(map[int][]byte)
        sequence []byte
        count    = 0
    )
    for i := range fb {
        switch fb[i] {
        case 10: // \n
            rows[count] = sequence
            sequence = nil
            count++
        default:
            sequence = append(sequence, fb[i])
        }
    }
    return rows
}

func build_map(receive chan int, send chan []byte, rows map[int][]byte) {
    for {
        result := <-receive
        switch {
        case result <= len(rows):
            send <- rows[result]
        default:
            fmt.Println("waiting...")
        }
    }
}

var tree_warning int

func walk_map(send chan int, receive chan []byte, done chan bool) {
    var row = 1
    var position = 3
    for {
        send <- row
        result := <-receive
        var c int
        for i := 0; i <= position; i++ {
            if c >= len(result) {
                c = 0
            }
            if len(result) != 0 {
                switch {
                case i == position:
                    if result[c] == 35 {
                        fmt.Print("☆")
                        tree_warning++
                    } else {
                        fmt.Print("♡")
                    }
                case result[c] == 35: // #
                    fmt.Print("#")
                case result[c] == 46: // .
                    fmt.Print(".")
                }
            }
            c++
        }

        switch {
        case row == 323:
            done <- true
            return
        default:
            row++
            position = position + 3
        }
        fmt.Println()
    }
    done <- true
}

func main() {
    var (
        done    = make(chan bool)
        send    = make(chan int)
        receive = make(chan []byte)
    )
    rows := parse()
    go build_map(send, receive, rows)
    go walk_map(send, receive, done)
    <-done
    fmt.Println(tree_warning)
}