License Key Formatting - Practice Coding Problems

License Key Formatting - Problem

String Easy

You are given a license key represented as a string s that consists of only alphanumeric characters and dashes. The string is separated into n + 1 groups by n dashes.

You are also given an integer k. We want to reformat the string s such that each group contains exactly k characters, except for the first group, which could be shorter than k but still must contain at least one character.

Furthermore, there must be a dash inserted between two groups, and you should convert all lowercase letters to uppercase.

Return the reformatted license key.

Input & Output

Example 1 — Basic Formatting

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

› Output: "5F3Z-2E9W"

💡 Note: The string has 8 valid characters: 5F3Z2E9W. With k=4, we get groups of 4: first group has 8%4=0→4 characters "5F3Z", second group has 4 characters "2E9W".

Example 2 — Shorter First Group

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

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

💡 Note: Valid characters: 25G3J (5 chars). With k=2, first group has 5%2=1 character "2", then groups of 2: "5G" and "3J".

Example 3 — All Dashes

$ Input: s = "---", k = 3

› Output: ""

💡 Note: No valid alphanumeric characters remain after removing dashes, so return empty string.

Constraints

1 ≤ s.length ≤ 3 × 10⁴
s consists of English letters, digits, and dashes '-'
1 ≤ k ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Input

License key with dashes: "5F3Z-2e-9-w", k=4

Process

Remove dashes, uppercase letters, group by k

Output

Formatted key: "5F3Z-2E9W"

Key Takeaway

🎯 Key Insight: Processing from right to left naturally handles the variable-length first group without complex calculations

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to process the string from right to left, which naturally handles the variable-length first group without special calculations. The reverse processing approach is optimal with time complexity O(n) and space complexity O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Clean Then Group	O(n)	O(n)	Remove dashes, convert to uppercase, then manually group characters
Reverse Processing	O(n)	O(n)	Build the result by processing characters from right to left

Brute Force - Clean Then Group — Algorithm Steps

Step 1: Remove all dashes and convert to uppercase
Step 2: Calculate first group size
Step 3: Manually build groups with dashes

Visualization

Tap to expand

Step-by-Step Walkthrough

Clean String

Remove dashes, convert to uppercase

Calculate Groups

Determine first group size

Build Result

Create groups with dashes

Code -

solution.c — C

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

char* solution(char* s, int k) {
    int len = strlen(s);
    char* cleaned = malloc(len + 1);
    int cleanedIdx = 0;
    
    // Remove dashes and convert to uppercase
    for (int i = 0; i < len; i++) {
        if (s[i] != '-') {
            cleaned[cleanedIdx++] = toupper(s[i]);
        }
    }
    cleaned[cleanedIdx] = '\0';
    
    if (cleanedIdx == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        free(cleaned);
        return result;
    }
    
    // Calculate first group size
    int remainder = cleanedIdx % k;
    if (remainder == 0) {
        remainder = k;
    }
    
    // Calculate result size (characters + dashes)
    int groups = (cleanedIdx + k - 1) / k;
    char* result = malloc(cleanedIdx + groups);
    int resultIdx = 0;
    int i = 0;
    
    // Add first group
    for (int j = 0; j < remainder; j++) {
        result[resultIdx++] = cleaned[i++];
    }
    
    // Add remaining groups
    while (i < cleanedIdx) {
        result[resultIdx++] = '-';
        for (int j = 0; j < k && i < cleanedIdx; j++) {
            result[resultIdx++] = cleaned[i++];
        }
    }
    
    result[resultIdx] = '\0';
    free(cleaned);
    return result;
}

int main() {
    char s[1000];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to clean string, single pass to format

✓ Linear Growth

Space Complexity

O(n)

Extra space for cleaned string and result

⚡ Linearithmic Space

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

Brute Force - Clean Then Group — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler