Как найти ближайшее большее число из набора чисел: JavaScript

Question

У меня есть набор чисел & мои требования, чтобы найти такую ​​же или ближайшее большее число к конкретному переменному множества/объекту чисел

var person = { 
    A:107, 
    B:112, 
    C:117, 
    D:127, 
    E:132, 
    F:140, 
    G:117, 
    H:127, 
    I:132, 
    J:132, 
    K:140, 
    L:147, 
    M:117, 
    N:127, 
    O:132 
}; 

мне нужно найти ближайшее к большему числу vaiable х
eg1- если

x = 116; 

затем ближайшее большее число х из числа множества является 117, которые повторяют в точке с, G, M так что мне нужно, чтобы узнать, C, G, M с JavaScript программно

eg2-

x= 127 

то же число х из числа набора повтора в D, H, N так что мне нужно, чтобы выяснить, D, H, N Programatically с JavaScript

Спасибо за помощь

Answer 1

Попробуйте

function getNearest(x){ 
    var keys=[]; 
    for(var key in person){ 
    if(person[key]==x+1) 
     keys.push(key) 
    } 
    return keys; 
} 
getNearest(116) 

Answer 2

Вы можете попробовать что-то вроде этого:

Примечание, если вы просто хотите ключи, вы можете заменить result[k] = obj[k]; на result.push(k) и сделать результат массив.

var person = {A:107,B:112,C:117,D:127,E:132,F:140,G:117,H:127,I:132,J:132,K:140,L:147,M:117,N:127,O:132}; 
 

 
function searchNearestNum(obj, x){ 
 
    var value = null; 
 
    var result = {}; 
 
    
 
    Object.keys(obj).sort(function(a,b){ 
 
    \t return obj[a]>obj[b]?1:(obj[a]<obj[b])?-1:0 
 
    }).forEach(function(k){ 
 
    if(!value && obj[k]>x){ 
 
     value = obj[k]; 
 
     result[k] = obj[k]; 
 
    } 
 
    else if(obj[k] === value){ 
 
     result[k] = obj[k]; 
 
    } 
 
    }); 
 
    
 
    return result; 
 
} 
 

 
function getList(){ 
 
    var searchValue = document.getElementById("txt").value; 
 
    if(searchValue && !isNaN(searchValue)){ 
 
    searchValue = parseInt(searchValue); 
 
    print(searchNearestNum(person, searchValue)); 
 
    } 
 
} 
 

 
function print(obj){ 
 
    document.getElementById("result").innerHTML = "<pre>" + JSON.stringify(obj,0,4) + "</pre>"; 
 
}

<input id="txt"/> 
 
<button onclick="getList()">get list</button> 
 

 
<p id="result"></p>

Answer 3

Полностью отредактированный для удовлетворения моих комментаторов =)

var x = 116; 

var max = x; 

for (var key in person) { 
    if(person[key]>max){ 
    max = person[key]; 
    } 
} 

function nextMax(ar, k, m) { 
    var dif = m; //Some high number 
    var rkey = null; 
    for (var key in ar) { 
     var check = ar[key]-k; 
     if(check<dif && check > 0){ 
      dif = check; 
      rkey = key; 
     } 
    } 
    return(rkey); 
} 

var keys = []; 
var values = []; 
for(var ckey; ckey = nextMax(person, x, max);){ 
    if(ckey == null){ 
    break; 
    } 
    keys.push(ckey); 
    values.push(person[ckey]); 
    x = person[ckey]; 
} 

console.log(keys); 
console.log(values); 

проверить это работает: https://jsfiddle.net/Aschab/q65wes0a/2/

Answer 4

подход 1

Попробуйте demo из очень простой алгоритм

Первый шаг -> Нажмите значения в массиве, как [ключ, значение, разность между значением и поиск]

var personArray = []; 
for (var key in person) 
{ 
    if ((person[key] - 116) > 0) 
    { 
    personArray.push([key, person[key], person[key] - 116 ]); 
    } 
} 

Заключительный шаг -> разбирайтесь по значения разности

personArray.sort(function(a,b){return a[2]-b[2]}); 
console.log(personArray[0][1]); 

подход 2

Чтобы сделать его еще более проще, держать ручку низкой разницы

var personArray = []; 
var lowestDifference = 0; 
var nearestHigherValue = 0; 
for (var key in person) 
{ 
    var difference = person[key] - 116; 
    if (difference > 0 && lowestDifference < difference) 
    { 
    lowestDifference = difference; 
    nearestHigherValue = person[key] ; 
    } 
} 
console.log("nearest higher value is " + nearestHigherValue); 

Answer 5

Я думаю, что это должно работать:

var resultObject = []; 

function search(x, person){ 
    for (var i=0; i < person.length; i++) { 
     if ((person[i].name === x) || (person[i].name === (x+i))) { 
      return person[i]; 
     } 
    } 
} 

var result = search(x, person); 
resultObject.push(result); 
var x = resultObject.length; 
while(x >0){ 
    console.log(x+"\n");x--; 
} 

Answer 6

Вы можете использовать функцию следующим образом:

