JavaScript function with loops not running fast enough

Question

I'm trying to practice for an interview and found a challenge online to write a function that will take an array of numbers and only return values that exist just once in the array, and return those values in order. For example, the array [1, 3, 5, 6, 1, 4, 3, 6] should return [4, 5].

I have a script that is passing the tests but for some of the tests is running too slow. Am I going about this wrong? Is there some fundamental way to speed this up? The script starts with findTheNumbers, and a is the array input:

function findTheNumbers(a) {
    var retVal = [];
    var nonUnique = [];

    for (var i = 0; i < a.length; i++){
        var isUnique = true;
        if (i != 0){
            for (var j = 0; j < nonUnique.length; j++){
                if (a[i] == nonUnique[j]){
                    isUnique = false;
                    break;
                }
            }
        }

        if (isUnique){
            for (var k = 0; k < a.length; k++){
                if (a[i] == a[k] && i != k){
                    isUnique = false;
                    nonUnique.push(a[i]);
                    break;
                }
            }    
        }

        if (isUnique){
            retVal.push(a[i]);
            if (retVal.length == 2){
                break;
            }
        }


    }

    retVal = sortArrayOfLengthOfTwo(retVal);
    return retVal;
}

function sortArrayOfLengthOfTwo(array){
    var retVal = [];
    if (array[0] > array[1]){
        retVal.push(array[1]);
        retVal.push(array[0]);
    } else {
        retVal = array;
    }

    return retVal;
}

UPDATE -

Not sure where the best place for this is, but here is my new version based on the accepted answer's hints (which worked SO much faster):

function findTheNumbers(a) {
    var retVal = [];
    var dict = {};
    for (var i = 0; i < a.length; i++){
        dict[a[i]] = 1 + (dict[a[i]] || 0);
    }

    for (var key in dict){
        if (dict[key] == 1){
            retVal.push(parseInt(key));
        }
    }

    return retVal;
}

Answer 1

When a program is too slow, the rule of thumb is to

• first blame your algorithm
• next blame your implementation (edit: as suggested by Bergi)
• finally blame the language

In your case, you parse the whole array n times, that is, the complexity is o(n^2). You can do the same with only one full parse, and a dictionary of the count for each element.

Edit about your new algorithm

Your new algorithm is very good. For the sake of your interview I have some comments:

• instead of var, you should consider using const as much as possible, and let otherwise
• do not hesitate to put intermediate results within variables
• use more descriptive names for your variables

Here's the way I would implement it:

function findTheUniqueNumbers(a) {
  const numberCounts = {} // I prefer "new Map()" on recent env.
  a.forEach( function(e) {
    const previousCount = numberCounts[e] || 0
    numberCounts[e] = previousCount + 1
  } )

  return Object.keys(numberCounts)
    .filter( function(e) {
      return numberCounts[e] === 1
    } )
}


const uniqueNumber = findTheUniqueNumbers([1, 3, 5, 6, 1, 4, 3, 6])
console.log(uniqueNumber)