Add comments

Author: vsliouniaev

Diff for: 2021/16/main.go

@@ -13,13 +13,52 @@ func main() {
 	fmt.Printf("Part 2: %d\n", part2(util.RelativeFile("input"))) // 13476220616073
 }
 
-type parser struct {
+func part1(file string) int64 {
+	data, err := hex.DecodeString(util.ReadLinesStrings(file)[0])
+	util.Check(err)
+	p := Parser{data: data}
+	p.ReadNumSubPackets(1)
+	return p.sumVersionNums
+}
+
+func part2(file string) int64 {
+	return evalExpression(util.ReadLinesStrings(file)[0])
+}
+
+func evalExpression(text string) int64 {
+	data, err := hex.DecodeString(text)
+	util.Check(err)
+	p := Parser{data: data}
+	var out []int64
+	out, _ = p.ReadNumSubPackets(1)
+	return out[0]
+}
+
+// Parser holds data for parsing the Buoyancy Interchange Transmission System (BITS) expression.
+type Parser struct {
 	data           []byte
 	pos            int
 	sumVersionNums int64
 }
 
-func (p *parser) ReadLiteral() (int64, bool) {
+func (p *Parser) Chomp(ln int) (int64, bool) {
+	i := bits.GetAsInt(p.data, p.pos, ln)
+	p.pos += ln
+	return i, (len(p.data)*8)-1 > p.pos
+}
+
+// ReadVersion reads the 3 bits at the start of the expression. These are only useful for part 1 of day 16.
+func (p *Parser) ReadVersion() (int64, bool) {
+	return p.Chomp(3)
+}
+
+// ReadMode reads the 3 bits of the mode at the head of an expression (after the version).
+func (p *Parser) ReadMode() (int64, bool) {
+	return p.Chomp(3)
+}
+
+// ReadLiteral reads a single literal value.
+func (p *Parser) ReadLiteral() (int64, bool) {
 	var ok bool
 	var read int64
 	val := int64(0)
@@ -36,21 +75,45 @@ func (p *parser) ReadLiteral() (int64, bool) {
 	return val, ok
 }
 
-func (p *parser) Chomp(ln int) (int64, bool) {
-	i := bits.GetAsInt(p.data, p.pos, ln)
-	p.pos += ln
-	return i, (len(p.data)*8)-1 > p.pos
+// ReadNested begins to parse a sub-packet chunk.
+// If the length type id is 0 - read packets until the total number of bits has been reached
+// If the length type id is 1 - read the specified number of packets
+func (p *Parser) ReadNested() ([]int64, bool) {
+	lengthTypeId, _ := p.Chomp(1)
+	if lengthTypeId == 0 {
+		// Total number of bits
+		totalNumberOfBits, _ := p.Chomp(15)
+		return p.ReadSubPacketsOfLength(int(totalNumberOfBits))
+	} else {
+		numberOfPackets, _ := p.Chomp(11)
+		return p.ReadNumSubPackets(numberOfPackets)
+	}
 }
 
-func (p *parser) ReadVersion() (int64, bool) {
-	return p.Chomp(3)
+// ReadNumSubPackets reads the specified number of sub-packets
+func (p *Parser) ReadNumSubPackets(num int64) ([]int64, bool) {
+	var out []int64
+	for i := int64(0); i < num; i++ {
+		o, _ := p.ReadSubPacket()
+		out = append(out, o)
+	}
+	return out, true
 }
 
-func (p *parser) ReadMode() (int64, bool) {
-	return p.Chomp(3)
+// ReadSubPacketsOfLength reads sub-packets limited to the number of bits
+func (p *Parser) ReadSubPacketsOfLength(lim int) ([]int64, bool) {
+	var out []int64
+	lim = p.pos + lim
+	for p.pos < lim {
+		o, _ := p.ReadSubPacket()
+		out = append(out, o)
+	}
+	return out, true
 }
 
-func (p *parser) ReadSub() (int64, bool) {
+// ReadSubPacket reads a single sub-packet. However, since a sub-packet can have more sub-packets it is recursive via
+// ReadNested calls back to itself.
+func (p *Parser) ReadSubPacket() (int64, bool) {
 	var out int64
 	var ok bool
 	v, _ := p.ReadVersion()
@@ -121,55 +184,3 @@ func (p *parser) ReadSub() (int64, bool) {
 
 	return out, ok
 }
-
-func (p *parser) ReadNested() ([]int64, bool) {
-	lengthTypeId, _ := p.Chomp(1)
-	if lengthTypeId == 0 {
-		// Total number of bits
-		totalNumberOfBits, _ := p.Chomp(15)
-		return p.ReadBits(int(totalNumberOfBits))
-	} else {
-		numberOfPackets, _ := p.Chomp(11)
-		return p.ReadNumSubPackets(numberOfPackets)
-	}
-}
-
-func (p *parser) ReadNumSubPackets(num int64) ([]int64, bool) {
-	var out []int64
-	for i := int64(0); i < num; i++ {
-		o, _ := p.ReadSub()
-		out = append(out, o)
-	}
-	return out, true
-}
-
-func (p *parser) ReadBits(lim int) ([]int64, bool) {
-	var out []int64
-	lim = p.pos + lim
-	for p.pos < lim {
-		o, _ := p.ReadSub()
-		out = append(out, o)
-	}
-	return out, true
-}
-
-func part1(file string) int64 {
-	data, err := hex.DecodeString(util.ReadLinesStrings(file)[0])
-	util.Check(err)
-	p := parser{data: data}
-	p.ReadNumSubPackets(1)
-	return p.sumVersionNums
-}
-
-func part2(file string) int64 {
-	return evalExpression(util.ReadLinesStrings(file)[0])
-}
-
-func evalExpression(text string) int64 {
-	data, err := hex.DecodeString(text)
-	util.Check(err)
-	p := parser{data: data}
-	var out []int64
-	out, _ = p.ReadNumSubPackets(1)
-	return out[0]
-}

Diff for: util/bits/bits.go

@@ -2,6 +2,8 @@ package bits
 
 var lookup = []int64{0b0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF}
 
+// https://stackoverflow.com/a/3847525
+
 func GetAsInt(bytes []byte, offset int, ln int) int64 {
 	byteIndex := offset / 8
 	bitIndex := offset % 8