# JavaScript Array Logic Questions

## Here are some **JavaScript array logic questions** commonly asked in interviews.

### 1\. **Find the Duplicate Numbers in an Array**

```javascript
const arr = [1, 2, 3, 2, 4, 5, 1];
const duplicates = arr.filter((item, index) => arr.indexOf(item) !== index);

console.log([...new Set(duplicates)]); // [2, 1]
```

### 2\. **Find the Missing Number in a Sequence**

```javascript
const arr = [1, 2, 4, 5]; // Missing: 3
const n = 5;
const total = (n * (n + 1)) / 2;
const sum = arr.reduce((a, b) => a + b, 0);

console.log(total - sum); // 3
```

### 3\. **Remove Duplicates from an Array**

```javascript
const arr = [1, 2, 2, 3, 4, 4];
const unique = [...new Set(arr)];

console.log(unique); // [1, 2, 3, 4]
```

### 4\. **Find the First Non-Repeating Element**

```javascript
const arr = [4, 5, 1, 2, 0, 4];
const firstUnique = arr.find(item => arr.indexOf(item) === arr.lastIndexOf(item));

console.log(firstUnique); // 5
```

### 5\. **Group Elements by Occurrence Count**

```javascript
const arr = ['a', 'b', 'a', 'c', 'b', 'a'];

const count = arr.reduce((acc, val) => {
  acc[val] = (acc[val] || 0) + 1;
  return acc;
}, {});

console.log(count); // { a: 3, b: 2, c: 1 }
```

### 6\. **Chunk an Array Into Smaller Arrays**

```javascript
function chunkArray(arr, size) {
  const result = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}

console.log(chunkArray([1, 2, 3, 4, 5], 2)); // [[1,2],[3,4],[5]]
```

7\. **Intersection of Two Arrays**

```javascript
const arr1 = [1, 2, 3, 4];
const arr2 = [2, 4, 6];
const intersection = arr1.filter(item => arr2.includes(item));

console.log(intersection); // [2, 4]
```

### 8\. **Check if Two Arrays are Equal**

```javascript
function arraysEqual(a, b) {
  if (a.length !== b.length) return false;
  return a.every((val, index) => val === b[index]);
}

console.log(arraysEqual([1, 2, 3], [1, 2, 3])); // true
```

### 9\. **Move All Zeros to End**

```javascript
function moveZeros(arr) {
  const nonZero = arr.filter(n => n !== 0);
  const zeroCount = arr.length - nonZero.length;
  return [...nonZero, ...Array(zeroCount).fill(0)];
}

console.log(moveZeros([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]
```

### 10\. **Find Second Largest Number**

```javascript
function secondLargest(arr) {
  const unique = [...new Set(arr)].sort((a, b) => b - a);
  return unique[1] ?? null;
}

console.log(secondLargest([10, 5, 10, 8])); // 8
```

### 11\. **Remove Falsy Values from Array**

```javascript
const arr = [0, "hello", false, undefined, "", 5];
const cleaned = arr.filter(Boolean);

console.log(cleaned); // ["hello", 5]
```