如何从一组特定的数字中找到最近的更高数字：javascript

我有一组数字&我的要求是找到与特定变量相同或最接近的更高数字 数字的集合/对象

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
};

我需要找到一个离可值x最近的更高数字
eg1-如果

然后，从数字集中到x最近的更高数字是117，它在C，G，M重复 所以我需要用javascript编程找出C，G，M

eg2-

然后从数字集中重复相同的数字到x，在D，H，N处重复 所以我需要用javascript编程找出D，H，N

谢谢你的帮助

试试这个

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

试试这个

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

---

您可以尝试以下方法：

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"]

注意，如果只需要键，可以替换

result[k]=obj[k]到
结果。按下（k）
并使结果成为一个数组


varperson={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}；
函数searchNearestNum（obj，x）{
var值=null；
var result={}；
Object.key（obj）.sort（函数（a，b）{
返回obj[a]>obj[b]？1：（obj[a]x）{
值=obj[k]；
结果[k]=obj[k]；
}
else if（obj[k]==值）{
结果[k]=obj[k]；
}
});
返回结果；
}
函数getList（）{
var searchValue=document.getElementById（“txt”）.value；
if（searchValue&！isNaN（searchValue））{
searchValue=parseInt（searchValue）；
打印（searchNearestNum（person，searchValue））；
}
}
功能打印（obj）{
document.getElementById（“结果”）.innerHTML=“”+JSON.stringify（obj，0,4）+”；
}

获取列表
您可以尝试以下方法：

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"]

注意，如果只需要键，可以替换
result[k]=obj[k]到
结果。按下（k）
并使结果成为一个数组


varperson={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}；
函数searchNearestNum（obj，x）{
var值=null；
var result={}；
Object.key（obj）.sort（函数（a，b）{
返回obj[a]>obj[b]？1：（obj[a]x）{
值=obj[k]；
结果[k]=obj[k]；
}
else if（obj[k]==值）{
结果[k]=obj[k]；
}
});
返回结果；
}
函数getList（）{
var searchValue=document.getElementById（“txt”）.value；
if（searchValue&！isNaN（searchValue））{
searchValue=parseInt（searchValue）；
打印（searchNearestNum（person，searchValue））；
}
}
功能打印（obj）{
document.getElementById（“结果”）.innerHTML=“”+JSON.stringify（obj，0,4）+”；
}

获取列表
完全编辑以满足我的评论=）

var x=116；
var max=x；
用于（var亲自输入）{
如果（人员[钥匙]>最大值）{
max=人[钥匙]；
}
}
函数nextMax（ar、k、m）{
var dif=m；//某个高数字
var-rkey=null；
for（ar中的var键）{
var检查=ar[键]-k；
如果（勾选0）{
dif=检查；
rkey=键；
}
}
返回（rkey）；
}
var键=[]；
var值=[]；
对于（var-ckey；ckey=nextMax（person，x，max）；）{
如果（ckey==null）{
打破
}
按键。按键（ckey）；
价值观。推（人[ckey]）；
x=人[ckey]；
}
控制台日志（键）；
console.log（值）；

检查它是否正常工作：
完全编辑以满足我的评论=）

var x=116；
var max=x；
用于（var亲自输入）{
如果（人员[钥匙]>最大值）{
max=人[钥匙]；
}
}
函数nextMax（ar、k、m）{
var dif=m；//某个高数字
var-rkey=null；
for（ar中的var键）{
var检查=ar[键]-k；
如果（勾选0）{
dif=检查；
rkey=键；
}
}
返回（rkey）；
}
var键=[]；
var值=[]；
对于（var-ckey；ckey=nextMax（person，x，max）；）{
如果（ckey==null）{
打破
}
按键。按键（ckey）；
价值观。推（人[ckey]）；
x=人[ckey]；
}
控制台日志（键）；
console.log（值）；

检查它是否工作：
方法1
试试这个非常简单的算法

第一步->将数组中的值推送到[key，value，value和search之间的差异]

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

最后一步->按差值对其排序

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 );

方法2
为了使它更简单，请保持差异最小的句柄

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--;
}

var personArray=[]；
var下限差=0；
var nearestHigherValue=0；
用于（var亲自输入）
{
var差异=人[键]-116；
如果（差异>0&&最低差异<差异）
{
最低差异=差异；
最接近的高值=人[键]；
}
}
log（“最近的较高值为”+最近的较高值）；
方法1
试试这个非常简单的算法

第一步->将数组中的值推送到[key，value，value和search之间的差异]

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

最后一步->按差值对其排序

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 );

方法2
为了使它更简单，请保持差异最小的句柄

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--;
}

var personArray=[]；
var下限差=0；
var nearestHigherValue=0；
用于（var亲自输入）
{
var差异=人[键]-116；
如果（差异>0&&最低差异<差异）
{
最低差异=差异；
最接近的高值=人[键]；
}
}
log（“最近的较高值为”+最近的较高值）；
我认为这应该行得通：

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;
}

var resultObject=[]；
功能搜索（x，个人）{
对于（变量i=0；i0）{
console.log（x+“\n”）；x--；
}
我认为这应该行得通：

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;
}

var resultObject=[]；
功能搜索（x，个人）{
对于（变量i=0；i