README.md

@@ -8,7 +8,6 @@ An attempt to start programming again.
 - [Day 4](./day04/scratchcards.go)
 - [Day 5](./day05/seeds.go)
 - [Day 6](./day06/race.go)
-- [Day 7](./day07/cards.go)
 
 
 This repo gets automatically mirrored to [Github](https://github.com/Doddophonique/aoc2023).

day07/cards.go

@@ -1,366 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"math"
-	"strings"
-	"os"
-	"strconv"
-	"sync"
-)
-
-var mapSeedsFirst = map[string]int{
-	"A": 12,
-	"K": 11,
-	"Q": 10,
-	"J": 9,
-	"T": 8,
-	"9": 7,
-	"8": 6,
-	"7": 5,
-	"6": 4,
-	"5": 3,
-	"4": 2,
-	"3": 1,
-	"2": 0,
-}
-
-var mapSeedsSecond = map[string]int{
-	"A": 12,
-	"K": 11,
-	"Q": 10,
-	"T": 9,
-	"9": 8,
-	"8": 7,
-	"7": 6,
-	"6": 5,
-	"5": 4,
-	"4": 3,
-	"3": 2,
-	"2": 1,
-	"J": 0,
-}
-
-type Game struct {
-	mu    sync.Mutex
-	ranks []int
-	// 0: High card, 1: One pair, 2: Two pair, 3: Three of a kind
-	// 4: Full house, 5: Four of a kind, 6: Five of a kind
-	typeOfHand   [7][]string
-	indexOfHand  [7][]int
-	baseThirteen [7][]int
-}
-
-func (g *Game) ChangeBase(hType, index int, mapSeeds map[string]int, wg *sync.WaitGroup) {
-	// Starting from the first char [0], we create the base13 num
-	chars := len(g.typeOfHand[hType][index])
-	baseTN := g.typeOfHand[hType][index]
-	decNum := 0
-	for i := 0; i < chars; i++ {
-		// This should be refactored to be a bit more legible
-		// It just computes N * 13^i and adds it over
-		decNum += int(float64(mapSeeds[string(baseTN[i])]) * math.Pow(13, float64(chars-i)))
-	}
-	g.baseThirteen[hType][index] = decNum
-	wg.Done()
-}
-
-func (g *Game) AnalyzeMap(cards string, index, mapSize, offset int) {
-	// The offset defaults to 0 for the regular game
-	// it is +1 for a game with Jokers\
-	mapSeed := mapSeedsFirst
-	if offset != 0 {
-		mapSeed = mapSeedsSecond
-	}
-	switch mapSize {
-	// Five of a kind
-	case 1:
-		g.mu.Lock()
-		g.typeOfHand[6] = append(g.typeOfHand[6], cards)
-		g.indexOfHand[6] = append(g.indexOfHand[6], index)
-		g.mu.Unlock()
-	// Four of a kind || Full House
-	case 2:
-		i := FullOrFour(cards, offset, mapSeed)
-		g.mu.Lock()
-		g.typeOfHand[i] = append(g.typeOfHand[i], cards)
-		g.indexOfHand[i] = append(g.indexOfHand[i], index)
-		g.mu.Unlock()
-	// Three of a kind || Two pair
-	case 3:
-		i := ThreeOrTwo(cards, offset, mapSeed)
-		g.mu.Lock()
-		g.typeOfHand[i] = append(g.typeOfHand[i], cards)
-		g.indexOfHand[i] = append(g.indexOfHand[i], index)
-		g.mu.Unlock()
-	// One pair
-	case 4:
-		g.mu.Lock()
-		g.typeOfHand[1] = append(g.typeOfHand[1], cards)
-		g.indexOfHand[1] = append(g.indexOfHand[1], index)
-		g.mu.Unlock()
-	// High card
-	case 5:
-		g.mu.Lock()
-		g.typeOfHand[0] = append(g.typeOfHand[0], cards)
-		g.indexOfHand[0] = append(g.indexOfHand[0], index)
-		g.mu.Unlock()
-	}
-}
-
-func (g *Game) DetermineType(cards string, index int, wg *sync.WaitGroup) {
-	// We create a map and we check the length. Depending on the length, we
-	// insert the string in a specific type
-	m := make(map[string]int)
-	for i := 0; i < len(cards); i++ {
-		key := string(cards[i])
-		m[key] = mapSeedsFirst[key]
-	}
-	// Now, depending on the number of elements in the map, we can assign
-	// append cards to a specific rank
-	mapSize := len(m)
-	g.AnalyzeMap(cards, index, mapSize, 0)
-
-	wg.Done()
-}
-
-func (g *Game) SecondGame(cards string, index int, wg *sync.WaitGroup) {
-	// If I don't have Js, run the standard DetermineType
-	m := make(map[string]int)
-	n := make(map[string]int)
-	for i := 0; i < len(cards); i++ {
-		key := string(cards[i])
-		// We need to track the number of Js
-		m[key] += 1
-		// This is to track the type of hand, knowing the number of Js
-		n[key] = mapSeedsSecond[key]
-	}
-	mapSize := len(n)
-	switch m["J"] {
-	case 0:
-		// We have a hand without Js
-		wg.Add(1)
-		g.DetermineType(cards, index, wg)
-	case 1:
-		// If there is a J, J can be use is not adding information, therefore -1
-		g.AnalyzeMap(cards, index, (mapSize - 1), 1)
-	case 2:
-		g.AnalyzeMap(cards, index, (mapSize - 1), 2)
-	case 3:
-		g.AnalyzeMap(cards, index, (mapSize - 1), 3)
-	case 4:
-		g.AnalyzeMap(cards, index, (mapSize - 1), 4)
-	case 5:
-		wg.Add(1)
-		g.DetermineType(cards, index, wg)
-	}
-	wg.Done()
-}
-
-func ThreeOrTwo(cards string, offset int, mapSeed map[string]int) int {
-	m := make(map[string]int)
-	for i := 0; i < len(cards); i++ {
-		key := string(cards[i])
-		m[key] += 1
-	}
-	// If we are in the second game, remove J
-	if mapSeed["J"] == 0 {
-		m["J"] = 0
-	}
-	// m[i] returns 0 if the element is not in the map. I take advantage
-	// of that
-	tempNum := 0
-	for i := range mapSeed {
-		if m[i] > tempNum {
-			tempNum = m[i]
-		}
-	}
-	// If an element has 3 values, we have a three of a kind
-	if tempNum+offset == 3 {
-		return 3
-		/// If an element has 2 values, we have a two pair
-	} else if tempNum+offset == 2 {
-		return 2
-	}
-	PrintAndWait("This has run for ", cards)
-	return -1
-}
-func FullOrFour(cards string, offset int, mapSeed map[string]int) int {
-	m := make(map[string]int)
-	for i := 0; i < len(cards); i++ {
-		key := string(cards[i])
-		m[key] += 1
-	}
-	// If we are in the second game, remove J
-	if mapSeed["J"] == 0 {
-		m["J"] = 0
-	}
-	// m[i] returns 0 if the element is not in the map. I take advantage
-	// of that
-	// Better to save the maximum number
-	tempNum := 0
-	for i := range mapSeed {
-		if m[i] > tempNum {
-			tempNum = m[i]
-		}
-	}
-	// If an element has four values, we have a Four of a kind
-	if tempNum+offset == 4 {
-		return 5
-		/// If an element has 3 values, we have a Full House
-	} else if tempNum+offset == 3 {
-		return 4
-	}
-	return -1
-}
-
-func check(e error) {
-	if e != nil {
-		panic(e)
-	}
-}
-
-func PrintAndWait(x ...any) {
-	fmt.Print(x...)
-	fmt.Scanln()
-}
-
-// https://www.golangprograms.com/golang-program-for-implementation-of-quick-sort.html
-// I need to learn how this shing works
-func quicksort(a, h []int, hType int) []int {
-	if len(a) < 2 {
-		return a
-	}
-
-	left, right := 0, len(a)-1
-
-	pivot := 0
-
-	a[pivot], a[right] = a[right], a[pivot]
-	h[pivot], h[right] = h[right], h[pivot]
-
-	for i, _ := range a {
-		if a[i] < a[right] {
-			a[left], a[i] = a[i], a[left]
-			h[left], h[i] = h[i], h[left]
-			left++
-		}
-	}
-
-	a[left], a[right] = a[right], a[left]
-	h[left], h[right] = h[right], h[left]
-
-	quicksort(a[:left], h[:left], hType)
-	quicksort(a[left+1:], h[left+1:], hType)
-
-	return a
-}
-
-func main() {
-
-	file, err := os.Open("./inputs/day7_try")
-	check(err)
-	defer file.Close()
-
-	// Struct for regular game
-	g := Game{}
-	// Struct for the Joker game
-	jo := Game{}
-
-	// Variable where we store every line in the file
-	lines := make([]string, 0)
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
-	}
-	// Array of strings, set of cards
-	var cards []string
-	// Array of int, bet
-	var bet []int
-	// Now, split the lines
-	for i := 0; i < len(lines); i++ {
-		tempString := strings.Split(lines[i], " ")
-		cards = append(cards, tempString[0])
-		tempNum, _ := strconv.Atoi(tempString[1])
-		bet = append(bet, tempNum)
-	}
-	// Rank will be from 1 to len(lines)
-	g.ranks = make([]int, len(lines))
-	jo.ranks = make([]int, len(lines))
-	// What do we know for sure? 5 identical seeds are the highest ranks,
-	// 5 completely different seeds are the lowest ranks.
-	// We can iterate for every set of cards, and do different things
-	// if the map we build has one element, five elements or the worst
-	// case (two, three or four elements).
-	//
-	// Two identical: 	4oK or FH
-	// Three identical: 3oK or 22
-	// Four identical: 	12
-	//
-	// With this, I put every typeOfHand in a different array
-	var wg sync.WaitGroup
-	wg.Add(2 * len(lines))
-	for i := 0; i < len(lines); i++ {
-		g.DetermineType(cards[i], i, &wg)
-		jo.SecondGame(cards[i], i, &wg)
-	}
-
-	wg.Wait()
-	// Now that g.typeOfHand has every type of hand separated, the rank
-	// is determined by the first card(s). I can convert every number
-	// to a base 13 representation and sort.
-	// In g.indexOfHand I have the index of the corresponding type.
-
-	// For every type of hand
-	for i := range g.typeOfHand {
-		// As many wait groups as the element we will iterate
-		wg.Add(len(g.typeOfHand[i]))
-		wg.Add(len(jo.typeOfHand[i]))
-		// We also need to initialize the array g.baseThirteen so we can
-		// keep the same index
-		g.baseThirteen[i] = make([]int, len(g.typeOfHand[i]))
-		jo.baseThirteen[i] = make([]int, len(jo.typeOfHand[i]))
-		// For every element in a single type of hand
-		for j := range g.typeOfHand[i] {
-			g.ChangeBase(i, j, mapSeedsFirst, &wg)
-		}
-		for j := range jo.typeOfHand[i] {
-			jo.ChangeBase(i, j, mapSeedsSecond, &wg)
-		}
-	}
-	wg.Wait()
-
-	// A sort of some kind. Important is to also move the index with the number as
-	// well.
-	for i := range g.baseThirteen {
-		quicksort(g.baseThirteen[i], g.indexOfHand[i], i)
-		quicksort(jo.baseThirteen[i], jo.indexOfHand[i], i)
-	}
-
-	curRank := 1
-	rank := 0
-	// Iter every array
-	for i := range g.typeOfHand {
-		for j := range g.typeOfHand[i] {
-			index := g.indexOfHand[i][j]
-			rank += curRank * bet[index]
-			curRank++
-		}
-	}
-	fmt.Printf("Rank: %d\n", rank)
-
-	curRank = 1
-	rank = 0
-	// Iter every array
-	for i := range jo.typeOfHand {
-		for j := range jo.typeOfHand[i] {
-			index := jo.indexOfHand[i][j]
-			rank += curRank * bet[index]
-			curRank++
-		}
-	}
-	fmt.Printf("Rank: %d\n", rank)
-
-}

day07/inputs

@@ -1 +0,0 @@
-../inputs

inputs/day07_test_input

@@ -1,5 +0,0 @@
-32T3K 765
-T55J5 684
-KK677 28
-KTJJT 220
-QQQJA 483