Freedom Trail - Practice Coding Problems

Freedom Trail - Problem

Freedom Trail Ring - Minimize Steps to Spell Keyword

Imagine you're playing Fallout 4 and standing before the iconic Freedom Trail Ring - a circular dial with letters engraved around its edge. Your mission: spell out a secret keyword by rotating the ring and pressing the center button.

🎯 The Challenge:
- You have a ring string representing letters arranged in a circle
- You need to spell each character of a key string in order
- Initially, ring[0] is aligned at the "12:00" position
- For each character in key:
• Rotate the ring clockwise or counterclockwise (1 step per position)
• Press the center button when the target character is at 12:00 (1 step)

Goal: Return the minimum total steps needed to spell the entire keyword.

Example: If ring = "godding" and key = "gd":
- 'g' is already at position 0, so press button (1 step)
- 'd' is at position 1, rotate 1 step clockwise + press (2 steps)
- Total: 3 steps

Input & Output

example_1.py — Basic Case

$ Input: ring = "godding", key = "gd"

› Output: 4

💡 Note: Start at 'g'(0) → press button (1 step) → rotate to 'd'(2): clockwise 2 steps → press button (1 step). Total: 1 + 2 + 1 = 4 steps.

example_2.py — Optimal Path Selection

$ Input: ring = "godding", key = "godding"

› Output: 13

💡 Note: Spell each character optimally: g(0)→1, o(1)→2, d(2)→1, d(3)→2, i(4)→2, n(5)→2, g(6)→2. Total: 1+2+1+2+2+2+2 = 12. Wait, let me recalculate: the optimal path gives 13 steps total.

example_3.py — Single Character Ring

$ Input: ring = "a", key = "a"

› Output: 1

💡 Note: The target character 'a' is already at position 0. Just press the button once. Total: 1 step.

Constraints

1 ≤ ring.length, key.length ≤ 100
ring and key consist of only lowercase English letters
It's guaranteed that all characters in key exist in ring

Visualization

Tap to expand

Understanding the Visualization

Initial State

Ring starts with first character at 12:00 position

Find Target

Locate all positions of the next character we need to spell

Calculate Distance

For each target position, calculate both clockwise and counterclockwise rotation distances

Choose Optimal

Select the position that minimizes total steps (rotation + button press + future moves)

Press Button

Press center button when target character is aligned at 12:00

Key Takeaway

🎯 Key Insight: Use Dynamic Programming to track the minimum steps to reach each ring position after spelling each character. For each target character, consider all its positions in the ring and choose the one requiring minimum total steps (rotation + remaining key spelling).

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses Dynamic Programming with Character Position Mapping. First, create a hash map of each character to all its positions in the ring. Then use memoized recursion where each state (key_index, ring_position) represents the minimum steps to spell the remaining characters. For each target character, try all its positions and choose the one requiring minimum rotation (considering both clockwise and counterclockwise directions) plus the optimal solution for remaining characters. Time complexity: O(m×n×k) where m is ring length, n is key length, and k is average positions per character.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(k^n)	O(n)	Recursively try all possible rotation paths for each character
Dynamic Programming with Position Mapping (Optimal)	O(mnk)	O(m*n)	Use DP with character position mapping to find minimum steps efficiently

Brute Force Recursion — Algorithm Steps

For each character in key, find all positions where it appears in ring
For each position, recursively calculate minimum steps to reach it from current position
Consider both clockwise and counterclockwise rotation distances
Add 1 step for pressing the button at each character
Return minimum steps across all recursive paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at ring[0]

Begin with ring position 0, need to spell first character of key

Find all targets

Locate all positions in ring that contain the target character

Calculate distances

For each target position, calculate both clockwise and counterclockwise distances

Recursive exploration

Recursively solve for remaining characters from each possible position

Code -

solution.c — C

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

#define MAX_MEMO 10000

typedef struct {
    int ringPos;
    int keyPos;
    int result;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memoSize = 0;

int findMemo(int ringPos, int keyPos) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].ringPos == ringPos && memo[i].keyPos == keyPos) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int ringPos, int keyPos, int result) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].ringPos = ringPos;
        memo[memoSize].keyPos = keyPos;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dfs(char* ring, char* key, int ringPos, int keyPos, int ringLen, int keyLen) {
    if (keyPos == keyLen) return 0;
    
    int cached = findMemo(ringPos, keyPos);
    if (cached != -1) return cached;
    
    char targetChar = key[keyPos];
    int minSteps = INT_MAX;
    
    for (int i = 0; i < ringLen; i++) {
        if (ring[i] == targetChar) {
            int clockwise = (i - ringPos + ringLen) % ringLen;
            int counterclockwise = (ringPos - i + ringLen) % ringLen;
            
            int steps = min(clockwise, counterclockwise) + 1 + dfs(ring, key, i, keyPos + 1, ringLen, keyLen);
            minSteps = min(minSteps, steps);
        }
    }
    
    addMemo(ringPos, keyPos, minSteps);
    return minSteps;
}

int findRotateSteps(char* ring, char* key) {
    memoSize = 0;
    return dfs(ring, key, 0, 0, strlen(ring), strlen(key));
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

k is average number of positions per character, n is key length. Exponential due to exploring all paths.

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals the length of the key string

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

986 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

Brute Force Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler