Letter Tile Possibilities - Practice Coding Problems

Letter Tile Possibilities - Problem

Letter Tile Possibilities

Imagine you have a collection of letter tiles, like those used in Scrabble or word games. Each tile has a single letter printed on it, and you want to know how many different sequences you can create using these tiles.

Given a string tiles where each character represents a letter on a tile, return the total number of possible non-empty sequences you can make. You can use each tile at most once in each sequence.

For example, with tiles "AAB", you can make: "A", "B", "AA", "AB", "BA", "AAB", and "ABA" - that's 7 different sequences!

Key Points:
• Each sequence must be non-empty
• You can use tiles in any order
• Each tile can only be used once per sequence
• Different arrangements of the same letters count as different sequences

Input & Output

example_1.py — Basic Case

$ Input: tiles = "AAB"

› Output: 7

💡 Note: The possible sequences are: "A", "B", "AA", "AB", "BA", "AAB", "ABA". Note that "A" appears twice in our tiles, so sequences like "AA" are possible.

example_2.py — All Same Letters

$ Input: tiles = "AAABBC"

› Output: 188

💡 Note: With 3 A's, 2 B's, and 1 C, we can form many different sequences. The algorithm counts all unique arrangements of different lengths efficiently.

example_3.py — Single Tile

$ Input: tiles = "V"

› Output: 1

💡 Note: With only one tile, we can only form one sequence: "V". This is the simplest edge case.

Constraints

1 ≤ tiles.length ≤ 7
tiles consists of uppercase English letters
Note: The small constraint on length makes backtracking very efficient

Visualization

Tap to expand

Understanding the Visualization

Count Your Tiles

First, count how many of each letter you have (A:2, B:1)

Try Each Letter

For each available letter type, use one and see what sequences you can extend

Build Recursively

At each step, count the current sequence plus all possible extensions

Backtrack Efficiently

Restore letter counts and try the next possibility

Key Takeaway

🎯 Key Insight: By using character frequency counting with backtracking, we can efficiently explore all possible sequences without generating duplicates, making the solution much faster than brute force permutation generation.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Facebook 8

The optimal solution uses backtracking with character frequency counting. By maintaining a frequency map of available characters, we can efficiently generate all possible sequences without duplicates. The key insight is that at each step, we try using each available character type, recursively count all extensions, then backtrack by restoring the character count. This avoids the exponential overhead of generating duplicate permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n! × 2^n)	O(n! × 2^n)	Generate all permutations of all possible lengths and count unique ones
Backtracking with Character Counting	O(∑(P(count_i, k))) for all k and characters i	O(26) for frequency map + O(max_length) for recursion	Use backtracking with frequency map to avoid duplicate generation

Generate All Permutations — Algorithm Steps

For each possible length from 1 to n
Generate all permutations of that length
Add each permutation to a set to avoid duplicates
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Length 1

Create all single-character sequences

Generate Length 2

Create all two-character permutations

Continue for All Lengths

Generate permutations up to full length

Remove Duplicates

Use set to eliminate duplicate sequences

Code -

solution.c — C

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

static char sequences[10000][10];
static int sequenceCount = 0;

int isDuplicate(char* seq) {
    for (int i = 0; i < sequenceCount; i++) {
        if (strcmp(sequences[i], seq) == 0) {
            return 1;
        }
    }
    return 0;
}

void generatePermutations(char* tiles, int* used, char* current, int pos, int length, int n) {
    if (pos == length) {
        current[length] = '\0';
        if (!isDuplicate(current)) {
            strcpy(sequences[sequenceCount++], current);
        }
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = 1;
            current[pos] = tiles[i];
            generatePermutations(tiles, used, current, pos + 1, length, n);
            used[i] = 0;
        }
    }
}

int numTilePossibilities(char* tiles) {
    int n = strlen(tiles);
    int* used = (int*)calloc(n, sizeof(int));
    char* current = (char*)malloc((n + 1) * sizeof(char));
    sequenceCount = 0;
    
    for (int length = 1; length <= n; length++) {
        generatePermutations(tiles, used, current, 0, length, n);
    }
    
    free(used);
    free(current);
    return sequenceCount;
}

int main() {
    char tiles[10];
    scanf("%s", tiles);
    printf("%d\n", numTilePossibilities(tiles));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 2^n)

For each of the 2^n subsets, we generate up to n! permutations

⚠ Quadratic Growth

Space Complexity

O(n! × 2^n)

Space needed to store all generated permutations in the set

⚠ Quadratic Space

18.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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler