Advent of Code for R users | Emil Hvitfeldt | Data Science Lab

Transcript#

This transcript was generated automatically and may contain errors.

And I'm just ready to introduce our guest today, which is Emil Hvitfeldt . He is a software engineer here at Posit, and he's going to be talking to us about Advent of Code, and I'm super, super excited about it. Emil, would you like to introduce yourself?

Yes, thank you for introducing me. So I'm a software engineer on the Tidy Models team, mostly thinking about how to make modeling as easy and pleasant as possible. But I also like to do fun things on the side. I do a lot of puzzles and such, which is where Advent of Code has a little bit of an intersection between coding and puzzles. So I'm excited to be here.

I love puzzles, too. I'm a big mystery person, but also a physical puzzle person.

Okay, we are going to be talking about Advent of Code today. We are going to hop into screen sharing very soon. I'm going to share my screen really quickly first and just show you what Advent of Code even looks like. I'm going to share. Okay, hopefully you can see my screen right now. And you can see I have just gone to adventofcode.com. The only other thing I have up here is our Slido. And it is a blank base of a Christmas tree with numbers next to it.

And it's got a login button, because I am not logged in. I've literally never done Advent of Code in my entire life. It kind of looks like a console screen. And if I click login, it will give me some different options. So I can log in with GitHub. I will do that in just a second. But you can go through any of these. I think Google is probably the easiest one.

If you have never used Advent of Code before, there are some places you can go. I'm going to let Emil walk through that. But I just wanted you to see what it looks like before you're logged in. Maybe we can all log in together. So I'm going to stop sharing and hand this over to Emil.

And this is where Advent of Code tries to mimic what it's like to do programming in the real world. Because now we have some code that does something. And now he's asking a new question and it could be related to what we've done so far.

Part two: counting every click

So then I stemmed a little bit. So it talked earlier about up here that when you turn the knob, you hear a little click. Oh, yeah. I do remember it said that. I was wondering if that was going to be a part of this. Yeah. So if you had that in mind, you might have written it a little bit different, right? Because now we have it said the actual password is not how many times we end up at zero after an instruction. It's how many times we're passing zero.

Like for any time you turn a knob, just like if you turn it 50 times, you're turning it 50 increments. Any time any of the increments hit zero, we're topping that. Oh, no. Now I don't know how to think about this anymore in our code loop. I sometimes think like when things change like that, I just want to delete my entire loop and start it over because if I try to modify my existing one, I might make things harder for myself. It's like when you ask an LLM to write something for you and it's so bad that fixing it takes more time than writing it yourself from scratch.

What are you doing, Emil? So what I normally do is I just copy all my code into a part two. So this is my part one solution and this will be my part two solution where I'll just do something. So I'm seeing two main ways of handling this. One of them is doing the math.

First, is it going to be one or more? So can we count any times it's going to be more? Okay. So first, if we're turning left. Yeah, it feels like... If anybody has an idea here, please let us know.

I will do it definitely here by doing... So I'll move this up. So instead of doing, adding, like subtracting the value, I will do a new for loop with J in the value and we're subtracting one instead. So instead of subtracting the whole value once, we are subtracting one, that whole value of times.

That doesn't make any sense to me. I keep going. So here, instead of adding 15. Like if it was L15. If it was L15, instead of adding 15, we're adding one, 15 times. Oh, so we can see once it passes a threshold. Yeah. And then we're just moving this chapter inside. But Kieran says, what if you land on zero?

But that's fine, because that's what we want. So if you land on zero, you get a click, but if you pass zero, you get a click. I think it's when you pass zero, you get a click, right? Because if it was landing on zero, it would be the same answer as the first part, where we would only land a certain number of times. So it's any blip that causes the dial to point at zero.

And then... Oh, wait. Isabella has a... Isabella says, don't forget to check the warning at the bottom. What warning? What warning? Where's the warning? Oh, is it at the bottom of this? That's in this example? Be careful.

If the dial were pointing at 50, a single rotation like R1000 would cause the dial to point at zero 10 times before returning back to 50. So it is just any time it passes zero. Yeah. So let's... This is starting to be like a lot of...

So now what we're doing, this is basically the same topic twice, right? So what we're doing here, when we turn left and we have a value of something, we're looping over and subtracting one that many times. Each time we're subtracting one, we check if it's zero. No, we should move this on before. We subtract a value from it and then do the modular operator to make sure we're between zero and 99. Then we check the value is zero and then time it. And then we move on.

So let's... This is where we can try the example one more time.

Oh, Kieran put a big old hinty hint in the Discord chat. Oh, I want to hear it. Do you want to know? He put a spoiler tag on it in Discord, which you can do by putting a double pipe on either side of something, by the way, if you want to. This is a learning space, so we're going to go ahead and say it. He says the magic is the difference between modulo and percent divided by percent integer division.

It's interesting how we never hit zero. Oh, we're not doing enough. Something is happening here. Yeah. All right. Let's see. This is what we can just do. I equals one. The reference is L. The value is... Oh, so we know what it is. We're not looping over... We're just looping over the singular value of 68. We need to seek that. Yeah. We need to seek a length of this. It gives us a little vector of one to that number. By the way, Emil's working in R, so we are one indexed, not zero indexed. Yes. That's also very fun because every once in a while the puzzle assumes that it's one indexed, but a lot of times it assumes it's zero indexed. So every once in a while R just works really well compared to other languages by being zero indexed.

So now I'm going to move this because this is going to blow up when we do the real input. That's true. Do we have a part two test number to tell us if we're right? Let's see. It's a six. Oh, you guys. I think we did it. Well, Emil did it. I take zero credit.

And I'm just doing command C to undo. And then we move this. Now that sets. Oh, one more thing that would be fun to do. That is R1000 because that was the warning. There was a warning, yeah. And we did sets for this. So we can also fader some of these things as unit tests. Right, yeah. So sometimes if you do these and you're doing them in a little bit longer format, later ones require a lot more code than these earlier ones. And, yeah, so it's just like sometimes you actually write the unit test to make sure that you're following all these.

Do you do this like pretty messily or do you like? Oh, it's very messy the first time. Okay, I have your GitHub with your Advent of Code in our stats and I'm going to pop that into the Discord server channel just so that everybody can kind of like get a glimpse at the way that Emil works. And that is the cleaned up version. Yeah. Also, I think that 1000% expect yourself to be a lot messier. I am a hot mess and my stuff if I post it on GitHub will be equally hot and messy.

An alternative approach using cumulative sums

So it turned out to be right and we're happy. Do we have time for me to show an alternative way of handling day one or part one? Absolutely, yeah. We have 12 minutes left and we are totally cool. We've got 41 people with us right now. Hello, everybody.

So then I will still split it out in directional values like this. We could do it with in that dplyr pipeline. The separate function from tidyr would also split it, but we already have it split, so we're saving some time. So what we can do is since these turns are happening one after another, we can do it as a time sum of this of the value that we then do the modulo on because that's the same as like turning it back and forth.

But we need to do the directions. So in here we can say if else direction equals to l then it's going to be a minus one or it's a one. So basically what I'm doing now here is I'm taking the values and then I'm turning this direction into a vector of like basically a sign. So are we adding? Are we subtracting?

So now it's like these are now clicks left or clicks right? Yes, and then we're taking the time sum of this. So we're just adding them one after another because that's essentially what we're doing. And then doing the modulo of that in one go. But then we can do sum of res equals zero and that might not be the right number. Let's find out. Why is that the right? That does seem too low. 31 is very low. Yeah, that's definitely too low.

So what are we doing? But like I said, even if we did this version and it worked, which I'm messing up somehow, even if we end. There's a question in Slido. Thank you, Lauren, for letting me know. It's what's the difference between the double percent, which is the modulo, and just one percent sign? What is it?

So one percent, I don't think, does anything. Does it? I don't know if that is an operator. That's not an operator. So that doesn't do anything. Well, at least in R, which is what we're working on. At least in R, yeah, right. So if you need to do the question mark and then like the bat around it, because this is a function, but it's not one with values, like letter values. So it's hard to search for. But if you do this instead, you can find it. And here we see it's in here. And they're like describing what they do.

Oh, there's the, what Kieran mentioned, which is like you have the modulo and then the like percent divided by percent Y. Yeah. Another thing you could do, but even if this option worked, that would have not worked because we needed to expand it in here, right? Because here we need to tell individual clips. I'm sure there's a way if you cared for it. So instead of adding another for loop inside, you could have done the math based on the number, like the position and the number of clips to find out if it will pass, how many times it will pass.