function findNearestNumbers(x, person) { 
    var results = []; 
    var currentClosest; 

    // Difference function measures the difference 
    // between two numbers 
    var diff = function(a, b) { 
    return Math.abs(a - b); 
    } 

    // Loop through each number on the person 
    for(var i in person) { 

    // We don't even need to do the diff if x is greater 
    // than the current number 
    if(x > p[i]) { 
     continue; 
    } 

    // Calculate the differnce between the current 
    // Number and the supplied 'x' value 
    var d = diff(x, person[i]); 

    // We want the highest number, not a matching number. 
    if(diff === 0) { 
     continue; 
    } 

    if(!currentClosest || d < currentClosest) { 

     // If it's the closest number so far, create 
     // a new array to store the results, with this key as 
     // the first element 
     results = [i]; 
     currentClosest = d; 
    } 
    else if(currentClosest === d) { 

     // If this is number is the same as the closest number 
     // then add this key to the results array 
     results.push(i); 
    } 
    } 

    return results; 
} 

Попробуйте скрипку здесь https://jsfiddle.net/y4nu3t0d/4/

Answer 7

Попытка используя for..in петли, Object.keys(), Array.prototype.map(), Array.prototype.reduce() для хранения значений свойств, как person ключи от нового объекта. Если свойство не существует, добавьте свойство person, иначе свойство concatenate person на созданном объекте; фильтровать свойства путем сравнения чисел; вернуть сцепленные строки, содержащие свойства исходного объекта, где фильтруется число больше входного параметра числа

var person = { 
 
    A: 107, B: 112, C: 117, D: 127, E: 132, 
 
    F: 140, G: 117, H: 127, I: 132, J: 132, 
 
    K: 140, L: 147, M: 117, N: 127, O: 132 
 
}; 
 

 
var res = function(n) { 
 
    var data = {}; 
 
    for (var prop in person) data[person[prop]] = (data[person[prop]] || "") + prop; 
 
    return data[Object.keys(data).map(Number).reduce(function(a, b) { 
 
    return a > n ? a : b 
 
    })]; 
 
} 
 

 
document.body.textContent = res(116) + "\n" + res(140)

Answer 8

Вы можете использовать уменьшить найти самую низкую разницу и получить ключи с этим значением. Если обнаружено более низкое различие, массив ключей заменяется новым набором нижних клавиш, например.

function getNextHighest(obj, value) { 
 
    var diff = Infinity; 
 
    return Object.keys(obj).reduce(function(acc, key) { 
 
    var d = obj[key] - value; 
 
    if (d > 0 && d < diff) { 
 
\t diff = d; 
 
\t acc = [key]; 
 
\t } else if (d == diff) { 
 
\t acc.push(key) 
 
\t } 
 
\t return acc; 
 
    }, []) 
 
} 
 

 
var person = {A:107,B:112,C:117,D:127,E:132,F:140,G:117, 
 
       H:127,I:132,J:132,K:140,L:147,M:117,N:127,O:132 
 
      }; 
 

 
document.write(getNextHighest(person, 116)); 
 
document.write('<br>' + getNextHighest(person, 140));

Answer 9

Попробуйте серию sort и filter на объекте:

var person = { 
    A: 107, 
    B: 112, 
    C: 117, 
    D: 127, 
    E: 132, 
    F: 140, 
    G: 117, 
    H: 127, 
    I: 132, 
    J: 132, 
    K: 140, 
    L: 147, 
    M: 117, 
    N: 127, 
    O: 132 
}; 

var myNum = 117; 

var nearest = Object.keys(person) 
.sort(function(item1, item2) { 
    if (person[item1] > person[item2]) {return 1}; 
    if (person[item1] < person[item2]) {return -1}; 
    return 0; 
}).filter(function(item) { 
    return person[item] >= myNum; 
}).filter(function(item, index, list){ 
    return person[list[0]] == person[item]; 
}); 

console.log(nearest) // will print ["C","M","G"] 

Проверить это fiddle для полного примера.

Answer 10

Thi - это прямой подход с петлей Array#forEach и переменная для хранения дельта и одна для ключей.

function nearestHigher(object, v) { 
 
    var delta = -1, 
 
     keys = []; 
 
    Object.keys(object).forEach(function (k) { 
 
     var d = object[k] - v; 
 
     if (d > 0) { 
 
      if (!~delta || d < delta) { 
 
       delta = d; 
 
       keys = [k]; 
 
       return; 
 
      } 
 
      d === delta && keys.push(k); 
 
     } 
 
    }); 
 
    return keys; 
 
} 
 

 
var person = { A: 107, B: 112, C: 117, D: 127, E: 132, F: 140, G: 117, H: 127, I: 132, J: 132, K: 140, L: 147, M: 117, N: 127, O: 132 }; 
 

 
document.write('<pre>' + JSON.stringify(nearestHigher(person, 116), 0, 4) + '</pre>'); 
 
document.write('<pre>' + JSON.stringify(nearestHigher(person, 132), 0, 4) + '</pre>'); 
 
document.write('<pre>' + JSON.stringify(nearestHigher(person, 140), 0, 4) + '</pre>');