Validate array symmetric

Question

Given an array of integers, determine if the array is symmetric, meaning it reads the same forwards and backwards. Your function should return a boolean value: true if the array is symmetric and false otherwise. For example, the array [1, 2, 3, 2, 1] is symmetric, while [1, 2, 3, 4, 5] is not.

Codemia · Accepted Answer

To determine if an array is symmetric, we can utilize the **two pointers** technique. This approach applies here because we need to compare elements from both ends of the array, moving towards the center. Specifically, we can initialize one pointer at the beginning (left) and another at the end (right) of the array. If the elements at these pointers are equal, we then move the left pointer one step to the right and the right pointer one step to the left, continuing this process until the pointers meet or cross each other. If we find any mismatch during this process, we can conclude that the array is not symmetric.

1. Initialize two pointers: `left` at index 0 and `right` at the last index of the array (`len(array) - 1`).  
2. While `left` is less than `right`:  
   - Compare the elements at these pointers: `array[left]` and `array[right]`.  
   - If they are not equal, return `False`.  
   - If they are equal, increment the `left` pointer by 1 and decrement the `right` pointer by 1.  
3. If we complete the loop without finding any unequal elements, return `True`.  
**Example:**  
For the input array `[1, 2, 3, 2, 1]`:  
- Start: `left` = 0, `right` = 4 (values are 1 and 1, equal)  
- Move pointers: `left` = 1, `right` = 3 (values are 2 and 2, equal)  
- Move pointers: `left` = 2, `right` = 2 (middle element, loop ends, symmetric)  
Return `True`.  
For the input array `[1, 2, 3, 4, 5]`:  
- Start: `left` = 0, `right` = 4 (values are 1 and 5, not equal)  
Return `False`.

Here is the Python implementation for the solution we discussed:
```python
def is_symmetric(array):
    left = 0
    right = len(array) - 1
    while left < right:
        if array[left] != array[right]:
            return False
        left += 1
        right -= 1
    return True
```
This function checks symmetry by iterating through the array with two pointers.

The time complexity of this algorithm is **O(n)**, where n is the number of elements in the array. This is because we potentially check each element once from both ends until the pointers meet. The space complexity is **O(1)** since we are using only a constant amount of extra space for the pointers, regardless of the input size. Given the constraints of the problem, this approach is efficient and optimal.

1. **Empty array:** An empty array `[]` is considered symmetric since there are no elements to compare. The function should return `True`.
2. **Single element array:** An array like `[1]` is symmetric as it reads the same forwards and backwards. The function should return `True`.
3. **Arrays with negative numbers:** Arrays like `[-1, -2, -1]` should also be handled correctly, returning `True` for symmetry.  
4. **Arrays with an even number of elements:** Arrays like `[1, 2, 2, 1]` should return `True`, while `[1, 2, 3, 4]` should return `False`.  
5. **Arrays with mixed types (if allowed):** If the problem constraints allow mixed types, e.g., `[1, '2', 1]`, the function should handle type comparisons correctly and return `False` as they are not equal.

Validate array symmetric

Twitter/X

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

Twitter/X Machine Learning 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