# Problem Solving Strategies for Algorithms
<p>Algorithms can be really intimidating, especially if you don't know how to approach them. This article will cover some common problem solving strategies that you can use to solve alot of common algorithms, please note that these problem solving strategies won't work for every algorithm and may not produce the best efficiencies for ones they do work on</p>
<br />
<h3>Multiple Pointers</h3>
<p>One of the best approaches to solving a problem that involves some kind of looping is creating multiple pointers for that particular loop, this is a fantastic strategy for not only simplifying the problem at hand, but also tends to make problems more efficient. </p>
<br>
<p>To show how we can use multiple pointers, here's a very basic example of a common problem where multiple pointers can be used: reversing an array</p>

```javascript
function reverseArr(arr){
  let right = arr.length - 1;
  let left = 0;
  while(left < right){
    const temp = arr[right];
    arr[right] = arr[left];
    arr[left] = temp;
    right--;
    left++
  }
  return arr;
}
```

Here we create two pointers, one that points to the beginning of the array and another that points to the end. This is great because it lets us essentially keep track of multiple portions of the array at one time, saving us from having to loop more than once.

Here's another example:
Merging two sorted arrays
```javascript
function mergeArrs(arr1,arr2){
  let pt1 = 0;
  let pt2 = 0;
  let mergedArr = new Array(arr1.length+arr2.length);
  while(pt1 < arr1.length || pt2 < arr2.length){
    const num1 = arr1[pt1];
    const num2 = arr2[pt2];
    if(pt2 >= arr2.length || num1 <= num2){
      mergedArr[pt1+pt2] = num1;
      pt1++;
    }else{
      mergedArr[pt1+pt2] = num2;
      pt2++;
    }
  }
  return mergedArr;
}
```
Here we have a pointer that points at a number in the first array and another that points at a number in the second array. We compare the numbers each pointer is pointing at and add them to our merged array based on which one is less than the other. In the case a pointer reaches the end of one array, we simply add the other number into our array. This lets us keep track of both arrays and do comparisons between them in the same loop iterations.

<h3>Shifting Frames</h3>
<p>A common theme that comes up with algorithms are problems that require a "frame" of solutions. For example, lets say we're given an array and we want to retrieve the maximum subarray sum, for example:</p>
```javascript
maxSubSum([1,2,-10,9,-3]) // Returns 9 because the maximum subarray sum is [9]
maxSubSum([1,2,-10,2,-3]) // Returns 3 because the maximum subarray sum is [1,2]
```
<p> Notice in this problem, our solution relies on maximizing a contiguous portion of our input. These problems can be solved with shifting frame in which we keep track of a frame of the input that can grow or shorten accordingly for example: </p>
For the input: [1,2,-10,-3], we can have a pointer which marks the start of our frame and another that marks the end, each would start at the origin point since our answer could theoretically just be one number from our subarray like so:
<br>
st <br>
end <br>
[1,2,-10,3] <br>
In this first iteration, since both of our pointers are at 1, our current maximum subarray is [1] which has a sum of 1, we can now look ahead at the next value and see if expanding our frame and including that value will increase our current maximum value. In this case, [1,2] equals 3 which is greater than [1], so we move our end pointer forwards: <br>
<br>
st <br>
  end <br>
[1,2,-10,3] <br>
We can continue this process until we reach the end of our array to return 3. Our shifting frame ends up being [1,2]. What if our example was a bit more complicated? For example, what if we have to move our head pointer as well? Here's a problem where that scenario would be the case:
<br>
st<br>
end<br>
[-1,2,3,-10,3]<br>
In our first iteration, our max sum is -1, we look ahead to 2, since 2+-1 is greater than 1, we move our end pointer forwards <br>
<br>
st<br>
  end<br>
[-1,2,3,-10,3]<br>
In our next iteration, adding 3 also increases our max sum of 1, so we move our pointer again and end with a max sum of 4
<br>
st<br>
  end<br>
[-1,2,3,-10,3]<br>
If we continue to the end, we'll notice no more additions will make 4 greater, so we return [-1,2,3] => 4, however 4 isn't our largest sum, [2,3] => 5 is. How do we move our start pointer forwards? We can do so by simply comparing our start number to the next number in the frame; if our start number is less than the current number and is negative, we simply move our frame forward. Alternatively, we can check if the start number + the next number in the frame is less than the next number in the frame (is -1+2 < 2?); if it fits either of these cases, we simply move the start pointer forwards.