Advent of Code 2020 Day 6

package main

import (
    "log"
    "os"
)

type group struct { // groups parties together
    answers []map[int]bool // each party gets there own set
    size    int         // how many parties in group
}

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

    buf := make([]byte, 1)
    previous_byte := make([]byte, 1)
    count := 0
    var group_count int
    var group_sizes []int
    for {
        _, err := f.Read(buf)
        if err != nil { // EOF, append last group
            group_sizes = append(group_sizes, count)
            group_count++
            break
        }

        // count newlines: "people"
        // on double newline, "group end", append group
        switch {
        case buf[0] == 10 && previous_byte[0] == 10:
            group_sizes = append(group_sizes, count)
            count = 0
            group_count++
        case buf[0] == 10:
            count++
        }

        previous_byte[0] = buf[0]
    }
    return group_sizes, group_count
}

func get_group_answers(group_sizes []int, group_count int) []group {
    // 2195 lines
    f, err := os.Open("input.txt")
    if err != nil {
        log.Println(err)
    }
    defer func() {
        err = f.Close()
        if err != nil {
            log.Println(err)
        }
    }()

    groups := make([]group, group_count)
    for i := range groups {
        groups[i].answers = make([]map[int]bool, group_sizes[i]+1)
        for z := range groups[i].answers {
            groups[i].answers[z] = make(map[int]bool, 0)
        }
    }

    i := 0; l := 0
    buf := make([]byte, 1)
    previous_byte := make([]byte, 1)

    for {
        _, err = f.Read(buf)
        if err != nil {
            groups[i].size = group_sizes[i]
            break // EOF
        }

        // a-z mapping
        switch string(buf[0]) {
        case "a":
            groups[i].answers[l][0] = true
        case "b":
            groups[i].answers[l][1] = true
        case "c":
            groups[i].answers[l][2] = true
        case "d":
            groups[i].answers[l][3] = true
        case "e":
            groups[i].answers[l][4] = true
        case "f":
            groups[i].answers[l][5] = true
        case "g":
            groups[i].answers[l][6] = true
        case "h":
            groups[i].answers[l][7] = true
        case "i":
            groups[i].answers[l][8] = true
        case "j":
            groups[i].answers[l][9] = true
        case "k":
            groups[i].answers[l][10] = true
        case "l":
            groups[i].answers[l][11] = true
        case "m":
            groups[i].answers[l][12] = true
        case "n":
            groups[i].answers[l][13] = true
        case "o":
            groups[i].answers[l][14] = true
        case "p":
            groups[i].answers[l][15] = true
        case "q":
            groups[i].answers[l][16] = true
        case "r":
            groups[i].answers[l][17] = true
        case "s":
            groups[i].answers[l][18] = true
        case "t":
            groups[i].answers[l][19] = true
        case "u":
            groups[i].answers[l][20] = true
        case "v":
            groups[i].answers[l][21] = true
        case "w":
            groups[i].answers[l][22] = true
        case "x":
            groups[i].answers[l][23] = true
        case "y":
            groups[i].answers[l][24] = true
        case "z":
            groups[i].answers[l][25] = true
        case "\n":
            if string(previous_byte[0]) == "\n" {
                groups[i].size = group_sizes[i]
                i++
                l = 0
            } else {
                l++
            }
        default:
            print(buf[0])
        }

        previous_byte[0] = buf[0]
    }

    return groups
}

func check_answers(groups []group, x int, c int) {
    for x != len(groups) {
        question := 0
        for question < 26 { // a-z
            person := 0
            for groups[x].answers[person][question] != false {
                person++
            }
            if person == groups[x].size {
                c++
            }
            // cycle to next question
            question++
        }

        x++ // cycle to next group
    }
    print(c)
}

func main() {
    group_sizes, group_count := get_group_sizes()
    groups := get_group_answers(group_sizes, group_count)
    check_answers(groups, 0, 0)
}