Execution of All Suffix Instructions Staying in a Grid

Execution of All Suffix Instructions Staying in a Grid - Problem

String Simulation Medium

Imagine you have a robot on an n × n grid that needs to follow a sequence of movement instructions. The grid has coordinates from (0, 0) at the top-left to (n-1, n-1) at the bottom-right.

You're given:

The grid size n
A starting position startPos = [startRow, startCol]
A string s of movement instructions: 'L' (left), 'R' (right), 'U' (up), 'D' (down)

Here's the interesting part: the robot can start executing from any position in the instruction string. For each possible starting position i, you need to determine how many instructions the robot can execute before either:

The next instruction would move it off the grid, or
There are no more instructions to execute

Goal: Return an array where answer[i] is the number of instructions the robot can execute starting from instruction i.

Input & Output

example_1.py — Basic Grid Navigation

$ Input: n = 3, startPos = [0,1], s = "RRDDLU"

› Output: [1,5,4,3,1,0]

💡 Note: Starting from index 0: Robot can only execute R (moves to [0,2]), then next R would go out of bounds. Starting from index 1: Robot executes RDDLU (5 moves total). Each starting position has different constraints based on remaining instructions.

example_2.py — Small Grid

$ Input: n = 2, startPos = [1,1], s = "LURD"

› Output: [4,1,1,1]

💡 Note: From index 0: All 4 instructions can be executed (LURD brings robot back to [1,1]). From other indices, only 1 instruction can be executed before going out of bounds.

example_3.py — Edge Case

$ Input: n = 1, startPos = [0,0], s = "LRUD"

› Output: [0,0,0,0]

💡 Note: In a 1×1 grid, any movement instruction takes the robot out of bounds, so 0 instructions can be executed from any starting index.

Constraints

m == s.length
1 ≤ n, m ≤ 500
0 ≤ startPos[0], startPos[1] < n
s consists of 'L', 'R', 'U', and 'D' only

Visualization

Tap to expand

Understanding the Visualization

Place Robot

Position the robot at the starting coordinates on the grid

Select Starting Instruction

Choose which instruction in the sequence to begin execution from

Execute Instructions

Move the robot step by step following each instruction

Check Boundaries

Stop if the next instruction would move the robot off the grid

Count Valid Moves

Record the total number of instructions successfully executed

Key Takeaway

🎯 Key Insight: Each starting position creates a different suffix of instructions, requiring independent simulation to count valid moves before hitting grid boundaries.

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 15

This problem requires direct simulation for each starting position. The optimal approach is to iterate through each possible starting index and simulate the robot's movement, counting valid steps until it goes out of bounds. With constraints of n,m ≤ 500, the O(m²) time complexity is acceptable. The key insight is that we need to check every suffix of the instruction string independently.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation	O(m²)	O(1)	For each starting position, simulate the robot's movement step by step

Direct Simulation — Algorithm Steps

Initialize result array of length m (instruction string length)
For each starting index i from 0 to m-1:
Reset robot position to startPos
Execute instructions from index i onwards
Count valid moves until robot goes out of bounds or instructions end
Store count in result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set robot at starting position

Execute Instructions

Move robot according to each instruction

Check Bounds

Stop if next move goes out of bounds

Count Steps

Record number of successful moves

Code -

solution.c — C

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

int isValid(int row, int col, int n) {
    return row >= 0 && row < n && col >= 0 && col < n;
}

void getNextPos(int row, int col, char instruction, int* nextRow, int* nextCol) {
    switch(instruction) {
        case 'L': *nextRow = row; *nextCol = col - 1; break;
        case 'R': *nextRow = row; *nextCol = col + 1; break;
        case 'U': *nextRow = row - 1; *nextCol = col; break;
        case 'D': *nextRow = row + 1; *nextCol = col; break;
        default: *nextRow = row; *nextCol = col; break;
    }
}

int* executeInstructions(int n, int* startPos, char* s, int* returnSize) {
    int m = strlen(s);
    *returnSize = m;
    int* result = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        int row = startPos[0], col = startPos[1];
        int count = 0;
        
        for (int j = i; j < m; j++) {
            int nextRow, nextCol;
            getNextPos(row, col, s[j], &nextRow, &nextCol);
            if (isValid(nextRow, nextCol, n)) {
                row = nextRow;
                col = nextCol;
                count++;
            } else {
                break;
            }
        }
        
        result[i] = count;
    }
    
    return result;
}

int main() {
    int n;
    int startPos[2];
    char s[100];
    
    scanf("%d", &n);
    scanf("%d %d", &startPos[0], &startPos[1]);
    scanf("%s", s);
    
    int returnSize;
    int* result = executeInstructions(n, startPos, s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

For each of m starting positions, we might execute up to m instructions, giving O(m²) time complexity

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for position tracking and counters (excluding output array)

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler