Is there a way to avoid number to string conversion & nested loops for performance?

Question

I just took a coding test online and this one question really bothered me. My solution was correct but was rejected for being unoptimized. The question is as following:

Write a function combineTheGivenNumber taking two arguments:

1. numArray: number[]
2. num: a number

The function should check all the concatenation pairs that can result in making a number equal to num and return their count.

E.g. if numArray = [1, 212, 12, 12] & num = 1212 then we will have return value of 3 from combineTheGivenNumber

The pairs are as following:

1. numArray[0]+numArray[1]
2. numArray[2]+numArray[3]
3. numArray[3]+numArray[2]

The function I wrote for this purpose is as following:

function combineTheGivenNumber(numArray, num) {
  //convert all numbers to strings for easy concatenation
  numArray = numArray.map(e => e+'');
  //also convert the `hay` to string for easy comparison
  num = num+'';
  let pairCounts = 0;
  
  // itereate over the array to get pairs
  numArray.forEach((e,i) => {
    numArray.forEach((f,j) => {
    if(i!==j && num === (e+f)) {
        pairCounts++;
       }
    });
  });
  
  return pairCounts;
}

console.log('Test 1: ', combineTheGivenNumber([1,212,12,12],1212)); 

console.log('Test 2: ', combineTheGivenNumber([4,21,42,1],421)); 

From my experience, I know conversion of number to string is slow in JS, but I am not sure whether my approach is wrong/lack of knowledge or does the tester is ignorant of this fact. Can anyone suggest further optimization of the code snipped?

Elimination of string to number to string will be a significant speed boost but I am not sure how to check for concatenated numbers otherwise.

Answer 1

Here's a simplified, and partially optimised approach with 2 loops:

// let's optimise 'combineTheGivenNumber', where
// a=array of numbers AND n=number to match
const ctgn = (a, n) => {
  // convert our given number to a string using `toString` for clarity
  // this isn't entirely necessary but means we can use strict equality later
  const ns = n.toString();
  
  // reduce is an efficient mechanism to return a value based on an array, giving us
  // _=[accumulator], na=[array number] and i=[index]
  return a.reduce((_, na, i) => {
    // convert our 'array number' to an 'array number string' for later concatenation
    const nas = na.toString();
    
    // iterate back over our array of numbers ... we're using an optimised/reverse loop
    for (let ii = a.length - 1; ii >= 0; ii--) {
      // skip the current array number
      if (i === ii) continue;
      
      // string + number === string, which lets us strictly compare our 'number to match'
      // if there's a match we increment the accumulator
      if (a[ii] + nas === ns) ++_;  
    }
    
    // we're done
    return _;
  }, 0);
}

Answer 2

I like your approach of going to strings early. I can suggest a couple of simple optimizations.

You only need the numbers that are valid "first parts" and those that are valid "second parts"

You can use the javascript .startsWith and .endsWith to test for those conditions. All other strings can be thrown away.

The lengths of the strings must add up to the length of the desired answer

Suppose your target string is 8 digits long. If you have 2 valid 3-digit "first parts", then you only need to know how many valid 5-digit "second parts" you have. Suppose you have 9 of them. Those first parts can only combine with those second parts, and give you 2 * 9 = 18 valid pairs.

You don't actually need to keep the strings!

It struck me that if you know you have 2 valid 3-digit "first parts", you don't need to keep those actual strings. Knowing that they are valid 2-digit first parts is all you need to know.

So let's build an array containing:

  How many valid 1-digit first parts do we have?,
  How many valid 2-digit first parts do we have?,
  How many valid 3-digit first parts do we have?,
  etc.

And similarly an array containing the number of valid 1-digit second parts, etc.

X first parts and Y second parts can be combined in X * Y ways

Except if the parts are the same length, in which case we are reusing the same list, and so it is just X * (Y-1).

So not only do we not need to keep the strings, but we only need to do the multiplication of the appropriate elements of the arrays.

5 1-char first parts & 7 3-char second parts = 5 * 7 = 35 pairs

6 2-char first part & 4 2-char second parts = 6 * (4-1) = 18 pairs

etc

So this becomes extremely easy. One pass over the strings, tallying the "first part" and "second part" matches of each length. This can be done with an if and a ++ of the relevant array element.

Then one pass over the lengths, which will be very quick as the array of lengths will be very much shorter than the array of actual strings.

function combineTheGivenNumber(numArray, num) {
  const sElements = numArray.map(e => "" + e);
  const sTarget = "" + num;
  const targetLength = sTarget.length
  const startsByLen = (new Array(targetLength)).fill(0);
  const endsByLen = (new Array(targetLength)).fill(0);

  sElements.forEach(sElement => {
    if (sTarget.startsWith(sElement)) {
      startsByLen[sElement.length]++
    }
    if (sTarget.endsWith(sElement)) {
      endsByLen[sElement.length]++
    }
  })
  // We can now throw away the strings. We have two separate arrays:
  // startsByLen[1] is the count of strings (without attempting to remove duplicates) which are the first character of the required answer
  // startsByLen[2] similarly the count of strings which are the first 2 characters of the required answer
  // etc.
  // and endsByLen[1] is the count of strings which are the last character ...
  // and endsByLen[2] is the count of strings which are the last 2 characters, etc.

  let pairCounts = 0;

  for (let firstElementLength = 1; firstElementLength < targetLength; firstElementLength++) {
    const secondElementLength = targetLength - firstElementLength;
    if (firstElementLength === secondElementLength) {
      pairCounts += startsByLen[firstElementLength] * (endsByLen[secondElementLength] - 1)
    } else {
      pairCounts += startsByLen[firstElementLength] * endsByLen[secondElementLength]
    }
  }

  return pairCounts;
}

console.log('Test 1: ', combineTheGivenNumber([1, 212, 12, 12], 1212));
console.log('Test 2: ', combineTheGivenNumber([4, 21, 42, 1], 421));

Answer 3

Depending on a setup, the integer slicing can be marginally faster

Although in the end it falls short

Also, when tested on higher N values, the previous answer exploded in jsfiddle. Possibly a memory error.

