DEV Community: Cipherlogs

Using only vim to solve AdventOfCode Challenges | Episode 3

Cipherlogs — Sun, 17 Dec 2023 20:34:13 +0000

1. Getting Started

To begin, access today's challenge and carefully read the instructions below before attempting to solve it.

New here? scenario1 and scenario2 might be unfamiliar, these sprints are designed to stretch your limits – you'll need to tackle the problem from both angles, or your solution won't fly. So, if you're content to stay within your comfort zone, this sprint isn't for you. Start with the first episode and give it a go yourself. Spend at least 15 minutes grappling with both scenarios before peeking at the solutions.

Remember, make sure that you are in sync with your team, if you don't have a team yet submit your application here https://forms.gle/bwegPDvbgEuWKDF47

Good luck!

1.1 Rules

In the first scenario, refrain from creating low-level functions that involve iterating through strings to extract duplicated characters. Instead, leverage built-in Vimscript functions creatively or utilize Unix utilities. Alternatively, if achieving the desired results promptly requires a one-liner in a programming language, that approach is acceptable. However, avoid reinventing the wheel; the emphasis is on efficiency in this speed-focused scenario.
In the second scenario, pay attention to the following considerations:

The initial aspect of the challenge involves splitting each line in half. However, the script should be flexible enough to allow for splitting into thirds, quarters, or any other specified interval. Ensure your script is capable of dynamically handling different split configurations.
For the first part of the challenge, when splitting each line into segments of size 'n,' retain only those chunks that match the specified size. For instance, if 'abcdefgh' is split into groups of 3, the desired result should be ['abc', 'def'].
The second part of the challenge focuses on joining lines in groups of 3. Extend the script's capability to accommodate future needs for joining lines in groups of 5, 7, or any other specified interval n. Ensure your script is adaptable to varying group sizes.

1.2 Sample Data

The provided sample data should be used for testing the commands. Once you feel comfortable and confident, you can apply these commands to your actual input data.

Input:

vJrwpWtwJgWrhcsFMMfFFhFp
jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
PmmdzqPrVvPwwTWBwg
wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
ttgJtRGJQctTZtZT
CrZsJsPPZsGzwwsLwLmpwMDw

Expected output:

part1: 157
part2: 70

2. Solutions

This guide assumes you've already watched the accompanying walk-through YouTube video. If you haven't, please do.

2.1 The First Scenario

TL;DR

Scenario1 Part1:

Define a function Char2nr to calculate character priorities.
Use getline('.') to get the current line.
Split the line into left and right halves.
Use grep to find unique characters in both halves.
Execute the command and replace the line with the output.
Apply the process to all lines.
Convert unique characters to priorities using :%s/.*/\=Char2nr(submatch(0))
Sum up the priorities using %! paste -sd+ | bc

Scenario1 Part2:

Merge three lines at a time using :g/^/.,+2j.
Calculate the total score using let total += split(getline('.'))->reduce(Intersect)->Char2nr().
View the final score with :echo total

2.1.1 Part One

Let's begin by addressing the obvious.

As we progress through the challenge, we will eventually need to convert characters to their corresponding priority levels.

Lowercase item types 'a' through 'z' have priorities ranging from 1 through 26.
Uppercase item types 'A' through 'Z' have priorities ranging from 27 through 52.

" 96 because -char2nr('a') + 1 == 96
" 38 because -char2nr('A') + 26 + 1 == 38

let Char2nr = {c -> char2nr(c) - (tolower(c) ==# c ? 96 : 38)}

We use the ==# operator to perform a case-sensitive comparison, as opposed to the == operator.

Now, let's proceed with the following steps:

Initiate the recording of a macro with qq, then extract useful information that we'll need later:

let str = getline('.') | let mid = len(str)/2

Having acquired the content of the current line and its midpoint, let's split it in half and save the left and right sides:

let [left, right] = [str[:mid+1], str[mid:]]

To extract unique characters from both the left and right sides, we can employ grep. In this case we want to highlight the unique characters so we'll use grep -o. Constructing the command within VIM requires formatting, for a more cleaner look we'll use printf() instead of concatenation. Here's the formatted command:

let cmd = printf(".!echo '%s' | grep -o '[%s]' | sort -u | head -1", left, right)

The ! signals to Vim that this is a shell command, and the . indicates that Vim should replace the current line with the output of our constructed command.

Now, Execute the command using :exe cmd and move to the next line and conclude the macro with q

With the macro defined, apply it to the remaining lines using :% norm @q. This process transforms all the lines into a single unique character.

The next step is to convert all unique characters to their corresponding priority and sum them up:

:%s/.*/\=Char2nr(submatch(0))/ | %! paste -sd+ | bc

Congratulations, Part One is now solved!

Before advancing to the next part, let's review and identify potential enhancements. During the initial attempt, it's common to miss the broader perspective, especially in this scenario where we are emphasizing speed.

The command we composed to find unique characters in two chunks of strings can be encapsulated in a function:

let Intersect = {a, b -> printf("echo '%s' | grep -o '[%s]' | sort -u | head -1", a, b)->system()}

This function now returns a string instead of mutating the actual line invoked from. Furthermore, it operates as a reducer, a concept from functional programming. Reducers should be designed to accumulate, akin to recording a macro that can be repeated.

However, there's a subtlety. If we apply our reducer to chunks of strings (2 by 2), there's a potential issue. The reducer returns strings with new lines (due to grep and sort), and merging these results might be inconsistent. Additionally, using head in this situation is discouraged. More details can be found in the exercises section.

To address this, the function must consistently return either an empty string or a string, regardless of the input. Let's remove any new lines from the output using tr -d '\n':

let Intersect = {a, b -> printf("echo '%s' | grep -o '[%s]' | sort -u | tr -d '\n'", a, b)->system()}

Understanding the underlying mechanics is crucial; it provides more value than just learning about specific utilities.

Now we can proceed to the next part.

2.1.2 Part Two

Our current objective is to consolidate three lines at a time, extract unique characters from each merged line, and finally, display the cumulative score for all lines. This might sound like a lot.

Well, let's see what vim has to say about that:

:let total = 0
:g/^/.,+2j | let total += split(getline('.'))->reduce(Intersect)->Char2nr()

Congrats, Part Two is solved!

These commands efficiently merge lines in groups of three and calculate the total score. The final score is stored in the 'total' variable. To view the result, simply run :echo total.

2.2 The Second Scenario

Let's begin by revisiting familiar ground. You still remember Char2nr right?

let Char2nr = {c -> char2nr(c) - (tolower(c) ==# c ? 96 : 38)}

Now, onto the Intersect function. While we could reuse the one from the first scenario, for the sake of learning, let's explore an alternative implementation:

let Intersect = {a, b ->split(a, '\zs')->filter({_, c -> c =~# "[".b."]"})->join('')}

We use '\zs' to split at the start of each character, transforming, for instance, "abc" into ['a', 'b', 'c'].
The filter step retains only the characters matching our regex pattern, with the c =~ 'regex', the use of # is to ensure case sensitivity.
Finally, we reassemble the characters into a single string using join().

With both Intersect and Char2nr in place, let's streamline the process further by creating a utility function to determine the priority level of each line:

let GetPriority = {str -> split(str)->reduce(g:Intersect)->g:Char2nr()}

Going forward, we only need to interact with GetPriority, simplifying our code.

Now, let's approach the challenge from a different perspective, considering the additional rules introduced. Despite seeming disparate, joining lines and splitting strings boil down to manipulating delimiters.

To address this, let's design a function that adds a space delimiter to any list every n elements. For example, calling SpaceEvery(2, ['a', 'b', 'c', 'd']) should yield ['a', 'b', ' ', 'c', 'd']:

let SpaceEvery = {n, xs ->
  \ range(n, len(xs) - n, n)
  \ ->map({i, x -> x + i})
  \ ->reduce({acc, i -> insert(xs, ' ', i)}, copy(xs))
  \}

This versatile function can now be applied to each part of the process, enhancing flexibility and maintainability.

Note: In case SpaceEvery() is expecting shorter strings, then it is better to use range(n, len(xs), n)

2.2.1 Part One

The first step is to split a line in half

let InHalf = {xs -> g:SpaceEvery(len(xs)/2, split(xs, '\zs'))->join('')}

2.2.2 Part Two

the second part is to join lines in groups of 3

let JoinBy3 = {xs -> g:SpaceEvery(3, xs)->join(',')->split()->map("split(v:val,',')->join()")}

2.2.3 Finale Part

Now that we have created all the necessary utilities, let’s apply them to our input file.

For the first part, we can say:

echo
      \ readfile("inputdemo")
      \ ->map("InHalf(v:val)")
      \ ->map("GetPriority(v:val)")
      \ ->reduce({a, b -> a + b})

And for the second part:

echo
      \ same as before
      \ ->JoinBy3()
      \ same as before
      \ same as before

Congrats, Not only did we solve the original challenge, but we also overcame the additional constraints and rules.

2.2.4 Finale Script

the final script is as follow:

let Intersect = {a, b ->
      \ split(a, '\zs')->filter({_, c -> c =~# "[".b."]"})->join('')}

let Char2nr = {c ->
      \ char2nr(c) - (tolower(c) ==# c ? 96 : 38)}

let GetPriority = {str ->
      \ split(str)->reduce(g:Intersect)->g:Char2nr()}

let SpaceEvery = {n, xs ->
      \ range(n, len(xs) - n, n)
      \ ->map({i, x -> x + i})
      \ ->reduce({acc, i -> insert(xs, ' ', i)}, copy(xs))}

let InHalf = {xs ->
      \ g:SpaceEvery(len(xs)/2, split(xs, '\zs'))->join('')}

let JoinBy3 = {xs ->
      \ g:SpaceEvery(3, xs)
      \ ->join(',')
      \ ->split()
      \ ->map("split(v:val,',')->join()")}


echo
      \ readfile("inputdemo")
      \ ->JoinBy3()
      \ ->map("GetPriority(v:val)")
      \ ->reduce({a, b -> a + b})

4. Bonus

For a more detailed explanation of this section, please refer to the walkthrough video.

In the second scenario, we decided to reinvent the wheel. This is entirely acceptable because we are in a learning process, and my objective is to equip you with the skills necessary for the challenges that lie ahead. when we start the second season, we will delve into the development of plugins and tackle more complex tasks. It is my intention that these foundational concepts become second nature to you, akin to drinking water.

Allow me to illustrate a real-life scenario. When expediency is essential, opting for a quick-and-dirty approach is viable. Instead of employing the readfile() function, we can load a file into memory using buffers and manipulate it as if it were open(technically it is open).

Let's explore how we can use commands in a script to address a particular problem. Please note that I will demonstrate this using the original challenge, not the augmented version from the second scenario, as the latter involves additional elements.

Imagine that your script file, 'myscript.vim', is open. If you input the following lines:

badd inputfile | buff inputfile
buff myscript

This is equivalent to :e inputfile, followed by buff myscript, swiftly transitioning between the two files. Executing this file might seem uneventful, but VIM's efficiency creates an illusion of no movement due to its rapid switching between files.

Now, what's the significance of this?

We can insert commands in between and modify our files using vim commands. Observe the following:

badd inputfile | buff inputfile
norm ggdd
buff myscript

In this scenario, our script switches to inputfile, navigates to the first line, deletes it, and then switches back to our myscript file. Remarkably efficient, isn't it?

Now, let's apply this technique to solve part 2 of our challenge:

badd inputfile | buffinputfile
let total = 0
g/^/.,+2j | let total += split(getline('.'))->reduce(Intersect)->Char2nr()
norm u
buff myscript
echo total

The norm u command ensures that after modifying the buffer, we undo the changes to maintain the original state of the buffer. Our primary focus is on calculating the result without altering the file.

This method of scriptwriting is invaluable, especially when you need to create scripts in this format or when hardcoding macros prove to be efficient. We'll explore examples later to highlight the efficiency of this approach.

5. Exercises

From time to time, I'll share the solutions on Twitter, however, I want you to spend some time with the exercises on your own and with your team.

In the first scenario, instead of employing Char2nr to calculate priority, achieve the same result using only :%s. A helpful hint is to utilize the '\C' flag to specify that the substitution should be case-sensitive.
Rather than consolidating three lines using the global command :g, explore an alternative approach using only regular expressions.
When we wanted to make Intersect acts as a reducer

3.1. why we weren't capable of using head -1

3.2. If Intersect finds many occurrences it will return them all as a string, how can we make Intersect only returns one character while keeping the function useful if used as a reducer?

3.3. In our case why is it okay to not use tr -d '\n'?
In the second scenario, if we find multiple unique occurrences we only choose the first one, this time select the one that appears the most.
Instead of SpaceEvery. Create a function that can put any delimiter for each n interval.
Using buffers only, write the solution for scenario1 part1 and part2, without opening the input file and make sure that you use the same solution that we came up with. (you can either hardcode macors using let @q=... or use norm to record it.)

Using only vim to solve AdventOfCode Challenges | Episode 2

Cipherlogs — Sun, 17 Dec 2023 20:31:33 +0000

Note: It's important to read the first episode to understand the context of how these challenges are solved.

1. Getting Started

Open today's challenge and make sure that you are in sync with your team, if you don't have a team yet submit your application here

Take your time with the challenge and solve the puzzle in the two mentioned scenarios. Good luck.

1.1 Rules

In the first scenario, if you plan to hardcode all possible outcomes of the game, avoid manual entry. Instead, find an automatic way to handle them. Imagine having one million potential outcomes for the game—your approach should be automated for speed. Utilize your editor for efficiency. Remember, the emphasis in the first scenario is on speed.
In the second scenario, write a Vimscript that accommodates the worst-case scenario. Consider a situation where each symbol might signify something else in the future. Structure your code to distinctly separate the game logic from symbol deciphering.

1.2 Sample Data

The provided sample data should be used for testing the commands. Once you feel comfortable and confident, you can apply these commands to your actual input data.

Input:

A Y
B X
C Z

Expected output:

part1: 15
part2: 12

2. Solutions

This guide assumes you've already watched the accompanying walk-through YouTube video. If you haven't, please do.

2.1 The First Scenario

2.1.1 Part One

Our input data consists of symbols representing each player's move, and our task is to calculate the score of each game. The quickest way is to map all possible outcomes and replace each line with the corresponding score. For example:

A Y
B X
C Z

will translate to:

8
1
6

This mapping can be done using Vim dictionaries, acting like hashtables or objects. Below is a function Swap containing a dictionary with all possible game outcomes:

function! Swap(line)
  let scores = {
    \ 'A X': '4',
    \ 'A Y': '8',
    \ 'A Z': '3',
    \ 'B X': '1',
    \ 'B Y': '5',
    \ 'B Z': '9',
    \ 'C X': '7',
    \ 'C Y': '2',
    \ 'C Z': '6',
  \ }

  return scores[a:line]
endfunction

While we can use this function immediately, today's challenge rules prohibit hard coding outcomes. Instead, we need a fast and creative way to enter them.

To generate all possible symbols, use :r! echo \\n{A..C}" "{X..Z}.

In the walkthrough video, alternatives to Bash were discussed, showcasing the flexibility to choose more powerful tools based on specific needs.

This Haskell code achieves the same result as the previous Bash code, but with a key advantage: scalability. We can easily make further transformations to the generated output by adding additional functions to the pipeline.

main = putStr $ unlines [[x, ' ', y] | x <- ['A'..'C'], y <- ['X'..'Z']]

So far, this is what we have:

A X 
A Y 
A Z 
B X 
B Y 
B Z 
C X 
C Y 
C Z

and our end goal is:

A X: score 
A Y: score
... 
C Z: score

First let's create a function on the fly, that will assign the bonus points, if we loose we get no bonus, if we end with a draw we get the hand move point plus 3 and if we win we get the hand move point plus 6.

let BonusOf = {a, b -> a > b ? 0 : (a < b ? 6 : 3)

Now, to assign the correct score to each combination, let's record a quick macro.

Start by recording a macro on the first line with the following commands:

:let ln = line('.')
:let playerA = ln-1/3 + 1
:let playerB = ln%3 ? ln%3 : 3

gg0C'p<Esc>A: <C-r>=playerB + (playerA>1 && playerB>1 ? BonusOf(playerA,playerB) : BonusOf(playerA%3,playerB%3))jq

As we covered in the walkthrough video, we're using line numbers to determine the value of each hand. By default, "A, X" is 1, "B, Y" is 2, and so on.

We also use BonusOf(playerA%3, playerB%3) to round the value of each hand by three. This is because "Rock" is typically 1 and "Paper" is 2. However, we need to adjust this logic for "Scissors" (3), which should not be considered stronger than "Rock." The walkthrough video explains this rounding process in more detail.

Now, let's apply the macro we recorded on the first line to the rest of the lines. Simply use .,$ norm @q and you're good to go!

Then wrap everything in a function:

function! Swap(line)
  let scores = {
        \ 'A X': 4,
        \ 'A Y': 8,
        \ 'A Z': 3,
        \ 'B X': 1,
        \ 'B Y': 5,
        \ 'B Z': 9,
        \ 'C X': 7,
        \ 'C Y': 2,
        \ 'C Z': 6,
        \ }

  return scores[a:line]
endfunction

Open the input file and run the function on each line using :%s/.*/\=Swap(submatch(0)). To calculate the sum of all lines, use %! paste -sd+ | bc.

2.1.2 Part Two

For the second part of the challenge, the approach remains similar. Adjust the way you calculate the score for each round. You'll end up with a function like this:

function! Swap2(line)
  let scores = {
    \ 'A X': 3,
    \ 'A Y': 4,
    \ 'A Z': 8,
    \ 'B X': 1,
    \ 'B Y': 5,
    \ 'B Z': 9,
    \ 'C X': 2,
    \ 'C Y': 6,
    \ 'C Z': 7,
  \ }

  return scores[a:line]
endfunction

Apply the same steps as in Part One to obtain the answer for the second part efficiently. Don't retype your previous commands, just recall them from the command history. this step shouldn't take more than 5 seconds.

2.2 The Second Scenario

Defining Essential Functions

First and foremost, let's address the essential functions required for our game logic:

let Bonus = {a, b -> a > b ? 0 : (a < b ? 6 : 3)}
let Score = {a, b -> a>1 && b>1 ? g:Bonus(a, b) + b : g:Bonus(a%3, b%3) + b}

These functions establish the scoring mechanism for the game.

Handling Hand Moves

To proceed, we need to assign points to each hand move:

let pointOf = {'rock': 1, 'paper': 2, 'scissors': 3}

Additionally, we create a dictionary to map each move to its defeating move:

let next = {'rock': 'scissors', 'paper': 'rock', 'scissors': 'paper'}

Processing Input Data

Assuming our input data is stored in a file named input, we start by reading and printing its content:

echo readfile("input")

The output is a list of lines in the format ['symbolA symbolB', 'symbolA symbolB', ...]. We transform it to [['symbolA', 'symbolB'], ...]:

echo
      \ readfile("inputdemo.vim")
      \ ->map("split(v:val, ' ')")

The next step now is to translate each symbol to what it mean, whether is it 'rock', 'paper' or 'scissors'. for now, we are still in the testing phase, let's create a dummy function that will do this translation.

function ToHand(symbol)
  return {_ -> 'rock'}
endfunction

Our ToHand function takes a symbol and returns a new function. This new function, in turn, takes an argument and ultimately returns the name of the hand. In our example, it will always return "rock."

You might wonder why we don't just create a function that directly returns the string "rock" instead of adding an extra layer of abstraction. The reason is that the function we return will later be able to accept symbols from either the left or right column. This allows each function to have information about the opponent's move.

While ToHand may seem simple now, we'll revisit it and expand its functionality later.

echo
      \ readfile("inputdemo.vim")
      \ ->map("split(v:val, ' ')")
      \ ->map({_, xs -> [ToHand(xs[0])(xs[1]), xs[1]]})

Here, we map over each element, applying ToHand to symbols in the left column for player one's move, and then applying it to the right column for player two's move.

      \ ->map({_, xs -> [xs[0], ToHand(xs[1])(xs[0])]})

While applying both functions simultaneously might seem tempting, it would make our lambda function unnecessarily complex. Instead, we'll follow the natural flow of the game: player one plays their move, the game state updates, and then player two reacts based on the updated state. This approach keeps our code easy to read.

Next, we convert hand names to their corresponding points:

      \ ->map({_, xs -> map(xs, "g:pointOf[v:val]")})

We call the Score function to obtain the score for each game round and sum up all the numbers in the list:

      \ ->map({_, v -> g:Score(v[0], v[1])})
      \ ->reduce({a, b -> a + b})

This encapsulates the entire game logic.

Note: While this script utilizes nested maps, it aligns with the nature of Vimscript. In other languages, we might explore composition or transduction, but for now, we'll keep Vimscript within its natural confines. Any future modifications will be limited to the ToHand function.

Note: I have written this using map on top of map. for this script is fine, in other languages, I might compose or transduce but let's not push vimscript doing things that aren't naturally built for. However, it's acknowledged that in future iterations, Lua may be explored for enhanced functionality, as hinted in the seond season.

Moving forward, the sole modification we'll make is to our placeholder function ToHand; all other aspects of the script remain unchanged.

2.2.1 Part One

In the initial phase of the puzzle, we assign 'rock' to A and X, 'paper' to B and Y, and 'scissors' to C and Z.

Now, let's refine our 'ToHand' function to accurately represent each symbol.

function ToHand(symbol)
  let symbols = {
        \ 'A': {_ -> 'rock'},
        \ 'B': {_ -> 'paper'},
        \ 'C': {_ -> 'scissors'},
        \ 'X': {_ -> 'rock'},
        \ 'Y': {_ -> 'paper'},
        \ 'Z': {_ -> 'scissors'},
        \}

  return symbols[a:symbol]
endfunction

This modification ensures that our 'ToHand' function correctly translates each symbol to its corresponding hand gesture.

And that's it – we're finished!

2.2.2 Part Two

In the second part, we define the conditions for three scenarios: losing, drawing, and winning denoted by X, Y, and Z respectively. Achieving these outcomes involves specific modifications to our ToHand function.

        \ 'X': {x -> g:next[x]}

For scenario X, which corresponds to a loss, we take the enemy's hand move, represented by arg x, and call the next function to determine the subsequent move required for a loss.

        \ 'Y': {x -> x}

In the case of Y, signifying a draw, we simply return the same enemy move denoted by x.

        \ 'Z': {x -> g:next[g:next[x]]}

For Z, indicating a win, we perform the inverse of the X scenario.

2.2.3 The Final Script

That's all the necessary adjustments to the ToHand function. The final and comprehensive script is provided below.

function ToHand(symbol)
  let symbols = {
        \ 'A': {_ -> 'rock'},
        \ 'B': {_ -> 'paper'},
        \ 'C': {_ -> 'scissors'},
        \ 'X': {x -> g:next[x]},
        \ 'Y': {x -> x},
        \ 'Z': {x -> g:next[g:next[x]]},
        \}

  return symbols[a:symbol]
endfunction


" CORE, DO NOT TOUCH
let pointOf = {'rock': 1, 'paper': 2, 'scissors': 3}
let next = {'rock': 'scissors', 'paper': 'rock', 'scissors': 'paper'}
let Bonus = {a, b -> a > b ? 0 : (a < b ? 6 : 3)}
let Score = {a, b -> a>1 && b>1 ? g:Bonus(a, b) + b : g:Bonus(a%3, b%3) + b}

echo
      \ readfile("inputdemo.vim")
      \ ->map("split(v:val, ' ')")
      \ ->map({_, xs -> [ToHand(xs[0])(xs[1]), xs[1]]})
      \ ->map({_, xs -> [xs[0], ToHand(xs[1])(xs[0])]})
      \ ->map({_, xs -> map(xs, "g:pointOf[v:val]")})
      \ ->map({_, v -> g:Score(v[0], v[1])})
      \ ->reduce({a, b -> a + b})

Exercises

In your preferred programming language, create a script that can automatically generate all potential game outcomes and their score.
Run your code in Vim to generate all the required data automatically.

Below is an example using Javascript:

const log = console.log;

const getCombos = xs => ys =>
  xs.flatMap (x => ys.map (y => [x, y]));

const pointOf = move => {
  const moves = {'X': 1, 'Y': 2, 'Z': 3,};
  return moves[move];
};

const some = xs => xA => xB =>
  xs
    .map (x => x.split(""))
    .some (x => x[0] === xA && x[1] === xB);

const isDraw = some (['AX', 'BY', 'CZ']);

const isLost = some (['AZ', 'BX', 'CY']);

const format = combos => {
  return (
    combos.map (combo => {
      const enemyMove = combo[0];
      const myMove = combo[1];
      const shapeScore = pointOf (myMove);

      const score = (
        isDraw (enemyMove) (myMove)
          ? 3 + shapeScore
          : isLost (enemyMove) (myMove) ? shapeScore : 6 + shapeScore
      );

      return `'${enemyMove} ${myMove}':${score},`
    })
  );
};

log (format (getCombos (['A', 'B', 'C']) (['X', 'Y', 'Z'])))

Using only vim to solve AdventOfCode Challenges | Episode 1

Cipherlogs — Sun, 17 Dec 2023 20:27:35 +0000

This journey will transform you and challenge your creative and resourceful thinking. You will explore new possibilities with VIM, going beyond what you thought it could do. And as you advance through the Advent Of Code puzzles, you will truly transform yourself if you follow the two scenarios listed below.

Every day, you'll practice two scenarios:

Speed: Imagine this: you are busy editing some text in VIM, when suddenly a challenge pops up on the same file you are working on. You have to solve it quickly with motions and commands to resume your original task. speed is key here.
Future-Proof: Suppose the challenge is not a one-time event, but a frequent occurrence. You need to solve it in a way that’s adaptable and scalable by writing a Vimscript that handles today’s problems and can cope with future changes.

Getting Started

Create an account with Advent of code, and open today's challenge.

Make sure that you are in sync with your team, if you don't have a team yet submit your application here

take your time with the challenge and solve the puzzle in the two mentioned scenarios. Good luck.

Solutions

This guide assumes you've already watched the accompanying walk-through YouTube video. If you haven't, please do.

Using only vim/neovim to solve Advent of code | Episode 1 - YouTube

Every day, you will face real challenges with two interconnected parts, demanding a unique approach.You will join programmers from around the world in solvin...

youtube.com

Sample data

The provided sample data should be used for testing the commands while you are reading. Once you feel comfortable and confident, you can apply these commands to your actual input data.

Input:

Expected output:

part1: 24000
part2: 45000

Scenario #1

1.1 Part1 First method: using AWK

We can use AWK to solve both part one and two, but let's stay in sync with the walk-through video.

{s+=$1} !NF{m=s>m?s:m;s=0} END {print m}

1.2 Part1 Second method: Global Command

Like AWK, the global command operates on every line one by one.

Concatenate lines containing only digits in reverse order: :g/\d/-j
Replace spaces with plus signs in each line: :%s/\s/+/g
Evaluate each line as an expression: :%s/.*/\=eval(submatch(0))
Select the entire file, perform a descending sort, and retain only the first line: :%!sort -nr | head -1

We can do step 1 and 2 in just :%s/\v\n($)@!/+ or :%s/\v(\d)\n(\d)/\1+\2

We can replace step3 with just :% !bc

1.3 Part2 Regex And Global Command

There's not much to change from the previous solution. All you need to do is instruct head to keep three lines instead of just one. Use head -3 now that we have the top 3 sums we can easily sum up these 3 lines :%! paste -sd+ | bc

Scenario 2

In the second scenario, we need to think of the worst possible cases for our input data and solve the problem accordingly. This problem is so simple that we do not need to write any vimscript or script today.

Exercises

After watching the walk-through video and going through this guide, you will have plenty of knowledge to solve the exercises below.

use the :g command to replicate what we did with AWK
modify our AWK to solve part2

In case you care about this content, follow me on twitter @cipherlogs and enable notification to be notified when each episode is out.