Solution 1 - Brute Force

Iterate through every pair of numbers using two nested loops. For each pair, check if they sum to the target. Return the indices when a match is found.

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Brute Force Approach """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Brute Force using `enumerate()`

Same brute force logic, but uses Python's enumerate() for cleaner index tracking instead of range(len(...)).

TimeComplexity: O(n^2)

SpaceComplexity: O(1)

""" 0001.1 - Solution 1 - Using Enumerate """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        """Two Sum Function"""
        for key1, num1 in enumerate(nums):
            for key2, num2 in enumerate(nums[key1 + 1 :], key1 + 1):
	              # enumerate(iterable, start=1) -> start value determines starting index
                # Printing value and key will output 1 i , 2 j, 3 k, 4 l 
                if num1 + num2 == target:
                    return [key1, key2]


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().twoSum([3, 3], 6))
    print(Solution().twoSum([3, 2, 4], 6))
    print(Solution().twoSum([2, 7, 11, 15], 9))


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 1 - Brute Force using Set

Given a string allowed of distinct characters and an array of strings words, count how many strings in words are "consistent" — meaning every character in the word appears in allowed. The brute force approach converts allowed into a set, then for each word checks if every character is in that set using all().

TimeComplexity: O(n \cdot m)

SpaceComplexity: O(k)

""" 1684.1 - Count the Number of Consistent Strings - Solution 1 - Brute Force using Set """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        """Count Consistent Strings Function"""
        allowed_set = set(allowed)
        count = 0
        for word in words:
            is_consistent = True
            for char in word:
                if char not in allowed_set:
                    is_consistent = False
                    break
            if is_consistent:
                count += 1
        return count


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().countConsistentStrings("ab", ["ad", "bd", "aaab", "baa", "badab"]))
    # Expected: 2
    print(Solution().countConsistentStrings("abc", ["a", "b", "c", "ab", "ac", "bc", "abc"]))
    # Expected: 7
    print(Solution().countConsistentStrings("cad", ["cc", "acd", "b", "ba", "bac", "bad", "ac", "d"]))
    # Expected: 4


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 2 - Pythonic using `all()` and Set

Same set-based approach but written in a more Pythonic style using all() and sum() with generator expressions for a concise one-pass count.

TimeComplexity: O(n \cdot m)

SpaceComplexity: O(k)

""" 1684.2 - Count the Number of Consistent Strings - Solution 2 - Pythonic using all() """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        """Count Consistent Strings Function"""
        allowed_set = set(allowed)
        return sum(all(c in allowed_set for c in word) for word in words)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().countConsistentStrings("ab", ["ad", "bd", "aaab", "baa", "badab"]))
    # Expected: 2
    print(Solution().countConsistentStrings("abc", ["a", "b", "c", "ab", "ac", "bc", "abc"]))
    # Expected: 7
    print(Solution().countConsistentStrings("cad", ["cc", "acd", "b", "ba", "bac", "bad", "ac", "d"]))
    # Expected: 4


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 3 - Using Set Subset Check

Instead of checking each character individually, convert each word into a set and check if it is a subset of the allowed set using Python's <= operator (or issubset()). This is cleaner and leverages built-in set operations.

TimeComplexity: O(n \cdot m)

SpaceComplexity: O(k)

""" 1684.3 - Count the Number of Consistent Strings - Solution 3 - Set Subset Check """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        """Count Consistent Strings Function"""
        allowed_set = set(allowed)
        return sum(set(word) <= allowed_set for word in words)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().countConsistentStrings("ab", ["ad", "bd", "aaab", "baa", "badab"]))
    # Expected: 2
    print(Solution().countConsistentStrings("abc", ["a", "b", "c", "ab", "ac", "bc", "abc"]))
    # Expected: 7
    print(Solution().countConsistentStrings("cad", ["cc", "acd", "b", "ba", "bac", "bad", "ac", "d"]))
    # Expected: 4


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

Solution 4 - Using Bitmask

Represent each character as a bit in a 26-bit integer. Convert allowed to a bitmask, then for each word build its bitmask and check if all bits are covered by the allowed mask using bitwise AND. This avoids hash table overhead and runs in constant space.

TimeComplexity: O(n \cdot m)

SpaceComplexity: O(1)

""" 1684.4 - Count the Number of Consistent Strings - Solution 4 - Bitmask Approach """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        """Count Consistent Strings Function"""
        allowed_mask = 0
        for c in allowed:
            allowed_mask |= 1 << (ord(c) - ord('a'))

        count = 0
        for word in words:
            word_mask = 0
            for c in word:
                word_mask |= 1 << (ord(c) - ord('a'))
            if word_mask & allowed_mask == word_mask:
                count += 1
        return count


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    print(Solution().countConsistentStrings("ab", ["ad", "bd", "aaab", "baa", "badab"]))
    # Expected: 2
    print(Solution().countConsistentStrings("abc", ["a", "b", "c", "ab", "ac", "bc", "abc"]))
    # Expected: 7
    print(Solution().countConsistentStrings("cad", ["cc", "acd", "b", "ba", "bac", "bad", "ac", "d"]))
    # Expected: 4


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

1684 - Count the Number of Consistent Strings