How should I match a random number with one of these values?

Question

I currently have this object of levels and their exp requirement.

const levels = {
  1: 50,
  2: 75,
  3: 125,
  4: 200,
  5: 350,
  6: 500,
  7: 1000,
  8: 1250,
  9: 2500,
  10: 5000,
  11: 7500,
  12: 10000,
  13: 15000,
  14: 30000,
  15: 50000,
  16: 75000,
  17: 100000,
  18: 200000,
  19: 300000,
  20: 400000,
  21: 500000,
  22: 750000,
  23: 1000000,
  24: 2500000,
  25: 5000000,
};

I also have the amount of exp one user has. How would I find the closest number to it from those object values and get the level of the user?

Answer 1

I would go for a recursive approach here:

const levels = {
  1: 50,
  2: 75,
  3: 125,
  4: 200,
  5: 350,
  6: 500,
  7: 1000,
  8: 1250,
  9: 2500,
  10: 5000,
  11: 7500,
  12: 10000,
  13: 15000,
  14: 30000,
  15: 50000,
  16: 75000,
  17: 100000,
  18: 200000,
  19: 300000,
  20: 400000,
  21: 500000,
  22: 750000,
  23: 1000000,
  24: 2500000,
  25: 5000000,
};

const userXP = 749999;

const getUserLevel = (xp, levelToCheck = 1) => {
  // the base case
  if (xp >= 5000000) return 25;
  // if the level above the one we're currently checking has a 
  // bigger requirement than the xp we're checking, 
  // return the current Level, otherwise call this function with the 
  // next higher level
  return levels[levelToCheck + 1] > xp ? levelToCheck : getUserLevel(xp, levelToCheck + 1);
};

console.log(getUserLevel(userXP));

Answer 2

you could binary search it..

getLevel = (exp) => {
    let res;
    let keys = Object.keys(levels);
    let start = 0;
    let end = keys.length - 1;
    let index = 0;
    while(start <= end){
        let mid = Math.floor((end + start) / 2);
        if(levels[keys[mid]] <= exp){
            start = mid + 1;
            index = mid;
        } else {
            end = mid - 1;
        }
    }

    if(Math.abs(levels[keys[index]] - exp) >  Math.abs(levels[keys[index+1]] - exp)){
        res = keys[index+1];
    } else {
        res = keys[index];
    }

    return res;
}

and the index should be the first larger or equal, or the last index.. then you can check if the next value is nearer the exp and do what you need to do

Answer 3

Presumably, someone gets a certain level only if they are at or above the required experience points. (Is this a gaming thing you're doing? A homework assignment from someone who likes gaming?)

Anyway, since the object is sorted in increasing order without any skips, you can find it with Object.entries():

function getLevel(myPoints) {
  return Object.entries(levels)
    .filter(([level, exp]) => exp <= myPoints)
    .pop()[0];
}

Object.entries() converts the object into an array of arrays. The .filter() gets rid of everything except entries where exp <= myPoints. And pop()[0] grabs the last element (the one with the highest level) and returns the level ([0] is level and [1] is the minimum points for that level).

I find this easier to understand than the loop solution and the recursive solution already posted. Others may disagree with me on that, and that's fine. Use whichever solution is easiest for you to understand. Unless this is going to scale up to 15 million levels or something, it's unlikely you'll have to worry about performance or memory or anything, so go with what you can maintain easiest.