Count Words Obtained After Adding a Letter

Count Words Obtained After Adding a Letter - Problem

You are given two 0-indexed arrays of strings startWords and targetWords. Each string consists of lowercase English letters only.

For each string in targetWords, check if it is possible to choose a string from startWords and perform a conversion operation on it to be equal to that from targetWords.

The conversion operation is described in the following two steps:

Append any lowercase letter that is not present in the string to its end.
- For example, if the string is "abc", the letters 'd', 'e', or 'y' can be added to it, but not 'a'. If 'd' is added, the resulting string will be "abcd".
Rearrange the letters of the new string in any arbitrary order.
- For example, "abcd" can be rearranged to "acbd", "bacd", "cbda", and so on. Note that it can also be rearranged to "abcd" itself.

Return the number of strings in targetWords that can be obtained by performing the operations on any string of startWords.

Note: You will only be verifying if the string in targetWords can be obtained from a string in startWords by performing the operations. The strings in startWords do not actually change during this process.

Input & Output

Example 1 — Basic Transformation

$ Input: startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"]

› Output: 2

💡 Note: "tack" can be formed from "act" by adding 'k' and rearranging to get "actk" then "tack". "act" cannot be formed from any start word by adding a letter (adding to "act" gives 4+ letters, adding to "ant" gives something with 4 letters that can't rearrange to "act"). "acti" can be formed from "act" by adding 'i'. Total: 2 words can be transformed.

Example 2 — No Valid Transformations

$ Input: startWords = ["ab","a"], targetWords = ["abc","abcd"]

› Output: 1

💡 Note: "abc" can be formed from "ab" by adding 'c'. "abcd" cannot be formed from any start word as it would require adding 2+ letters. Total: 1 word can be transformed.

Example 3 — Multiple Start Options

$ Input: startWords = ["g","go"], targetWords = ["og"]

› Output: 1

💡 Note: "og" can be formed from "g" by adding 'o' and rearranging to get "go", then rearranging to "og". Total: 1 word can be transformed.

Constraints

1 ≤ startWords.length, targetWords.length ≤ 5 × 10⁴
1 ≤ startWords[i].length, targetWords[i].length ≤ 10
startWords[i] and targetWords[i] consist of lowercase English letters only
No string in startWords is a prefix of any other string in startWords

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is that we can transform a start word to a target word if and only if the target has exactly one more unique character than the start word. The optimal approach uses bit masks to represent character sets, allowing O(1) comparisons instead of string sorting. Time: O(n×k + m×k), Space: O(n)

Common Approaches

✓ Bit Mask Optimization

⏱️ Time: O(n × k + m × k) Space: O(n)

Convert each word to a bit mask where each bit represents whether a character a-z is present. For a target to be reachable from a start word, the target's mask should have exactly one more bit set than the start word's mask.

Brute Force with Letter Addition

⏱️ Time: O(n × m × 26 × k log k) Space: O(k)

For each target word, check every start word by trying to add each of the 26 letters that are missing from the start word. After adding a letter, compare sorted versions to see if they match the target.

Sorted String Signatures

⏱️ Time: O(n × k log k + m × k²) Space: O(n × k)

Pre-compute sorted versions of all start words, then for each target word, try removing each character and check if the remaining sorted string exists in our start word signatures.

Bit Mask Optimization — Algorithm Steps

Convert each word to a 26-bit mask representing character presence
Store all start word masks in a hash set
For each target, try clearing each bit and check if resulting mask exists in start set
Count successful matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Bits

Word 'ab' becomes 11000...0 (bits 0,1 set)

Target Processing

Word 'cab' becomes 111000...0, try clearing each bit

Match Check

Clearing bit 2 gives 011000...0, check if exists

Code -

solution.c — C

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

#define MAX_MASKS 1000

int startMasks[MAX_MASKS];
int maskCount = 0;

int wordToMask(char* word) {
    int mask = 0;
    int len = strlen(word);
    for (int i = 0; i < len; i++) {
        mask |= (1 << (word[i] - 'a'));
    }
    return mask;
}

bool findMask(int mask) {
    for (int i = 0; i < maskCount; i++) {
        if (startMasks[i] == mask) {
            return true;
        }
    }
    return false;
}

int solution(char startWords[][20], int startSize, char targetWords[][20], int targetSize) {
    // Convert start words to bit masks
    maskCount = startSize;
    for (int i = 0; i < startSize; i++) {
        startMasks[i] = wordToMask(startWords[i]);
    }
    
    int count = 0;
    
    for (int t = 0; t < targetSize; t++) {
        int targetMask = wordToMask(targetWords[t]);
        bool found = false;
        
        // Try removing each character (clearing each bit)
        for (int i = 0; i < 26 && !found; i++) {
            if (targetMask & (1 << i)) { // If bit i is set
                // Clear bit i to simulate removing character
                int reducedMask = targetMask ^ (1 << i);
                
                if (findMask(reducedMask)) {
                    count++;
                    found = true;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char startWords[1000][20];
    char targetWords[1000][20];
    int startSize = 0, targetSize = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char *token = strtok(line, "[],\"\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= 'a' && token[0] <= 'z') {
            strcpy(startWords[startSize++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\"\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= 'a' && token[0] <= 'z') {
            strcpy(targetWords[targetSize++], token);
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    printf("%d\n", solution(startWords, startSize, targetWords, targetSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k + m × k)

n start words × k characters to create masks + m target words × k bits to check

⚡ Linearithmic

Space Complexity

O(n)

Hash set storing n bit masks (integers)

⚡ Linearithmic Space

15.2K Views

Medium Frequency

~25 min Avg. Time

428 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

Bit Mask Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler