131 lines
2.5 KiB
Go
131 lines
2.5 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"math/bits"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func GetData(s string) []string {
|
|
var result []string
|
|
fileReader, err := os.Open(s)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
lines := bufio.NewScanner(fileReader)
|
|
lines.Split(bufio.ScanLines)
|
|
for lines.Scan() {
|
|
result = append(result, lines.Text())
|
|
}
|
|
return result
|
|
}
|
|
func ConvertToUsefulData(s []string) [][]uint {
|
|
a := make([][]uint, len(s[0]))
|
|
for i := range a {
|
|
a[i] = make([]uint, len(s))
|
|
}
|
|
for i, data := range s {
|
|
split := strings.Split(data, "")
|
|
for j, data2 := range split {
|
|
x, _ := strconv.Atoi(data2)
|
|
a[j][i] = uint(x)
|
|
}
|
|
}
|
|
return a
|
|
}
|
|
func main() {
|
|
result := Part1(ConvertToUsefulData(GetData("./data")))
|
|
fmt.Printf("The Power consumption is: %d\n", result)
|
|
|
|
data := ConvertToUsefulData(GetData("./test-data"))
|
|
for _, f := range data {
|
|
fmt.Println(f)
|
|
}
|
|
}
|
|
|
|
func Part1(data [][]uint) uint {
|
|
gammaRate := uint(0)
|
|
epsilonRate := uint(0)
|
|
for _, rows := range data {
|
|
dict := make(map[uint]uint)
|
|
for _, entry := range rows {
|
|
dict[entry] = dict[entry] + 1
|
|
}
|
|
if dict[0] > dict[1] {
|
|
gammaRate = gammaRate << 1
|
|
epsilonRate = epsilonRate << 1
|
|
epsilonRate, _ = bits.Add(epsilonRate, 1, 0)
|
|
} else {
|
|
gammaRate = gammaRate << 1
|
|
epsilonRate = epsilonRate << 1
|
|
gammaRate, _ = bits.Add(gammaRate, 1, 0)
|
|
}
|
|
}
|
|
//fmt.Printf("Gamma Rate: %b as int (%d)\n", gammaRate, gammaRate)
|
|
//fmt.Printf("Epsilon Rate: %b as int (%d)\n", epsilonRate, epsilonRate)
|
|
|
|
return gammaRate * epsilonRate
|
|
}
|
|
|
|
func dataSliceConvert(data [][]uint) [][]uint {
|
|
a := make([][]uint, len(data[0]))
|
|
for i := range a {
|
|
a[i] = make([]uint, len(data))
|
|
}
|
|
for i, row := range data {
|
|
for j, dataEntry := range row {
|
|
a[j][i] = dataEntry
|
|
}
|
|
}
|
|
return a
|
|
}
|
|
|
|
func WhichIsMore(data []uint) int {
|
|
dict := make(map[uint]uint)
|
|
for _, entry := range data {
|
|
dict[entry] = dict[entry] + 1
|
|
}
|
|
if dict[0] == dict[1] {
|
|
return 1
|
|
}
|
|
if dict[0] < dict[1] {
|
|
return 1
|
|
}
|
|
if dict[0] > dict[1] {
|
|
return 0
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func Cycle(data [][]uint, i int) [][]uint {
|
|
var result [][]uint
|
|
|
|
test := make([]uint, len(data))
|
|
for j := range data {
|
|
test[j] = data[j][i]
|
|
}
|
|
more := uint(WhichIsMore(test))
|
|
//fmt.Println(more)
|
|
//fmt.Println(test)
|
|
for _, odata := range data {
|
|
if odata[i] == more {
|
|
result = append(result, odata)
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func Part2(data [][]uint) (uint, uint) {
|
|
ordered := dataSliceConvert(data)
|
|
oxygenRate := Cycle(ordered, 0)
|
|
for i := range ordered[0] {
|
|
oxygenRate := Cycle(oxygenRate, i)
|
|
fmt.Println(oxygenRate)
|
|
}
|
|
|
|
return 0, 0
|
|
}
|