AdventJS 2023: Day 5 Challenge
Tags: javascript, webdev, challenge, node
Published: 2023-12-06 21:50:36

---
title: AdventJS 2023: Day 5 Challenge
published: true
date: 2023-12-05 06:00:00 UTC
tags: javascript, webdev, challenge, node
canonical_url: https://alexvalle.dev/adventjs-2023-day-5-challenge?showSharer=true
cover_image: "https://dev-to-uploads.s3.amazonaws.com/uploads/articles/99ft38on511kshlfp7c0.png"
---

The solution to the [Challenge #5](https://adventjs.dev/es/challenges/2023/5) of [AdventJS 2023](https://adventjs.dev/es)

The solution to the [previous challenge](https://dev.to/fenriuz/adventjs-2023-day-4-challenge-3knh)

The solution to the [next challenge](https://dev.to/fenriuz)

{%- # TOC start (generated with https://github.com/derlin/bitdowntoc) -%}

- [**Challenge Description**](#challenge-description)
- [**Analysis**](#analysis)
   * [**Inputs**](#inputs)
   * [**Output**](#output)
   * [**Considerations**](#considerations)
- [**Solution**](#solution)
   * [**Code**](#code)
   * [**Community Solutions**](#community-solutions)

{%- # TOC end -%}


## **Challenge Description**

Santa 🎅 is testing his new electric sled, the CyberReindeer, on a North Pole road. The road is represented by a string of characters, where:

. = Road
S = Santa's Sled
* = Open barrier
| = Closed barrier
Example of a road: S...|....|.....

Each unit of time, the sled moves one position to the right. If it encounters a closed barrier, it stops until the barrier opens. If it is open, it goes through directly.

All barriers start closed, but after 5 units of time, they all open forever.

Create a function that simulates the sled's movement for a given time and returns an array of strings representing the state of the road at each unit of time:

```javascript
const road = 'S..|...|..'
const time = 10 // units of time
const result = cyberReindeer(road, time)

/* -> result:
[
  'S..|...|..', // initial state
  '.S.|...|..', // sled advances on the road
  '..S|...|..', // sled advances on the road
  '..S|...|..', // sled stops at the barrier
  '..S|...|..', // sled stops at the barrier
  '...S...*..', // barrier opens, sled advances
  '...*S..*..', // sled advances on the road
  '...*.S.*..', // sled advances on the road
  '...*..S*..', // sled advances on the road
  '...*...S..', // passes through the open barrier
]
*/
```
The result is an array where each element shows the road at each unit of time.

Take into account that if the sled is in the same position as a barrier, then it takes its place in the array.

## **Analysis**

To solve this challenge, we must move the letter `S` within the string and stop it when it finds a barrier (`|`). The barrier will open (`*`) after 5 units of time. We need to store the journey of the letter `S` in an array until the units of time run out.

### **Inputs**

1. Road (`road`): The original string through which the sled will make its journey.

2. Time (`time`): A number with the units of time.

### **Output**

- An array of the history of the sled's journey

### **Considerations**

- We must stop the sled when it encounters a barrier and store it in history even if it does not move from there.

- When the sled passes over an open barrier (`*`), it will replace it in the string and once it has passed, the open barrier (`*`) must be put back.

## **Solution**

The initial position of the sled is identified at the beginning. The function iterates for each unit of time, advancing the sled if there is no closed barrier ahead. On the fifth unit of time, all barriers open permanently. The state of the road is updated and saved in an array at each iteration, reflecting the position of the sled and the state of the barriers. The final result is an array showing the state of the road at each moment of the given time.

### **Code**

```javascript
/**
 * Simulates the movement of Santa's sled on a road for a given time.
 * 
 * @param {string} road - Representation of the road with '.', 'S', '|', and '*'.
 * @param {number} time - Number of units of time to simulate.
 * @return {string[]} - Array representing the state of the road at each unit of time.
 */
function cyberReindeer(road, time) {
  // Stores the state of the road at each unit of time
  const roadStates = [road];

  // Finds the initial position of the sled
  let sledPosition = road.indexOf("S");

  // Character that will be replaced by the sled when it moves
  let replacedChar = ".";

  // Iterates for each unit of time, minus one, since the initial state is already included
  for (let i = 0; i < time - 1; i++) {
    // Gets the current state of the road
    let currentRoadState = roadStates[i];

    // On the fifth iteration (unit of time 5), all barriers open
    if (i === 4) {
      currentRoadState = currentRoadState.replace(/[|]/g, "*");
    }

    // Checks if the next position of the sled is not a closed barrier
    if (currentRoadState[sledPosition + 1] !== "|") {
      // Prepares the new sled position
      // concatenating it to the element that previously was in that position
      const newSledPosition = `${replacedChar}S`;

      // Updates the character replaced by the sled before being replaced
      replacedChar = currentRoadState[sledPosition + 1];

      // Builds the new state of the road with the sled moved one position
      const firstPart = currentRoadState.substring(0, sledPosition);
      const lastPart = currentRoadState.substring(sledPosition + 2);
      currentRoadState = firstPart + newSledPosition + lastPart;

      // Updates the sled position
      sledPosition += 1;
    }

    // Adds the updated state of the road to the array
    roadStates.push(currentRoadState);
  }

  // Returns the array with the state of the road at each unit of time
  return roadStates;
}

```

### **Community Solutions**

Solution by [SantiMenendez19](https://github.com/SantiMenendez19/adventjs/blob/main/2023/challenge05/solution.js):

```javascript
codefunction cyberReindeer(road, time) {
    let result = []
    let timePassed = 0
    let pos = 0
    let aux = "."
    while (time > 0) {
        result.push(road)
        time--
        timePassed++
        if (timePassed >= 5) road = road.replace(/\|/gi, "*")
        if (road[pos+1] === '.' || road[pos+1] === '*') {
            road = road.split("")
            road[pos] = aux
            aux = road[pos+1]
            road[pos+1] = "S"
            road = road.join("")
            pos++
        }
    }
    return result
}

```

Solution by [Achalogy](https://github.com/Achalogy/advent-js-2023/blob/main/retos/reto-5/main.ts):

```javascript
function cyberReindeer(road, time) {
  let moves = [road]
  let a = 0
  let b = "."

  for (let i = 1; i < time; i++) {
    if (i == 5) road = road.replace(/\|/g, "*")
    const newRoad = road.replace(/S[\.\*]/, `${b}S`)
    if (newRoad != road) {
      a++
      b = road[a]
    }
    road = newRoad
    moves.push(road)
  }

  return moves;
}

```

And that was the challenge for December 5th and its solutions. Do you have another alternative solution? Leave it in the comments!