License Key Formatting - Practice Coding Problems

License Key Formatting - Problem

String Easy

Transform a messy license key into a perfectly formatted one! You're given a license key string containing alphanumeric characters and dashes scattered throughout. Your mission is to reformat this string so that:

Each group contains exactly k characters (except the first group which can be shorter)
Groups are separated by dashes
All letters are converted to uppercase
The first group must contain at least one character

For example: "5F3Z-2e-9-w" with k=4 becomes "5F3Z-2E9W" Think of it like reorganizing a messy product serial number into a clean, standardized format that's easy to read and type!

Input & Output

example_1.py — Basic formatting

$ Input: s = "5F3Z-2e-9-w", k = 4

› Output: "5F3Z-2E9W"

💡 Note: The string has 8 valid characters. First group gets 4 characters (5F3Z), second group gets the remaining 4 characters (2E9W), separated by a dash.

example_2.py — Shorter first group

$ Input: s = "2-5g-3-J", k = 2

› Output: "2-5G-3J"

💡 Note: 5 valid characters total. First group gets 1 character (2), then two groups of 2 characters each (5G, 3J).

example_3.py — No dashes needed

$ Input: s = "2-4A0r7-4k", k = 4

› Output: "24A0R74K"

💡 Note: 8 valid characters fit exactly into 2 groups of 4, but since we want first group to be shorter if needed, all 8 characters form one group less than k*2.

Constraints

1 ≤ s.length ≤ 3 × 10⁴
s consists of English letters, digits, and dashes '-'
1 ≤ k ≤ 10⁴
First group can be shorter than k but must contain at least one character

Visualization

Tap to expand

Understanding the Visualization

Input Cleaning

Remove all dashes and convert letters to uppercase

Reverse Grouping

Process from right to left, creating groups of k characters

Final Assembly

Reverse the result to get proper order with dashes between groups

Key Takeaway

🎯 Key Insight: Working backwards naturally ensures all groups except the first have exactly k characters, eliminating complex group size calculations!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 Apple 12

The optimal approach processes the cleaned string from right to left, naturally forming groups of exactly k characters (except the first group). This reverse processing technique elegantly handles the variable-length first group requirement with O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Reverse Processing (Optimal)	O(n)	O(n)	Process characters backwards to naturally form groups of exactly k characters
Character-by-Character Reconstruction	O(n²)	O(n)	Build result by processing each character and rebuilding groups repeatedly

Reverse Processing (Optimal) — Algorithm Steps

Remove all dashes and convert to uppercase
Start from the rightmost character
Build groups of k characters from right to left
Add dashes between groups
The leftmost group gets remaining characters (≤ k)

Visualization

Tap to expand

Step-by-Step Walkthrough

Clean String

Remove dashes: '5F3Z2E9W'

Process Backwards

Build groups from right to left

Reverse Result

Final formatted string: '5F3Z-2E9W'

Code -

solution.c — C

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

void reverse(char* str, int len) {
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

char* licenseKeyFormatting(char* s, int k) {
    int len = strlen(s);
    
    // Remove dashes and convert to uppercase
    char* clean = (char*)malloc((len + 1) * sizeof(char));
    int cleanLen = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] != '-') {
            clean[cleanLen++] = toupper(s[i]);
        }
    }
    clean[cleanLen] = '\0';
    
    if (cleanLen == 0) {
        free(clean);
        char* result = (char*)malloc(1 * sizeof(char));
        result[0] = '\0';
        return result;
    }
    
    char* result = (char*)malloc((cleanLen * 2) * sizeof(char));
    int resultLen = 0;
    
    // Process from right to left
    for (int i = cleanLen - 1; i >= 0; i--) {
        // Add dash every k characters (except at the beginning)
        if (resultLen > 0 && resultLen % (k + 1) == k) {
            result[resultLen++] = '-';
        }
        result[resultLen++] = clean[i];
    }
    
    result[resultLen] = '\0';
    
    // Reverse to get correct order
    reverse(result, resultLen);
    
    free(clean);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to clean it, then single pass backwards to format

✓ Linear Growth

Space Complexity

O(n)

Space for cleaned string and result string

⚡ Linearithmic Space

31.5K 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

Reverse Processing (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler