Cracking the Safe - Practice Coding Problems

Cracking the Safe - Problem

You're tasked with cracking a digital safe that has a unique password verification system. The safe requires a password consisting of n consecutive digits, where each digit can range from 0 to k-1.

Here's the catch: the safe doesn't reset between attempts. Instead, it continuously monitors the last n digits you've entered. Every time you input a new digit, the safe checks if the most recent n digits match the correct password.

Example: If the password is "345" (n=3) and you enter "012345":

After typing 0: recent digits = "0" ❌
After typing 1: recent digits = "01" ❌
After typing 2: recent digits = "012" ❌
After typing 3: recent digits = "123" ❌
After typing 4: recent digits = "234" ❌
After typing 5: recent digits = "345" ✅ Safe unlocked!

Goal: Find the shortest possible string that is guaranteed to unlock the safe, regardless of what the actual password is. This string must contain every possible n-digit combination as a substring.

Input & Output

example_1.py — Basic case

$ Input: n = 1, k = 2

› Output: "10"

💡 Note: For n=1, we need every single digit from 0 to k-1. The string "10" contains both "0" and "1" as substrings.

example_2.py — Small De Bruijn sequence

$ Input: n = 2, k = 2

› Output: "00110"

💡 Note: We need all 2-digit binary combinations: "00", "01", "10", "11". The string "00110" contains: "00" (positions 0-1), "01" (positions 1-2), "11" (positions 2-3), "10" (positions 3-4).

example_3.py — Edge case

$ Input: n = 1, k = 1

› Output: "0"

💡 Note: With only one possible digit (0) and length 1, the answer is simply "0".

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Create a graph where each (n-1)-digit sequence is a node

Add Transitions

Connect nodes with edges representing digit additions

Find Eulerian Path

Use DFS to visit every edge (combination) exactly once

Build Sequence

The path gives us the optimal De Bruijn sequence

Key Takeaway

🎯 Key Insight: By modeling combinations as graph edges rather than nodes, we can find the shortest path that visits every combination exactly once, creating the optimal De Bruijn sequence.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Visit each of the k^n edges exactly once in DFS

✓ Linear Growth

Space Complexity

O(k^n)

Store visited edges and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 4
1 ≤ k ≤ 10
1 ≤ kⁿ ≤ 4096
The answer is guaranteed to exist and be unique

Asked in

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

The optimal solution uses a De Bruijn sequence approach by modeling the problem as finding an Eulerian path in a graph. Each node represents an (n-1)-digit prefix, and edges represent digit transitions. Using DFS to traverse every edge exactly once produces the shortest string containing all possible n-digit combinations.

Common Approaches

Approach	Time	Space	Notes
✓ De Bruijn Sequence using DFS (Optimal)	O(k^n)	O(k^n)	Build a De Bruijn sequence using DFS on a graph where nodes are (n-1)-digit prefixes
Brute Force (Generate All Permutations)	O(k^n * n)	O(k^n * n)	Generate all possible n-digit combinations and concatenate them

De Bruijn Sequence using DFS (Optimal) — Algorithm Steps

Create nodes for all possible (n-1)-digit sequences
For each node, create k edges by appending digits 0 to k-1
Use DFS to find an Eulerian path that visits every edge exactly once
Build the result string by following the path

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create nodes for (n-1)-digit prefixes and edges for digit transitions

DFS Traversal

Use DFS to visit every edge exactly once

Build Result

Construct the De Bruijn sequence from the path

Code -

solution.c — C

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

#define MAX_VISITED 100000

struct {
    char edges[MAX_VISITED][10];
    int count;
} visited;

char result[MAX_VISITED];
int result_pos;

bool isVisited(const char* edge) {
    for (int i = 0; i < visited.count; i++) {
        if (strcmp(visited.edges[i], edge) == 0) {
            return true;
        }
    }
    return false;
}

void addVisited(const char* edge) {
    strcpy(visited.edges[visited.count], edge);
    visited.count++;
}

void dfs(const char* node, int k, int n) {
    for (int digit = 0; digit < k; digit++) {
        char edge[10];
        sprintf(edge, "%s%d", node, digit);
        
        if (!isVisited(edge)) {
            addVisited(edge);
            char nextNode[10];
            strcpy(nextNode, edge + 1);
            dfs(nextNode, k, n);
            result[result_pos++] = '0' + digit;
        }
    }
}

char* crackSafe(int n, int k) {
    if (n == 1) {
        char* ans = malloc((k + 1) * sizeof(char));
        for (int i = 0; i < k; i++) {
            ans[i] = '0' + i;
        }
        ans[k] = '\0';
        return ans;
    }
    
    visited.count = 0;
    result_pos = 0;
    
    // Start with the lexicographically smallest (n-1)-digit node
    char startNode[10];
    memset(startNode, '0', n - 1);
    startNode[n - 1] = '\0';
    
    dfs(startNode, k, n);
    
    // Reverse result
    for (int i = 0; i < result_pos / 2; i++) {
        char temp = result[i];
        result[i] = result[result_pos - 1 - i];
        result[result_pos - 1 - i] = temp;
    }
    result[result_pos] = '\0';
    
    // Create final result
    char* finalResult = malloc((strlen(startNode) + result_pos + 1) * sizeof(char));
    sprintf(finalResult, "%s%s", startNode, result);
    return finalResult;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    char* result = crackSafe(n, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Visit each of the k^n edges exactly once in DFS

✓ Linear Growth

Space Complexity

O(k^n)

Store visited edges and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 4
1 ≤ k ≤ 10
1 ≤ kⁿ ≤ 4096
The answer is guaranteed to exist and be unique

18.5K Views

Medium Frequency

~35 min Avg. Time

567 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

De Bruijn Sequence using DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler