Detect permutation in array

Question

Given array, detect all occurrences of the palindrome pattern.

Codemia · Accepted Answer

To detect all occurrences of a palindrome pattern in an array, we can utilize the concept of frequency counting and the properties of palindromes. A palindrome reads the same forwards and backwards, which means that for a sequence of characters (or numbers) to be a palindrome, the characters must have specific counts: all characters must have even counts, except for at most one character which can have an odd count (this character would be the center of the palindrome).

This problem can be approached using a sliding window technique combined with a hash map (or dictionary) to track the frequency of elements within that window. The sliding window will allow us to efficiently check each possible substring for the palindrome property.

1. **Initialization**: Start by defining a hash map to count the frequency of each element.
2. **Sliding Window**: Implement a sliding window of size `n` (the length of the substring we are checking). Initialize the window on the first `n` elements of the array.
3. **Frequency Count**: Populate the hash map with the frequencies of the first window.
4. **Check for Palindrome**: Create a helper function to check if the frequency map can form a palindrome. This involves verifying that at most one character has an odd frequency count.
5. **Slide the Window**: Move the window one element to the right, updating the frequency map by removing the count of the element that is sliding out and adding the count of the element that is sliding in.
6. **Repeat**: Repeat steps 4 and 5 until the end of the array is reached, collecting all starting indices of valid palindrome substrings.

**Example**: For the input array `[1, 2, 3, 2, 1]`, with window size `3`, we would check:
- First window `[1, 2, 3]`: Frequency => {1: 1, 2: 1, 3: 1} (not a palindrome)
- Next window `[2, 3, 2]`: Frequency => {2: 2, 3: 1} (is a palindrome)
- Final window `[3, 2, 1]`: Frequency => {3: 1, 2: 1, 1: 1} (not a palindrome)
- Result: [1] (the starting index of the valid palindrome substring)

```python
def detect_palindrome(arr, n):
    from collections import defaultdict
    result = []
    frequency = defaultdict(int)
    length = len(arr)

# Initial population of the frequency map
    for i in range(n):
        frequency[arr[i]] += 1

def is_palindrome(freq_map):
        odd_count = sum(1 for count in freq_map.values() if count % 2 != 0)
        return odd_count <= 1

# Check initial window
    if is_palindrome(frequency):
        result.append(0)

# Sliding window
    for i in range(n, length):
        frequency[arr[i]] += 1  # Add new element to the window
        frequency[arr[i - n]] -= 1  # Remove the element going out of the window

if frequency[arr[i - n]] == 0:
            del frequency[arr[i - n]]  # Clean up to avoid unnecessary counts

if is_palindrome(frequency):
            result.append(i - n + 1)

return result

# Example usage:
print(detect_palindrome([1, 2, 3, 2, 1], 3))  # Output: [1]
```

The time complexity of this solution is O(n * k), where n is the length of the array and k is the size of the window (constant due to the fixed range of possible characters). The space complexity is O(m), where m is the number of unique elements in the input array (size of the frequency map). In the worst case, if all elements are unique, m can equal n. However, since the problem is constrained by typical input sizes in interview settings, this is manageable.

1. **Empty Array**: If the input array is empty, the output should be an empty list `[]` since there are no substrings to check.
2. **Single Element**: An array with a single element like `[1]` should return `[0]` as the only substring of length 1 is a palindrome.
3. **All Unique Elements**: An array like `[1, 2, 3]` with no repeating elements should return an empty list `[]` since no palindromic substrings exist.
4. **All Same Elements**: An array like `[1, 1, 1, 1]` of the same element should return all starting indices of every possible window since all substrings are palindromes. For size 2, it would return [0, 1, 2].

Detect permutation in array

Waymo

What the Interviewer Expects

Key Topics to Cover

How to Approach This

Possible Follow-up Questions

Sharpen Your Skills on Codemia

Sample Answer

Problem Analysis

Approach

Submit Your Answer

Waymo Software Engineer Interview Guide

Related Questions

Binary Search on graph

Count kth largest element in array

Find connected components in string

Merge Three Sorted strings

Binary Search on string