So you could do something like, so if we imagine the position is 40 and the value is 60, and we are minusing, right? So if we're in the left, we could do if value is larger than position. And then, because we know if it's larger than position, we're passing it, right? But if it's, if the value is then less than a hundred, no, it needs to be lighter than a hundred plus, like the depth between. So basically, so here we know that it's, it goes over, it hits zero if it goes over 20, right? But it also, it does over twice if it's more than 120 and three times if it's more than 220, right? So you could do the math here. Like divide it by a hundred first and use that, like the number of times it goes in to a hundred as your first number.

Yeah, so there is a way, like you could write this up to avoid the inner for loop somehow, right? There's probably like 50 ways to do this and to get it right, which is the best and worst thing about coding.

There's probably like 50 ways to do this and to get it right, which is the best and worst thing about coding.

I feel like when I was first learning programming, I was like, but what's the right answer? And nobody could tell me that. They're like, there's no right answer. There's, if the code runs, it runs, right?

I wanted to call out, Kieran mentioned, and by the way, Kieran said he did not actually implement Modulo on his own. I was just taking him literally, and he was joking. He said that he used accumulate from the purrr package, which I think is an interesting solution. Yeah, so there's so many different ways of handling this. Yeah, and that'll like sequentially do your cumulative sum by applying a function cumulatively over time.

And Noor was saying in the beginning too, that she would have solved it by like creating a function that did your thing that you need to do in your for loop.

Yeah, we're having a conversation in the chat about Modulo and the difference between R and Python operators. Like another thing you should do, which would be overkill in this situation, but a lot of Advent of Code likes these things where it's like a series of instructions, right? Like if the first character is L, you do something. If the first character is R, do something else. But sometimes they have like six different ones that do different things.

What we do in R, which I've done, which is very fun, is you take the input and then with, so here we have the, I've just done a shape of the, oh, it's so long. So just for like demonstration. So what we could do is we have the input that says this, but what we instead could do is to do is modify it a little bit. So you have direction. And then, oh, three minutes left as a time check.

So you can modify it a little bit, right? So now suddenly it looks like a bunch of function tools, right? So you could modify the input to turn it into what looks like a bunch of R function tools, define the functions R and L that does what we need. And then evaluate the input. Ooh, I like it. It's almost metaprogramming. Yeah. So you can do that. Here, it's Overtail. And you need to do like some weird, like back up things where we need to, because we need to now modify in global slope, like out of zeros. But you could do that. You could, these two for loops we have, you could have put those inside an L function and R function that then just run on itself. So instead of looping over the input, we're turning the input into code that when evaluated does the same thing.

So that's, so it was a great first day because there's a lot of different things to do. Yeah, this was a fantastic day. Part one and two for our purposes. This is really fun. If you never did Advent of Code before, like I didn't, I hope that you are now excited to go play with it. And there's only 12 days this year, so it's a little bit less stressful. It used to be 30 days every single time. And people were staying up past midnight to get things done as fast as they came out. And like, don't stress that much, but do have fun. Do come share in the Discord server what you're working on, and we can work on it together.

And I'm so excited that you hung out with us today. We are going to be here next week with Alex Chisholm, who also happens to work here at Posit, to talk about all the different ways to publish Shiny apps in 2026. Because our Shiny app publication landscape has been changing so much and is evolving. And we would love to show you how that works in Positron and RStudio and everything in between. Thank you for hanging out with us, Emil. This was fantastic.

It was a pleasure. It was fun having time with everyone. I'll try to do, like, if people aren't Discord, I think people are sharing answers. That's fun. They are. And it's very entertaining, but also, like, make sure to only spend however much time you have on it, so it doesn't take over. Care for your mental health and your friends and family, instead of spending all day on Advent of Code. Yeah. Okay, everybody, I will see you on the Discord server. Come say hi. Come share your code. Other than that, I'll see you next week, or I'll see you on Thursday for the Data Science Hangout. Bye, everybody!

Advent of Code for R users | Emil Hvitfeldt | Data Science Lab

Transcript#

Tour of Advent of Code

Day one: reading the puzzle

Setting up the code

Introducing the modulo operator

Part two: counting every click

An alternative approach using cumulative sums

Featured software#

positron

purrr

tidyverse

tidyverse.org