🌟 Advent of Code (AoC) 2022 🌟

-- The program expects the input on stdin, ie
-- $ ./solve < input

main = interact solve

solve :: String -> String
solve input = "Problem 1: " ++ show p1 ++ "\n"
           ++ "Problem 2: " ++ show p2 ++ "\n"
    where p1 = length (filter fullOverlap intervals)
          p2 = length (filter partialOverlap intervals)
          intervals = map getIntervals (lines input)

fullOverlap :: (Int, Int, Int, Int) -> Bool
fullOverlap (a, b, c, d)
    | (a <= c && b >= d) || (a >= c && b <= d) = True
    | otherwise = False

partialOverlap :: (Int, Int, Int, Int) -> Bool
partialOverlap (a, b, c, d)
    | (b < c) || (a > d) = False
    | otherwise = True

getIntervals :: String -> (Int, Int, Int, Int)
getIntervals s = (a, b, c, d)
    where (a, b) = parseInterval (takeWhile (/=',') s)
          (c, d) = parseInterval (tail (dropWhile (/=',') s))
          parseInterval = (\s -> (
              read (takeWhile (/='-') s),
              read (tail (dropWhile (/='-') s))))

a b←1 0 1 0⊂↑⍎¨¨'\d+'⎕S'&'¨⊃⎕NGET'4.txt' 1
+/0≥×/a-b 		⍝ del1
+/0≥×/a-⌽b		⍝ del2

'\d+'⎕S'&'¨⊃⎕NGET'4.txt'1

↑⍎¨¨'\d+'⎕S'&'¨⊃⎕NGET'4.txt'1

1 0 1 0⊂↑⍎¨¨'\d+'⎕S'&'¨⊃⎕NGET'4.txt' 1

a b←1 0 1 0⊂↑⍎¨¨'\d+'⎕S'&'¨⊃⎕NGET'4.txt' 1

a-b

×/a-b

0≥×/a-b

+/0≥×/a-b

+/0≥×/a-⌽b

