Letter Tile Possibilities

Letter Tile Possibilities - Problem

You have n tiles, where each tile has one letter tiles[i] printed on it.

Return the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.

Note: You may use each tile at most once per sequence.

Input & Output

Example 1 — Basic Case

$ Input: tiles = "AAB"

› Output: 8

💡 Note: Possible sequences: "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA". Total of 8 sequences.

Example 2 — All Same Characters

$ Input: tiles = "AAABBC"

› Output: 188

💡 Note: With frequencies A:3, B:2, C:1, we can form many sequences of lengths 1-6. Each length has unique permutations based on character frequencies.

Example 3 — Single Character

$ Input: tiles = "V"

› Output: 1

💡 Note: Only one sequence possible: "V"

Constraints

1 ≤ tiles.length ≤ 7
tiles consists of uppercase English letters

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use backtracking with frequency counting to generate all possible sequences without duplicates. The optimal approach uses a frequency map to track available characters and backtracking to systematically build sequences. Time: O(∑k!/∏freq_i!), Space: O(n)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Backtracking with Frequency Map

⏱️ Time: O(∑(k! / ∏(freq_i)!)) Space: O(n)

Count frequency of each character, then use backtracking to build sequences of different lengths. For each position, try each available character and recursively build the rest.

Brute Force - Generate All Permutations

⏱️ Time: O(2ⁿ × n!) Space: O(2ⁿ × n!)

Generate every possible subsequence of the tiles string, then create all permutations for each subsequence. This approach considers every possible way to arrange the letters.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_NUMS 100000

int solution(int* nums, int numsSize) {
    // Use a simple array as hash set for positive numbers
    int hash[MAX_NUMS] = {0};
    int visited[MAX_NUMS] = {0};
    
    // Mark all numbers as present
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] >= 0 && nums[i] < MAX_NUMS) {
            hash[nums[i]] = 1;
        }
    }
    
    int maxLength = -1;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < 0 || nums[i] >= MAX_NUMS || visited[nums[i]]) continue;
        
        // Only start chain if this number is not a square of another number in the set
        int isStart = 1;
        for (int j = 0; j < MAX_NUMS; j++) {
            if (hash[j] && (long long)j * j == nums[i]) {
                isStart = 0;
                break;
            }
        }
        
        if (!isStart) continue;
        
        // Try to build chain starting from this number
        long long current = nums[i];
        int length = 1;
        
        while (current < MAX_NUMS && hash[current] && current * current < MAX_NUMS && hash[current * current]) {
            if (current < MAX_NUMS) visited[current] = 1;
            current = current * current;
            length++;
            
            // Prevent infinite loops
            if (current == 1) break;
        }
        
        if (current < MAX_NUMS && hash[current]) {
            visited[current] = 1;
        }
        
        if (length >= 2) {
            if (length > maxLength) {
                maxLength = length;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    
    while (token != NULL && numsSize < 20) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

842 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