85 lines
2.1 KiB
Markdown
85 lines
2.1 KiB
Markdown
---
|
|
tags:
|
|
- design-patterns
|
|
---
|
|
|
|
# Multiple pointers
|
|
|
|
The multiple pointers pattern can be useful for moving through an array and
|
|
comparing elements against each other in a time-efficient manner and without
|
|
costly multiple loops.
|
|
|
|
## Example: moving pairs
|
|
|
|
In this example we shuffle through an array creating a pair from each element
|
|
encountered. Thus for an array such as `[4, 3, 2, 1, 3, 6, 7]` we would return
|
|
`[ [ 4, 3 ], [ 3, 2 ], [ 2, 1 ], [ 1, 3 ], [ 3, 6 ], [ 6, 7 ] ]`.
|
|
|
|
```js
|
|
function movingPairs(arr) {
|
|
const store = [];
|
|
let left = 0;
|
|
let right = 1;
|
|
for (left; left < arr.length - right; left++) {
|
|
store.push([arr[left], arr[right + left]]);
|
|
}
|
|
return store;
|
|
}
|
|
```
|
|
|
|
## Example: identify unique values
|
|
|
|
An example application of the above pattern would be identifying the number of
|
|
unique values in an array that contains duplicates. One way to do this in
|
|
JavaScript would be to use a Set however this is a more generic approach that
|
|
only requires a single loop:
|
|
|
|
```js
|
|
function uniqueValues(arr) {
|
|
if (!arr.length) {
|
|
return 0;
|
|
} else {
|
|
let count = 1;
|
|
let left = 0;
|
|
let right = 1;
|
|
for (right; right < arr.length; right++) {
|
|
if (arr[left] !== arr[right]) {
|
|
count++;
|
|
}
|
|
left++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
}
|
|
```
|
|
|
|
This works by having two pointers at either end of the array; one moving from
|
|
the right and one moving from the left. Whilst the right pointer is less than
|
|
the array length, the left pointer is incremented as the right moves closer to
|
|
it. At each incrementation, the values of pointers (used as indexes) are
|
|
compared for uniqueness, and a count is kept.
|
|
|
|
## Example: identify duplicates
|
|
|
|
This is very similar to the above but this time we are looking for duplicates
|
|
rather than unique values.
|
|
|
|
```js
|
|
function areThereDuplicatesPointer(...input) {
|
|
let start = 0;
|
|
let next = 1;
|
|
while (next < input.length) {
|
|
let same = input[start] === input[next];
|
|
if (same) {
|
|
return true;
|
|
}
|
|
start++;
|
|
next++;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
console.log(areThereDuplicatesPointer(1, 2, 3)); // false
|
|
console.log(areThereDuplicatesPointer(1, 2, 2)); // true
|
|
```
|