Free Code Camp - Pairwise

I'm working through the Free Code Camp syllabus and I'm on to Intermediate JavaScript Algorithms. This Pairwise problem was the last challenge in that section. The section came just after "Object Oriented JavaScript." So I figured they were looking for an OO solution, but the instructions included a link to MDN's array.reduce(). My solution doesn't use array.reduce() and I'd really appreciate some feedback on what I could have done better to make my code more compact and efficient. It feels a little clunky but passes all the tests.

The instructions


Return the sum of all indices of elements of 'arr' that can be paired
with one other element to form a sum that equals the value in the
second argument 'arg'. If multiple sums are possible, return the
smallest sum. Once an element has been used, it cannot be reused to
pair with another.


For example, pairwise([1, 4, 2, 3, 0, 5], 7) should return 11 because
4, 2, 3 and 5 can be paired with each other to equal 7.


pairwise([1, 3, 2, 4], 4) would only equal 1, because only the first
two elements can be paired to equal 4, and the first element has an
index of 0!


Remember to use RSAP if you get stuck. Try to pair program. Write your
own code.


Here are some helpful links:

Array.reduce()

My Solution

```
function pairwise(arr, arg) {
this.objects = [];
var total = 0;

function Element(value, index) {
this.value = value;
this.index = index;
this.used = 0;
}

for (var i = 0; i < arr.length; i++) {
this.objects.push(new Element(arr[i], i));
}

for (var j = 0; j < objects.length; j++) {
if (objects[j].used === 0) {
for (var k = 0; k < objects.length; k++) {
if (objects[k].used === 0 && objects[k].index != objects[j].index) {
if (arg - objects[j].value == objects[k].value) {
total = total + objects[j].index + objects[k].index;

I looked through your code and it is a valid solution, but you could reduce your code base by better leveraging the functions that JavaScript already provides, such as Array.prototype.indexOf().

For example, instead of building a new class-like-function (Element) to track the appearance of a certain index, I simply made a deep copy of the the initial array and parsed it with indexOf().

Moreover, in your code, when you first declare this.objects = [], this actually refers to the global scope (window object). As you can see, you are calling pairwise without building a new instance (new keyword). In this case, thus the this keyword is bound to the global window object.

Please find below my take on it:

function pairwise(arr, arg) {

  var result = 0,
      newArr = [],
      //Used to hold the indices that we have already used to form our sum
      indices = [];

  //Loop through arr and create a deep copy of it in newArr
  for(var k = 0; k < arr.length; k++) {
    newArr.push(arr[k]);
  }

  //Loop through arr
  for(var i = 0; i < arr.length; i++) {

    //Loop through newArr
    for(var j = 0; j < newArr.length; j++) {
      //Since we want to add different elements of the array, we want to avoid adding the same element
      if(i !== j) {
        //If the sum of two elements is equal to arg AND the indices that we have in i and j are not part of the indices array
        //Indices array is used to hold the already used indices, thus ensuring the accurate parsing of the parameters
        if(arr[i] + newArr[j] === arg && indices.indexOf(i) === -1 && indices.indexOf(j) === -1) {
          //Sum the indices up
          result += i + j;
          //Push the indices in the indices array in order to not use them in further iterations
          indices.push(i, j);
        }
      }
    }
  }

  return result;
}

pairwise([1,4,2,3,0,5], 7);

StackExchange Code Review Q#98448, answer score: 3