def day4(as: Array[Short], bs: Array[Short], cs: Array[Short], ds: Array[Short]): (Int, Int) =
   val spec = ShortVector.SPECIES_PREFERRED
   val sz = as.length
   var i = 0
   var acc1v = ShortVector.zero(spec)
   var acc2v = ShortVector.zero(spec)
   while i < spec.loopBound(sz) do
      val av = ShortVector.fromArray(spec, as, i)
      val bv = ShortVector.fromArray(spec, bs, i)
      val cv = ShortVector.fromArray(spec, cs, i)
      val dv = ShortVector.fromArray(spec, ds, i)
      acc1v = acc1v.add(av.sub(bv).mul(bv.sub(dv)).compare(LE, 0).toVector.abs())
      acc2v = acc2v.add(av.sub(dv).mul(bv.sub(cv)).compare(LE, 0).toVector.abs())
      i += spec.length()
   var acc1s = 0
   var acc2s = 0
   while i < sz do
      if (as(i) - cs(i)) * (bs(i) - ds(i)) <= 0 then acc1s += 1
      if (as(i) - ds(i)) * (bs(i) - cs(i)) <= 0 then acc2s += 1
      i += 1
   (acc1v.reduceLanes(ADD) + acc1s, acc2v.reduceLanes(ADD) + acc2s)

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	var elf []int
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	inputArray := strings.Split(inputString, "\n\n")
	for i := 1; i <= len(inputArray); i++ {
		var elfCal int
		calories := strings.Split(inputArray[i-1], "\n")
		for j := 0; j < len(calories); j++ {
			calInt, _ := strconv.Atoi(calories[j])
			elfCal += calInt
		}
		elf = append(elf, elfCal)
		elfCal = 0
	}
	maxElf := 0
	for i := 0; i < len(elf); i++ {
		if elf[i] > maxElf {
			maxElf = elf[i]
		}
	}
	fmt.Println(maxElf)
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	var elf []int
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	inputArray := strings.Split(inputString, "\n\n")
	for i := 1; i <= len(inputArray); i++ {
		var elfCal int
		calories := strings.Split(inputArray[i-1], "\n")
		for j := 0; j < len(calories); j++ {
			calInt, _ := strconv.Atoi(calories[j])
			elfCal += calInt
		}
		elf = append(elf, elfCal)
		elfCal = 0
	}
	maxElf := 0
	secondElf := 0
	thirdElf := 0
	for i := 0; i < len(elf); i++ {
		if elf[i] > maxElf {
			maxElf = elf[i]
		}
	}
	for i := 0; i < len(elf); i++ {
		if elf[i] > secondElf && elf[i] < maxElf {
			secondElf = elf[i]
		}
	}
	for i := 0; i < len(elf); i++ {
		if elf[i] > thirdElf && elf[i] < secondElf {
			thirdElf = elf[i]
		}
	}
	topThree := maxElf + secondElf + thirdElf
	fmt.Println(topThree)
}

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	rounds := strings.Split(inputString, "\n")
	var score int
	for i := 0; i < len(rounds); i++ {
		oponent := rounds[i][0]
		mine := rounds[i][2]
		switch mine {
		//I throw rock
		case 'X':
			score += 1
		//I throw paper
		case 'Y':
			score += 2
		//I throw scissors
		case 'Z':
			score += 3
		}
		switch oponent {
		//They throw Rock
		case 'A':
			if mine == 'X' {
				score += 3
			}
			if mine == 'Y' {
				score += 6
			}
			if mine == 'Z' {
				score += 0
			}
			//They throw Paper
		case 'B':
			if mine == 'X' {
				score += 0
			}
			if mine == 'Y' {
				score += 3
			}
			if mine == 'Z' {
				score += 6
			}
			//They throw Scissors
		case 'C':
			if mine == 'X' {
				score += 6
			}
			if mine == 'Y' {
				score += 0
			}
			if mine == 'Z' {
				score += 3
			}
		}
	}
	fmt.Println(score)
}

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	rounds := strings.Split(inputString, "\n")
	var score int
	for i := 0; i < len(rounds); i++ {
		oponent := rounds[i][0]
		mine := rounds[i][2]
		switch mine {
		//I throw rock
		case 'X':
			score += 0
		//I throw paper
		case 'Y':
			score += 3
		//I throw scissors
		case 'Z':
			score += 6
		}
		switch oponent {
		//They throw Rock
		case 'A':
			if mine == 'X' {
				score += 3
			}
			if mine == 'Y' {
				score += 1
			}
			if mine == 'Z' {
				score += 2
			}
			//They throw Paper
		case 'B':
			if mine == 'X' {
				score += 1
			}
			if mine == 'Y' {
				score += 2
			}
			if mine == 'Z' {
				score += 3
			}
			//They throw Scissors
		case 'C':
			if mine == 'X' {
				score += 2
			}
			if mine == 'Y' {
				score += 3
			}
			if mine == 'Z' {
				score += 1
			}
		}
	}
	fmt.Println(score)
}

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	var backpacks []string
	var priority int
	//take input from file and make it a string
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	//split input into each elfs calories
	backpacks = strings.Split(inputString, "\n")
	for i := 0; i < len(backpacks); i++ {
		var prio int
		comp1 := backpacks[i][0 : len(backpacks[i])/2]
		comp2 := backpacks[i][len(backpacks[i])/2:]
		for _, ch := range comp1 {
			if strings.Contains(comp2, string(ch)) {
				if ch > 97 {
					prio = int(ch)
					prio -= 96
				} else {
					prio = int(ch)
					prio -= 38
				}
			}
		}
		priority += prio
	}
	fmt.Println(priority)
}

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	var backpacks []string
	var priority int
	iterations := 0
	compare := 1
	//take input from file and make it a string
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	//split input into each elfs calories
	backpacks = strings.Split(inputString, "\n")
	for i := 0; i < len(backpacks); i += 3 {
		var prio int
		for _, ch := range backpacks[i] {
			if string(ch) == "g" {
			}
			if strings.Contains(backpacks[i+1], string(ch)) {
				if strings.Contains(backpacks[i+2], string(ch)) {
					if ch > 97 {
						prio = int(ch)
						prio -= 96
					} else {
						prio = int(ch)
						prio -= 38
					}
					break
				}
			}
		}
		priority += prio
		compare++
		if compare >= 3 {
			compare = 1
		}
		iterations++
	}
	fmt.Println(priority)
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	counter := 0
	//take input from file and make it a string
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	pairs := strings.Split(inputString, "\n")
	for i := 0; i < len(pairs); i++ {
		elfs := strings.Split(pairs[i], ",")
		elfOneStart, _ := strconv.Atoi(strings.Split(elfs[0], "-")[0])
		elfOneEnd, _ := strconv.Atoi(strings.Split(elfs[0], "-")[1])
		elfTwoStart, _ := strconv.Atoi(strings.Split(elfs[1], "-")[0])
		elfTwoEnd, _ := strconv.Atoi(strings.Split(elfs[1], "-")[1])
		if (elfOneStart <= elfTwoStart && elfOneEnd >= elfTwoEnd) || (elfTwoStart <= elfOneStart && elfTwoEnd >= elfOneEnd) {
			counter++
		}
	}
	fmt.Println(counter)
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	counter := 0
	//take input from file and make it a string
	input, _ := os.ReadFile("../input.txt")
	inputString := string(input)
	pairs := strings.Split(inputString, "\n")
	for i := 0; i < len(pairs); i++ {
		elfOneStart, _ := strconv.Atoi(strings.Split(strings.Split(pairs[i], ",")[0], "-")[0])
		elfOneEnd, _ := strconv.Atoi(strings.Split(strings.Split(pairs[i], ",")[0], "-")[1])
		elfTwoStart, _ := strconv.Atoi(strings.Split(strings.Split(pairs[i], ",")[1], "-")[0])
		elfTwoEnd, _ := strconv.Atoi(strings.Split(strings.Split(pairs[i], ",")[1], "-")[1])
		if (elfOneStart <= elfTwoStart && elfOneEnd >= elfTwoStart) || (elfTwoStart <= elfOneStart && elfTwoEnd >= elfOneStart) {
			counter++
		}
	}
	fmt.Println(counter)
}

include prelude, strscans, algorithm

proc crateNumber(indent: int): int =
  indent div 4

proc readInput*(input: string): tuple[stack: seq[seq[char]], instructions: seq[tuple[start, to, amount: int]]] =
  result.stack = newSeq[seq[char]](9)
  for line in input.splitLines:
    if '[' in line:
      # crate
      for i, c in line:
        if c == '[':
          let crate = crateNumber(i)
          result.stack[crate].add line[i+1]
    elif line.startsWith("move"):
      # move
      var instr: tuple[start, to, amount: int]
      assert scanf(line, "move $i from $i to $i", instr.amount, instr.start, instr.to)
      # zero-index adjust
      instr.start -= 1
      instr.to -= 1
      result.instructions.add instr
      
  # reverse stacks
  for i in 0 .. result.stack.high:
    result.stack[i].reverse()
      
proc part1(input: string) =
  var (stack, instructions) = readInput(input)
  for (start, to, amount) in instructions:
    for i in 0 ..< amount:
      stack[to].add stack[start].pop()

  var answer: seq[char]
  for s in stack:
    answer.add s[^1]

  echo "Part 1: ", answer.join("")

proc part2(input: string) =
  var (stack, instructions) = readInput(input)
  for (start, to, amount) in instructions:
    let movedCrates = stack[start][^amount .. ^1]
    stack[start].setLen(stack[start].len - amount)
    stack[to].add movedCrates

  var answer: seq[char]
  for s in stack:
    answer.add s[^1]

  echo "Part 2: ", answer.join("")

when isMainModule:
  let input = readFile("input.txt")
  part1(input)
  part2(input)

with open('Day5/data.txt') as file:
    data = file.readlines()

stack = data[0:8]
moves = data[10:]

stack_list = [""] * len(max(stack, key=len))

for line in stack:
    line_clean = line.strip()
    for n, letter in enumerate(line_clean):
        if 'A' <= letter <= 'Z':
            stack_list[n] = stack_list[n] + letter

while '' in stack_list:
    stack_list.remove('')

stack_list2 = stack_list.copy()  # For second half of puzzle

moves_list = []
for text_moves in moves:
    moves_list.append([int(s) for s in text_moves.split() if s.isdigit()])


def rearrange_crate(stack_remove, stack_add, n_moves):
    for move in range(n_moves):
        stack_add = stack_remove[0] + stack_add
        stack_remove = stack_remove[1:]
    return stack_remove, stack_add


def print_answer(stacks):
    answer = ''
    for stack in stacks:
        answer = answer + stack[0]
    print(answer)


for move in moves_list:
    new_stacks = rearrange_crate(stack_list[move[1] - 1], stack_list[move[2] - 1], move[0])
    stack_list[move[1] - 1] = new_stacks[0]
    stack_list[move[2] - 1] = new_stacks[1]

print_answer(stack_list)  # Print first answer


def rearrange_crate_9001(stack_remove, stack_add, n_moves):
    stack_add = stack_remove[0:n_moves] + stack_add
    stack_remove = stack_remove[n_moves:]
    return stack_remove, stack_add


for move in moves_list:
    new_stacks = rearrange_crate_9001(stack_list2[move[1] - 1], stack_list2[move[2] - 1], move[0])
    stack_list2[move[1] - 1] = new_stacks[0]
    stack_list2[move[2] - 1] = new_stacks[1]

print_answer(stack_list2)  # Print second answer

public class DayFive {
	public static void main(String[] args) {
	List<String> crates = new ArrayList<>();
	List<String> instructions = new ArrayList<>();
	
	try {  
		File file = new File("C:\\AoC 22\\inputDay5.txt");
		FileReader filereader = new FileReader(file);
		BufferedReader bufferedreader = new BufferedReader(filereader);
			String line;  
		while((line = bufferedreader.readLine()) != null) {  
			if(line.contains("move"))
				instructions.add(line);
			else
				crates.add(line);
		}
		filereader.close();
	} catch(IOException e) { 
			e.printStackTrace();
	}
	List<Stack<Character>> stackList = new ArrayList<>();
	Stack<Character> one = new Stack<>();
	Stack<Character> two = new Stack<>();
	Stack<Character> three = new Stack<>();
	Stack<Character> four = new Stack<>();
	Stack<Character> five = new Stack<>();
	Stack<Character> six = new Stack<>();
	Stack<Character> seven = new Stack<>();
	Stack<Character> eight = new Stack<>();
	Stack<Character> nine = new Stack<>();
	stackList.add(one);
	stackList.add(two);
	stackList.add(three);
	stackList.add(four);
	stackList.add(five);
	stackList.add(six);
        stackList.add(seven);
	stackList.add(eight);
	stackList.add(nine);
	
	for(int i = crates.size()-1; i >= 0; i--) {
		String temp = crates.get(i);
		for(int j = 0; j <= temp.length()-1; j++) {
		     if(Character.isAlphabetic(temp.charAt(j)) && !Character.isDigit(temp.charAt(j))) {
        		   if(j == 1)
	         		one.push(temp.charAt(j));
			    else if(j == 5)
				two.push(temp.charAt(j));
		             else if(j == 9)
				  three.push(temp.charAt(j));
			      else if(j == 13)
				   four.push(temp.charAt(j));
				else if(j == 17)
			            five.push(temp.charAt(j));
				else if(j == 21)
				      six.push(temp.charAt(j));
				else if(j == 25)
				      seven.push(temp.charAt(j));
				else if(j == 29)
					eight.push(temp.charAt(j));
				else if(j == 33)
					nine.push(temp.charAt(j));
			}
		}
	}
	List<String> instructionsclean = new ArrayList<>();
	for(int i = 0; i < instructions.size(); i++) {
		String temp = instructions.get(i);
		temp = temp.replace("move ", "");
		temp = temp.replace("from ", "");
		temp = temp.replace("to ", "");
		instructionsclean.add(temp);
	}	
	for(int i = 0; i < instructionsclean.size(); i++) {
		String temp = instructionsclean.get(i);
		int move = Integer.parseInt(temp.substring(0, temp.indexOf(' ')));
		int from = Integer.parseInt(temp.substring(temp.indexOf(' ')+1, temp.indexOf(' ')+2));
		int to = Integer.parseInt(temp.substring(temp.indexOf(' ')+3, temp.length()));
			
		for(int m = 1; m <= move; m++) {
			char chara = stackList.get(from-1).pop();
			stackList.get(to-1).push(chara);
		}
	}
	System.out.println("part one: " + stackList.get(0).peek() + " " + stackList.get(1).peek() + " " + stackList.get(2).peek()
			 + " " + stackList.get(3).peek() + " " + stackList.get(4).peek() + " " + stackList.get(5).peek()
			 + " " + stackList.get(6).peek() + " " + stackList.get(7).peek() + " " + stackList.get(8).peek());
/*
 * resetting stacks
*/
	stackList.get(0).removeAllElements();
	stackList.get(1).removeAllElements();
	stackList.get(2).removeAllElements();
	stackList.get(3).removeAllElements();
	stackList.get(4).removeAllElements();
	stackList.get(5).removeAllElements();
	stackList.get(6).removeAllElements();
	stackList.get(7).removeAllElements();
	stackList.get(8).removeAllElements();
	
	for(int i = crates.size()-1; i >= 0; i--) {
		String temp = crates.get(i);
		for(int j = 0; j <= temp.length()-1; j++) {
			if(Character.isAlphabetic(temp.charAt(j)) && !Character.isDigit(temp.charAt(j))) {
				if(j == 1)
					one.push(temp.charAt(j));
				else if(j == 5)
					two.push(temp.charAt(j));
				else if(j == 9)
					three.push(temp.charAt(j));
				else if(j == 13)
					four.push(temp.charAt(j));
				else if(j == 17)
					five.push(temp.charAt(j));
				else if(j == 21)
					six.push(temp.charAt(j));
				else if(j == 25)
					seven.push(temp.charAt(j));
				else if(j == 29)
					eight.push(temp.charAt(j));
				else if(j == 33)
					nine.push(temp.charAt(j));
			}
		}
	}
	for(int i = 0; i < instructionsclean.size(); i++) {
		String temp = instructionsclean.get(i);
		int move = Integer.parseInt(temp.substring(0, temp.indexOf(' ')));
		int from = Integer.parseInt(temp.substring(temp.indexOf(' ')+1, temp.indexOf(' ')+2));
		int to = Integer.parseInt(temp.substring(temp.indexOf(' ')+3, temp.length()));
		List<Character> tempList = new ArrayList<>();
		for(int m = 1; m <= move; m++) {
			char chara = stackList.get(from-1).remove(stackList.get(from-1).size()-1);
			tempList.add(chara);
		}
		for(int k = tempList.size()-1; k >= 0; k--) 	
			stackList.get(to-1).push(tempList.get(k));
		tempList.clear();
	}
	System.out.println("part two: " + stackList.get(0).peek() + " " + stackList.get(1).peek() + " " + stackList.get(2).peek()
			 + " " + stackList.get(3).peek() + " " + stackList.get(4).peek() + " " + stackList.get(5).peek()
			 + " " + stackList.get(6).peek() + " " + stackList.get(7).peek() + " " + stackList.get(8).peek());
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

type Instruction struct {
	Count int
	From  int
	To    int
}

func getResult(crateStacks [][]rune) string {
	result := ""
	for _, stack := range crateStacks {
		result += string(stack[len(stack)-1:])
	}
	return result
}

func reverse(r []rune) {
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
}

func moveCrates(crateStacks [][]rune, instructions []Instruction, preservePickOneByOneOrder bool) {
	for _, inst := range instructions {
		fromStack := crateStacks[inst.From]
		stackIndex := len(fromStack) - inst.Count
		lastCrates := fromStack[stackIndex:]            // get last
		crateStacks[inst.From] = fromStack[:stackIndex] // remove last
		if preservePickOneByOneOrder {
			reverse(lastCrates)
		}
		crateStacks[inst.To] = append(crateStacks[inst.To], lastCrates...)
	}
}

func getPartOne(crateStacks [][]rune, instructions []Instruction) string {
	moveCrates(crateStacks, instructions, true)
	result := getResult(crateStacks)
	return result
}

func getPartTwo(crateStacks [][]rune, instructions []Instruction) string {
	moveCrates(crateStacks, instructions, false)
	result := getResult(crateStacks)
	return result
}

func getRows(filename string) ([][]rune, []Instruction) {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	crateStacks := make([][]rune, 0)
	instructions := make([]Instruction, 0)
	for scanner.Scan() {
		row := scanner.Text()
		if strings.Contains(row, "[") {
			for i := 1; i < len(row); i += 4 {
				j := (i - 1) / 4
				if j+1 > len(crateStacks) {
					crateStacks = append(crateStacks, make([]rune, 0))
				}
				if string(row[i]) != " " {
					crateStacks[j] = append(crateStacks[j], int32(row[i]))
				}
			}
		} else if strings.Contains(row, "move") {
			var inst Instruction
			fmt.Sscanf(row, "move %d from %d to %d",
				&inst.Count, &inst.From, &inst.To)
			inst.From -= 1
			inst.To -= 1
			instructions = append(instructions, inst)
		}
	}
	// Reverse the crateStack
	for _, crateStack := range crateStacks {
		reverse(crateStack)
	}
	return crateStacks, instructions
}

func main() {
	fmt.Println("Part one:", getPartOne(getRows("../input.txt")))
	fmt.Println("Part two:", getPartTwo(getRows("../input.txt")))
}

val input = Using.resource(Source.fromFile("""5.txt"""))(_.getLines().toVector)
val (crates, moves) = input.span(_ != "")

val crates2 = crates.map(str => (1 to str.length by 4).map(str)).transpose.map(_.dropWhile(_ == ' ').init)

moves.foldLeft(crates2) { (state, move) =>
   move match
      case s"move $amount from $from to $to" =>
         val (fst, snd) = state(from.toInt - 1).splitAt(amount.toInt)
         state.updated(from.toInt - 1, snd).updated(to.toInt - 1, fst.reverse ++ state(to.toInt - 1))
      case _ => state
}.map(_.head).mkString

moves.foldLeft(crates2) { (state, move) =>
   move match
      case s"move $amount from $from to $to" =>
         val (fst, snd) = state(from.toInt - 1).splitAt(amount.toInt)
         state.updated(from.toInt - 1, snd).updated(to.toInt - 1, fst ++ state(to.toInt - 1))
      case _ => state
}.map(_.head).mkString

-- The program expects the input on stdin, ie
-- $ ./solve < input
import Data.Char (isDigit, isUpper)

main = interact solve

solve :: String -> String
solve input = "Problem 1: " ++ show (map head finalCratesPt1) ++ "\n"
           ++ "Problem 2: " ++ show (map head finalCratesPt2) ++ "\n"
    where finalCratesPt1 = foldr doMovePt1 crates moves
          finalCratesPt2 = foldr doMovePt2 crates moves
          crates = filter (not.null) (map (filter isUpper) (transpose cratesInput))
          moves = reverse (map readMove (filter (not.null) movesInput))
          (cratesInput, movesInput) = break null (lines input)

-- Some types for readability.
data Move = Move {num::Int, from::Int, to::Int} deriving (Show)
type Crates = [String]
type Stack = String

transpose :: [[a]] -> [[a]]
transpose ([]:_) = []
transpose x = (map head x) : transpose (map tail x)

-- Parse the strings from the problem input.
readMove :: String -> Move
readMove s = Move a b c
    where a = read (takeWhile isDigit (dropWhile (not.isDigit) s))
          b = read (takeWhile isDigit (dropWhile (not.isDigit) (dropWhile isDigit (dropWhile (not.isDigit) s))))
          c = read (takeWhile isDigit (dropWhile (not.isDigit) (dropWhile isDigit (dropWhile (not.isDigit) (dropWhile isDigit (dropWhile (not.isDigit) s))))))

-- Remove a number of crates from a specific target stack.
popStack :: Move -> Crates -> (Crates, Stack)
popStack move crates = (before ++ [remaining] ++ after, removed)
    where (before, target:after) = splitAt ((from move)-1) crates
          (removed, remaining) = splitAt (num move) target

-- Place a number of crates on a specific target stack.
pushStack :: Move -> Stack -> Crates -> Crates
pushStack move moved crates = before ++ [moved ++ target] ++ after
    where (before, target:after) = splitAt ((to move)-1) crates

-- Perform a move while reversing the crates, for part 1.
doMovePt1 :: Move -> Crates -> Crates
doMovePt1 move crates = pushStack move (reverse moved) crates_
    where (crates_, moved) = popStack move crates

-- Perform a move, without reversing the crates, for part 2.
doMovePt2 :: Move -> Crates -> Crates
doMovePt2 move crates = pushStack move moved crates_
    where (crates_, moved) = popStack move crates

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

func getMoves(input string) (int, []string) {
	var crateRows int
	//Count on which row there's a double linebreak
	for i, ch := range input {
		if ch == '\n' && input[i+1] != '\n' {
			crateRows++
		}
		if ch == '\n' && input[i+1] == '\n' {
			break
		}
	}
	//Return number of rows and the moves
	moves := strings.Split(input, "\n")[crateRows+2:]
	return crateRows, moves
}

// Function to get the letters from each "crate"
func splitToStacks(input string, crateRows int) [][]string {
	rows := strings.Split(input, "\n")[0:crateRows]
	crateRow := strings.Split(input, "\n")[crateRows]
	numCrates, _ := strconv.Atoi(string(crateRow[len(crateRow)-2]))
	stacks := make([][]string, numCrates+1)
	for i := len(rows) - 1; i >= 0; i-- {
		k := 1
		for j := 1; j < len(rows[0])-1; j += 4 {
			if string(rows[i][j]) != " " {
				stacks[k] = append(stacks[k], string(rows[i][j]))
			}
			k++
		}
	}
	return stacks
}

func splitMoves(moves []string) [][]int {
	toret := make([][]int, len(moves))
	for i := 0; i < len(moves); i++ {
		//Split each move into numbers
		move := strings.Split(moves[i], " ")
		tempNum, _ := strconv.Atoi(move[1])
		tempFrom, _ := strconv.Atoi(move[3])
		tempTo, _ := strconv.Atoi(move[5])
		//Save the numbers to an array
		toret[i] = append(toret[i], tempNum)
		toret[i] = append(toret[i], tempFrom)
		toret[i] = append(toret[i], tempTo)
	}
	return toret
}
func MakeMoves1(stacks [][]string, moves [][]int) [][]string {
	for i := 0; i < len(moves); i++ {
		num := moves[i][0]
		from := moves[i][1]
		to := moves[i][2]
		//Move the correct number of letters from the "from" stack to the "to" stack
		for j := 0; j < num; j++ {
			stacks[to] = append(stacks[to], stacks[from][len(stacks[from])-1])
			stacks[from] = stacks[from][:len(stacks[from])-1]
		}
	}
	return stacks
}

func MakeMoves2(stacks [][]string, moves [][]int) [][]string {
	for i := 0; i < len(moves); i++ {
		num := moves[i][0]
		from := moves[i][1]
		to := moves[i][2]
		//Move letters from the "from" stack to the "to" stack in batches on "num"
		stacks[to] = append(stacks[to], stacks[from][len(stacks[from])-num:]...)
		stacks[from] = stacks[from][:len(stacks[from])-num]
	}
	return stacks
}

func printLast(stacks [][]string) {
	for i := 1; i < len(stacks); i++ {
		fmt.Print(stacks[i][len(stacks[i])-1])
	}
}
func main() {
	input, _ := os.ReadFile("input.txt")
	inputString := string(input)
	//Find separator between crates and moves
	crateRows, tempmoves := getMoves(inputString)
	//Get the crate letters into an array per collumn
	stacks := splitToStacks(inputString, crateRows)
	//Split moverows into pure numbers
	moves := splitMoves(tempmoves)
	//Create stack for first method
	stacks1 := MakeMoves1(stacks, moves)
	//Need to recreate stacks because MakeMoves1 changes the original
	stacks = splitToStacks(inputString, crateRows)
	//Create stack for second method
	stacks2 := MakeMoves2(stacks, moves)
	//Print last element of each stack
	printLast(stacks1)
	fmt.Println()
	printLast(stacks2)
}

using AOC.Helpers.Extensions;
using System.Text.RegularExpressions;

namespace AOC2022.Puzzles;

internal partial class Puzzle5 : Puzzle<string>
{
    [GeneratedRegex(@move (\d+) from (\d+) to (\d+))] private static partial Regex InstructionRegex();
    [GeneratedRegex(@\[(.)\])] private static partial Regex CrateRegex();

    protected override void Solve(string[] lines)
    {
        One = SetupAndMoveCrates(lines, false);
        Two = SetupAndMoveCrates(lines, true);
    }

    private static string SetupAndMoveCrates(string[] lines, bool moveAsGroup)
    {
        var idx = lines.ToList().FindIndex(string.IsNullOrWhiteSpace);
        var crateLines = lines[..idx];
        var instructions = lines[(idx + 1)..];

        var stacks = Enumerable.Range(0, crateLines.Last().Last(char.IsDigit) - '0')
            .Select((x, stackIdx) => new Stack<char>(crateLines.Reverse().Skip(1)
                .Select(crateLine => crateLine
                    .Chunk(4)
                    .Skip(stackIdx)
                    .Select(crateStr => CrateRegex().Match(string.Concat(crateStr))
                        .Groups.Values.Last().Value.FirstOrDefault())
                    .FirstOrDefault())
                .Where(x => x > 0)))
            .ToArray();
        
        MoveCrates(instructions, stacks, moveAsGroup);
        return string.Concat(stacks.Select(x => x.Peek()));
    }

    private static void MoveCrates(IEnumerable<string> instructions, Stack<char>[] stacks, bool moveAsGroup)
    {
        foreach (var instruction in instructions)
        {
            var values = InstructionRegex().Match(instruction).Groups.Values
                .Skip(1).Select(x => int.Parse(x.Value)).ToList();
            var (amount, from, to) = (values[0], values[1], values[2]);
            var crates = Enumerable.Range(0, amount).Select(_ => stacks[from - 1].Pop());
            if (moveAsGroup) crates = crates.Reverse();
            stacks[to - 1].PushRange(crates);
        }
    }
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))

#define MAX_CRATES	128
#define MAX_PILES	9

struct pile {
	char c[MAX_CRATES];
	int n;
};

struct pile p[MAX_PILES];
struct pile p2[MAX_PILES];

void parsePiles(char *line, ssize_t len) {
	int idx = 0, chr = 0;

	while(++chr < len) {
		if (line[chr] == ' ') {
			idx++;
			chr += 3;
			continue;
		}
		memmove(p[idx].c+1, p[idx].c, p[idx].n);
		p[idx].c[0] = line[chr];
		p[idx].n++;
		idx++;
		chr+=3;
	}
}

void doMoves(char *line) {
	int n, from, to;

	if (sscanf(line, "move %d from %d to %d\n", &n, &from, &to) != 3)
		exit(EXIT_FAILURE);

	from--;
	to--;

	// Part 1
	for (int i=0; i<n; i++)
		p[to].c[p[to].n++] = p[from].c[--p[from].n];

	// Part 2
	p2[from].n -= n;
	memcpy(&p2[to].c[p2[to].n], &p2[from].c[p2[from].n], n);
	p2[to].n += n;
}

int main(void) {
	char *line = NULL;
	size_t len = 0;
	ssize_t nread;

	FILE *fp = fopen("d5_input.txt", "r");
	if (!fp) {
		perror("Failed to open file");
		exit(EXIT_FAILURE);
	}

	while ((nread = getline(&line, &len, fp)) != -1) {
		if (!strcmp(line, "\n"))
			break;
		if (strncmp(line, "   ", 3) && strncmp(line, "[", 1))
			continue;
		parsePiles(line, nread);
	}
	memcpy(p2, p, sizeof(p));

	while ((nread = getline(&line, &len, fp)) != -1)
		doMoves(line);

	printf("Answer string for part 1: ");
	for (int i=0; i<ARRAY_LEN(p); i++)
		putchar(p[i].c[p[i].n-1]);
	putchar('\n');

	printf("Answer string for part 2: ");
	for (int i=0; i<ARRAY_LEN(p2); i++)
		putchar(p2[i].c[p2[i].n-1]);
	putchar('\n');

	free(line);
	fclose(fp);

	exit(EXIT_SUCCESS);
}