Validate array symmetric

Question

Given an array, write a function to determine if it is symmetric, meaning it reads the same forwards and backwards. The function should take an array of integers as input and return a boolean value: true if the array is symmetric, and false otherwise.

Codemia · Accepted Answer

To determine if an array is symmetric (reads the same forwards and backwards), we can recognize that this problem fits well with the **Two Pointers** technique. This approach involves using two indices: one starting from the beginning of the array and the other from the end. We can compare the elements at these two pointers and move them closer until they meet in the middle. If all corresponding elements are equal, the array is symmetric. This approach is efficient for this problem as it allows us to check symmetry in a single pass through the array.

1. Initialize two pointers: `left` starting at index 0 and `right` at the last index of the array (`len(array) - 1`).
2. While `left` is less than `right`, do the following:
   - Compare the elements at `array[left]` and `array[right]`.
   - If they are not equal, return `False` immediately as the array is not symmetric.
   - If they are equal, increment `left` by 1 and decrement `right` by 1.
3. If the loop completes without finding any unequal pairs, return `True` as the array is symmetric.

**Example:** For the array `[1, 2, 3, 2, 1]`, the checks would be: 
- Compare `array[0]` (1) with `array[4]` (1): equal.
- Compare `array[1]` (2) with `array[3]` (2): equal.
- Compare `array[2]` (3) with itself: equal. 
The array is symmetric, so the function returns `True`.

Here is the Python solution implementing the above approach:

```python
def is_symmetric(array):
    left, right = 0, len(array) - 1
    while left < right:
        if array[left] != array[right]:
            return False
        left += 1
        right -= 1
    return True
```
This function checks the symmetry of the array by using two pointers, ensuring an efficient comparison.

The time complexity of this solution is **O(n)**, where `n` is the length of the array. This is because we potentially check each element once as we move both pointers towards the center. The space complexity is **O(1)**, as we are only using a fixed amount of space for the pointers and not utilizing any additional data structures that scale with input size.

1. **Empty Array:** An empty array `[]` should return `True`, as it is considered symmetric by definition.
2. **Single Element Array:** An array with a single element, e.g., `[5]`, should also return `True`.
3. **Two Elements:** Arrays like `[1, 1]` should return `True`, while `[1, 2]` should return `False`.
4. **Negative Numbers:** The function must handle negative numbers correctly, e.g., `[-1, -2, -1]` should return `True`.
5. **Arrays with Different Types:** If the array contains different data types (like integers and strings), it should return `False` on comparison, e.g., `[1, '1', 1]`.

Validate array symmetric

SentinelOne

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

SentinelOne 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