As far as I have tested with both random and hand-crafted values, my solution holds. It is based on an observation, that if X, Y concantenated == Z, then following must be true:
Z - Y == X * 10^(floor(log10(Y)) + 1)
an example of this:
1212 - 12 = 1200
12 * 10^(floor((log10(12)) + 1) = 12 * 10^(1+1) = 12 * 100 = 1200

Now in theory, this should be faster then manipulating strings. And in many other languages it most likely would be. However in Javascript as I just learned, the situation is a bit more complicated. Javascript does some weird things with casting that I haven't figured out yet. In short - when I tried storing the numbers(and their counts) in a map, the code got significantly slower making any possible gains from this logarithm shenanigans evaporate. Furthermore, storing them in a custom-crafted data structure isn't guaranteed to be faster since you have to build it etc. Also it would be quite a lot of work.

As it stands this log comparison is ~ 8 times faster in a case without(or with just a few) matches since the quadratic factor is yet to kick in. As long as the possible postfix count isn't too high, it will outperform the linear solution. Unfortunately it is still quadratic in nature with the breaking point depending on a total number of strings as well as their length.

So if you are searching for a needle in a haystack - for example you are looking for a few pairs in a huge heap of numbers, this can help. In the other case of searching for many matches, this won't help. Similarly, if the input array was sorted, you could use binary search to push the breaking point further up.

In the end, unless you manage to figure out how to store ints in a map(or some custom implementation of it) in a way that doesn't completely kill the performance, the linear solution of the previous answer will be faster. It can still be useful even with the performance hit if your computation is going to be memory heavy. Storing numbers takes less space then storing strings.

var log10 = Math.log(10)
function log10floored(num) {
     return Math.floor(Math.log(num) / log10)
}
function combineTheGivenNumber(numArray, num) {
      count = 0
      for (var i=0; i!=numArray.length; i++) {
        let portion = num - numArray[i]
        let removedPart = Math.pow(10, log10floored(numArray[i]))
        if (portion % (removedPart * 10) == 0) {
          for (var j=0; j!=numArray.length; j++) {
                    
                        if (j != i && portion / (removedPart * 10) == numArray[j] ) {
                    count += 1
             }
           }  
         }  
        }
      return count
      
      }
 //The previous solution, that I used for timing, comparison and check purposes 
 function combineTheGivenNumber2(numArray, num) {
  const strings = new Map();
  for (const num of numArray) {
    const str = String(num);
    strings.set(str, 1 + (strings.get(str) ?? 0));
  }
  const whole = String(num);
  
  let pairCounts = 0;
  for (const [prefix, pCount] of strings) {
    if (!whole.startsWith(prefix))
      continue;
    const suffix = whole.slice(prefix.length);
    if (strings.has(suffix)) {
      let sCount = strings.get(suffix);
      if (suffix == prefix) sCount--; // no self-concatenation
      pairCounts += pCount*sCount;
    }
  }
  return pairCounts;
}
var myArray = []
for (let i =0; i!= 10000000; i++) {
    myArray.push(Math.floor(Math.random() * 1000000))
}
var a = new Date()
t1 = a.getTime()
console.log('Test 1: ', combineTheGivenNumber(myArray,15285656)); 
var b = new Date()
t2 = b.getTime()
console.log('Test 2: ', combineTheGivenNumber2(myArray,15285656)); 
var c = new Date()
t3 = c.getTime()

console.log('Test1 time: ', t2 - t1)
console.log('test2 time: ', t3 - t2)

Small update

As long as you are willing to take a performance hit with the setup and settle for the ~2 times performance, using a simple "hashing" table can help.(Hashing tables are nice and tidy, this is a simple modulo lookup table. The principle is similar though.)

Technically this isn't linear, practicaly it is enough for the most cases - unless you are extremely unlucky and all your numbers fall in the same bucket.

function combineTheGivenNumber(numArray, num) {
  count = 0
  let size = 1000000
  numTable = new Array(size)
  for (var i=0; i!=numArray.length; i++) {
    let idx = numArray[i] % size
    if (numTable[idx] == undefined) {
        numTable[idx] = [numArray[i]]
    } else {
      numTable[idx].push(numArray[i])
    }       
  }
  for (var i=0; i!=numArray.length; i++) {
    let portion = num - numArray[i]
    let removedPart = Math.pow(10, log10floored(numArray[i]))
    if (portion % (removedPart * 10) == 0) {
      if (numTable[portion / (removedPart * 10) % size] != undefined) {
        let a = numTable[portion / (removedPart * 10) % size]
        for (var j=0; j!=a.length; j++) {

          if (j != i && portion / (removedPart * 10) == a[j] ) {
              count += 1
           }
         }  
       }  
      }
    }
  return count
  
  }

Answer 4

Elimination of string to number to string will be a significant speed boost

No, it won't.

Firstly, you're not converting strings to numbers anywhere, but more importantly the exercise asks for concatenation so working with strings is exactly what you should do. No idea why they're even passing numbers. You're doing fine already by doing the conversion only once for each number input, not every time your form a pair. And last but not least, avoiding the conversion will not be a significant improvement.

To get a significant improvement, you should use a better algorithm. @derpirscher is correct in his comment: "[It's] the nested loop checking every possible combination which hits the time limit. For instance for your example, when the outer loop points at 212 you don't need to do any checks, because regardless, whatever you concatenate to 212, it can never result in 1212".

So use

let pairCounts = 0;
numArray.forEach((e,i) => {
  if (num.startsWith(e)) {
//^^^^^^^^^^^^^^^^^^^^^^
    numArray.forEach((f,j) => {
      if (i !== j && num === e+f) {
        pairCounts++;
      }
    });
  }
});

You might do the same with suffixes, but it becomes more complicated to rule out concatenation to oneself there.

Optimising further, you can even achieve a linear complexity solution by putting the strings in a lookup structure, then when finding a viable prefix just checking whether the missing part is an available suffix:

function combineTheGivenNumber(numArray, num) {
  const strings = new Map();
  for (const num of numArray) {
    const str = String(num);
    strings.set(str, 1 + (strings.get(str) ?? 0));
  }
  const whole = String(num);
  
  let pairCounts = 0;
  for (const [prefix, pCount] of strings) {
    if (!whole.startsWith(prefix))
      continue;
    const suffix = whole.slice(prefix.length);
    if (strings.has(suffix)) {
      let sCount = strings.get(suffix);
      if (suffix == prefix) sCount--; // no self-concatenation
      pairCounts += pCount*sCount;
    }
  }
  return pairCounts;
}

(the proper handling of duplicates is a bit difficile)