221 lines
7.6 KiB
Go
221 lines
7.6 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
// "strings"
|
|
"bufio"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
)
|
|
|
|
func check(e error) {
|
|
if e != nil {
|
|
panic(e)
|
|
}
|
|
}
|
|
|
|
func PrintAndWait(x ...any) {
|
|
fmt.Print(x)
|
|
fmt.Scanln()
|
|
}
|
|
|
|
func MatchNumbers(lines []string, index int, ast []int, total *int) {
|
|
// Regex that finds the numbers in a row
|
|
renum := regexp.MustCompile("[0-9]+")
|
|
// Gather numbers in prev line
|
|
prevLine := renum.FindAllStringIndex(lines[index-1], -1)
|
|
// Gather numbers in this line
|
|
thisLine := renum.FindAllStringIndex(lines[index], -1)
|
|
// Gather numbers in next line
|
|
nextLine := renum.FindAllStringIndex(lines[index+1], -1)
|
|
// Calculate the number of numbers in three lines
|
|
totalNumbers := len(prevLine) + len(thisLine) + len(nextLine)
|
|
|
|
// Now we create a big array with all the indexes
|
|
allIndexes := prevLine
|
|
for i := range thisLine {
|
|
allIndexes = append(allIndexes, thisLine[i])
|
|
}
|
|
for i := range nextLine {
|
|
allIndexes = append(allIndexes, nextLine[i])
|
|
}
|
|
|
|
// Now we create a big array with all the numbers
|
|
// We start from the previous line
|
|
allNumbers := renum.FindAllString(lines[index-1], -1)
|
|
thisNums := renum.FindAllString(lines[index], -1)
|
|
for i := range thisNums {
|
|
allNumbers = append(allNumbers, thisNums[i])
|
|
}
|
|
nextNums := renum.FindAllString(lines[index+1], -1)
|
|
for i := range nextNums {
|
|
allNumbers = append(allNumbers, nextNums[i])
|
|
}
|
|
// When we start, we have zero matches
|
|
matches := 0
|
|
// We will stop when we encounter two numbers
|
|
twoNums := [2]int{0, 0}
|
|
_ = twoNums
|
|
// Cycling through all numbers, but stopping at two matches
|
|
for i := 0; i < totalNumbers && matches < 2; i++ {
|
|
if (ast[0] >= allIndexes[i][0] - 1 && ast[0] <= allIndexes[i][1]) {
|
|
matches += 1
|
|
num, _ := strconv.Atoi(allNumbers[i])
|
|
twoNums[matches - 1] = num
|
|
}
|
|
}
|
|
if(matches == 2) {
|
|
tempGears := twoNums[0] * twoNums[1]
|
|
*total += tempGears
|
|
}
|
|
}
|
|
|
|
func CheckGears(lines []string) {
|
|
total := 0
|
|
totalPoint := &total
|
|
// Regex that finds the numbers in a row
|
|
//renum := regexp.MustCompile("[0-9]+")
|
|
// Regex that finds the asterisks in a row
|
|
resym := regexp.MustCompile("[*]")
|
|
// For every line starting from the second
|
|
for i := 0; i < len(lines) - 1; i++ {
|
|
// Take the index of the asterisks
|
|
asteriskIndex := resym.FindAllStringIndex(lines[i], - 1)
|
|
// For every index we get
|
|
for j := range asteriskIndex {
|
|
MatchNumbers(lines, i, asteriskIndex[j], totalPoint)
|
|
}
|
|
}
|
|
// firstLineNums := renum.FindAllStringIndex(lines[index], -1)
|
|
// firstLineSymbolsIndex := resym.FindAllStringIndex(lines[index], -1)
|
|
// secondLineSymbolsIndex := resym.FindAllStringIndex(lines[index + 1], -1)
|
|
// For every *number index range*, check if in the same line there is a
|
|
// symbol on (first - 1) or (last + 1), check in other lines if there is
|
|
// a symbol in a specific interval of numbers. If you find a match, you
|
|
// can break as you just need one symbol
|
|
fmt.Printf("Total of gears is: %d\n", total)
|
|
}
|
|
|
|
func main() {
|
|
file, err := os.Open("./inputs/day03_input")
|
|
check(err)
|
|
defer file.Close()
|
|
|
|
// This regex find the numbers inside strings
|
|
renum := regexp.MustCompile("[0-9]+")
|
|
resym := regexp.MustCompile("[^0-9.]+")
|
|
|
|
scanner := bufio.NewScanner(file)
|
|
var lines []string
|
|
var totalSum int = 0
|
|
|
|
// Read the whole file into an array of strings
|
|
for scanner.Scan() {
|
|
lines = append(lines, scanner.Text())
|
|
}
|
|
numLines := len(lines)
|
|
numbers := make([][]int, numLines)
|
|
|
|
// The 2D array of numbers will hold all the numbers to easily
|
|
// match them with corresponding strings in the file using the index
|
|
// For every line in the file, create an array of numbers
|
|
for i := 0; i < numLines; i++ {
|
|
tempNums := renum.FindAllString(lines[i], -1)
|
|
for j := 0; j < len(tempNums); j++ {
|
|
num, _ := strconv.Atoi(tempNums[j])
|
|
numbers[i] = append(numbers[i], num)
|
|
}
|
|
}
|
|
/* Line [0] needs to check only line 1 for symbols.
|
|
Similarly, the last line needs to check only
|
|
(last line index - 1) for symbols.
|
|
So we first check the line [0], then start a loop
|
|
from 1 to (last line index - 1)
|
|
*/
|
|
firstLineNums := renum.FindAllStringIndex(lines[0], -1)
|
|
firstLineSymbolsIndex := resym.FindAllStringIndex(lines[0], -1)
|
|
secondLineSymbolsIndex := resym.FindAllStringIndex(lines[1], -1)
|
|
// For every *number index range*, check if in the same line there is a
|
|
// symbol on (first - 1) or (last + 1), check in other lines if there is
|
|
// a symbol in a specific interval of numbers. If you find a match, you
|
|
// can break as you just need one symbol
|
|
for i := range firstLineNums {
|
|
for j := range firstLineSymbolsIndex {
|
|
if firstLineSymbolsIndex[j][0] >= firstLineNums[i][0] - 1 &&
|
|
(firstLineSymbolsIndex[j][0] <= firstLineNums[i][1]) {
|
|
totalSum += numbers[0][i]
|
|
break
|
|
}
|
|
}
|
|
for j := range secondLineSymbolsIndex {
|
|
if (secondLineSymbolsIndex[j][0] >= firstLineNums[i][0] - 1) &&
|
|
(secondLineSymbolsIndex[j][0] <= firstLineNums[i][1]) {
|
|
totalSum += numbers[0][i]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
// Now we loop from 1 to (last index - i)
|
|
for i := 1; i < len(lines) - 1; i++ {
|
|
// We need to check the current line against an interval of three lines
|
|
// breaking the loop for a single number as soon as we find a match
|
|
// (we don't want duplicate matches)
|
|
currentLineNums := renum.FindAllStringIndex(lines[i], -1)
|
|
previousLineIndex := resym.FindAllStringIndex(lines[i - 1], -1)
|
|
currentLineIndex := resym.FindAllStringIndex(lines[i], -1)
|
|
nextLineIndex := resym.FindAllStringIndex(lines[i + 1], -1)
|
|
OuterLoop:
|
|
for k := range currentLineNums {
|
|
for j := range previousLineIndex {
|
|
if previousLineIndex[j][0] >= currentLineNums[k][0] - 1 &&
|
|
previousLineIndex[j][0] <= currentLineNums[k][1] {
|
|
totalSum += numbers[i][k]
|
|
continue OuterLoop
|
|
}
|
|
}
|
|
for j := range currentLineIndex {
|
|
if currentLineIndex[j][0] >= currentLineNums[k][0] - 1 &&
|
|
currentLineIndex[j][0] <= currentLineNums[k][1] {
|
|
totalSum += numbers[i][k]
|
|
continue OuterLoop
|
|
}
|
|
}
|
|
for j := range nextLineIndex {
|
|
if nextLineIndex[j][0] >= currentLineNums[k][0] - 1 &&
|
|
nextLineIndex[j][0] <= currentLineNums[k][1] {
|
|
totalSum += numbers[i][k]
|
|
continue OuterLoop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Now we need to loop the last line and confront it with previous
|
|
// and itself
|
|
lastLineNums := renum.FindAllStringIndex(lines[len(lines) - 1], -1)
|
|
lastLineSymbolsIndex := resym.FindAllStringIndex(lines[len(lines) - 1], -1)
|
|
notLastLineSymbolsIndex := resym.FindAllStringIndex(lines[len(lines) - 2], -1)
|
|
// For every *number index range*, check if in the same line there is a
|
|
// symbol on (last - 1) or (last + 1), check in other lines if there is
|
|
// a symbol in a specific interval of numbers. If you find a match, you
|
|
// can break as you just need one symbol
|
|
for i := range lastLineNums {
|
|
for j := range lastLineSymbolsIndex {
|
|
if lastLineSymbolsIndex[j][0] >= lastLineNums[i][0] - 1 &&
|
|
(lastLineSymbolsIndex[j][0] <= lastLineNums[i][1]) {
|
|
totalSum += numbers[len(lines) - 1][i]
|
|
break
|
|
}
|
|
}
|
|
for j := range notLastLineSymbolsIndex {
|
|
if (notLastLineSymbolsIndex[j][0] >= lastLineNums[i][0] - 1) &&
|
|
(notLastLineSymbolsIndex[j][0] <= lastLineNums[i][1]) {
|
|
totalSum += numbers[len(lines) - 1][i]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
fmt.Printf("The total sum is: %d\n", totalSum)
|
|
CheckGears(lines)
|
|
}
|