Javascript 除单个整数外，数组中的整数要么是完全奇数，要么是完全偶数。检索这个整数。JS

您将得到一个包含整数的数组（其长度至少为3，但可能非常大）。数组中的整数要么是完全奇数，要么是完全偶数，只有一个整数N。请编写一个将数组作为参数并返回N的方法

例如： [2, 4, 0, 100, 4, 11, 2602, 36] 返回时间：11

我需要工作的测试用例：

Test.assertEquals(findOutlier([0, 1, 2]), 1)
Test.assertEquals(findOutlier([1, 2, 3]), 2)
Test.assertEquals(findOutlier([2,6,8,10,3]), 3)
Test.assertEquals(findOutlier([0,0,3,0,0]), 3)
Test.assertEquals(findOutlier([1,1,0,1,1]), 0)

到目前为止，我的代码似乎不起作用：

function findOutlier(integers){
    var evens = [];
    var odds = [];
    for (var i = 0; i < integers.length; i++) {
        if (integers[i] % 2) {
            evens.push(integers[i]);
        } else {
            odds.push(integers[i]);
        }
    }
    var elen = evens.length;
    var olen = odds.length

    if (elen > olen) {
        return odds;
    } else {
        return evens;
    }
}

函数findOutlier（整数）{
var evens=[]；
var赔率=[]；
对于（var i=0；iolen）{
回报率；
}否则{
返回晚上；
}
}

---

使用此代码我需要更改什么？

首先，您的情况应该是：

if (integers[i] % 2 === 0) {

您需要返回数组的第一个元素：

return odds[0];

以下是我可能的做法：

function findOutlier(arr) {
  var result = arr.reduce(function(p, c) {
    p[c % 2 === 0 ? 'even' : 'odd'].push(c);
    return p;
  }, { odd: [], even: [] });
  var eLen = result.even.length;
  var oLen = result.odd.length;
  if (oLen < eLen) {
    return oLen > 1 ? result.odd : result.odd[0];
  } else {
    return eLen > 1 ? result.even : result.even[0];
  };
}

函数findOutlier（arr）{
var结果=arr.REDUCT（功能（p，c）{
p[c%2==0？'偶数'：'奇数'].push（c）；
返回p；
}，{奇数：[]，偶数：[]}）；
var eLen=结果偶数长度；
var oLen=结果奇数长度；
if（oLen1？result.odd：result.odd[0]；
}否则{
返回eLen>1？result.偶数：result.偶数[0]；
};
}

---

我看到两种可能的修改： 1） 返回数组中的单个值，而不是数组中的所有值

return evens[0];

更改if以检查模是否=0（如果余数=0，则为偶数）

-

函数findOutlier（整数）{
var evens=[]；
var赔率=[]；
对于（var i=0；iolen）
{
回报率[0]；
} 
其他的
{
返回偶数[0]；
}
}

我有空闲时间。。。我这样做了，javascript非常有趣，能得到另一个视图也很好

var numbers = [2,4,6,8,10,12,14,16,17,18,20];

function findOutlier(arr) {
    var odds = arr.filter(function (number) {
    return !!(number % 2)
  });

  var evens = arr.filter(function (number) {
    return !(number % 2)
  });

  var result = (odds.length < evens.length) ? odds.pop() : evens.pop();

  return result;
}

findOutlier(numbers);

var数=[2,4,6,8,10,12,14,16,17,18,20]；
函数findOutlier（arr）{
var赔率=arr.filter（函数（编号）{
返回！！（数字%2）
});
var evens=arr.filter（函数（编号）{
返回！（编号%2）
});
var结果=（赔率.length

我发现了一种使用O（1）内存的方法。不会生成其他数组。它检查前3个值中有多少是偶数。如果该数字为2或更多，则会查找奇数。否则，它会寻找一个偶数值

函数findOutlier（arr）{
//大O：内存=1，时间=n；
设evenCount=0；
for（设i=0；i<3；i++）{
设val=arr[i]；
如果（val%2==0）evenCount++；
}
设isEven=evenCount>1；
for（设i=0；i

函数findOne（arr）{
设evenOrOdd={“偶数”：[]，“奇数”：[]}；
for（设i=0；i1 | | evenCount===1&&oddCount>1）{
打破
}
arr[i]%2==1？
偶数[奇数]推送（arr[i]）：
偶数或奇数[“偶数”]。推（arr[i]）；
});
返回evenOrOdd[“奇数”]。长度===1？
evenOrOdd[“奇数”][0]：
evenOrOdd[“偶数”][0]；
}

函数findOutlier（整数）{
//你的代码在这里
整数。sort（）；
var计数=0；
对于（变量i=0；i<3；i++）{
if（整数[i]%2==0）{
计数+=1；
}
}
如果（计数>=2）{
var r=整数。过滤器（函数（x）{
返回x%2！==0；
});
}否则{
var r=整数。过滤器（函数（x）{
返回x%2==0；
});
}
返回r[0]；
}

Python版本，用于在包含多个偶数或奇数的数组中查找偶数或奇数，其中一个为偶数或奇数。例如：[2,781004,13]=13，[111,81,79,410023]=4。

---

检查前3个数字，如果其中两个相同，则返回异常值：

function findOutlier(integers){
  //your code here

  if (integers[0]%2 === 0 && integers[1]%2 === 0 ) {
      return integers.find(integer => integer %2 !== 0)
 } else if(integers[0]%2 !== 0 && integers[1]%2 !== 0) {
      return integers.find(integer => integer % 2 === 0)
 } else {
      if(integers[2]%2 === 0){
          return integers.find(integer => integer %2 !==0)
      }
      else {
          return  integers.find(integer => integer %2 ===0)
      }
}

---

您应该返回单个异常值，而不是异常值数组。另外，

整数[i]%2

应该与0比较。@MichaelLiu谢谢，这不是我正在做的吗？将只有一个奇数或偶数，所以这将是唯一一个被返回？谢谢大家!！变量

赔率

和

偶数

是数组，您将返回全部内容。应该是

return赔率[0]

或

return evens[0]

。@Pointy，谢谢，我已经更改了，但似乎没有得到结果？控制台有错误吗？回答很好，非常简洁。我想知道你是否能够在JFIDLE上运行你的代码，或者只是给出一个如何使用该函数的示例？演示链接将带你到JSFIDLE。谢谢。我能问一下这个位子是什么吗

（（整数[i]%2）==0）

？模将返回除以2后的余数，因此，如果是偶数，余数将为零，如果是奇数，余数将为1！虽然这个代码片段可能是解决方案，但它确实有助于提高文章的质量。请记住，您将在将来为读者回答这个问题，而这些人可能不知道您的代码建议的原因。虽然这可能会回答作者的问题，但它缺少一些解释性词语和/或文档链接。如果没有一些短语，原始代码片段就没有多大帮助。你也会发现这很有帮助。请编辑你的答案-

var numbers = [2,4,6,8,10,12,14,16,17,18,20];

function findOutlier(arr) {
    var odds = arr.filter(function (number) {
    return !!(number % 2)
  });

  var evens = arr.filter(function (number) {
    return !(number % 2)
  });

  var result = (odds.length < evens.length) ? odds.pop() : evens.pop();

  return result;
}

findOutlier(numbers);

function findOne(arr){
   let evenOrOdd = {"even": [], "odd": []};

   for(let i=0; i<arr.length; i++) {
      let oddCount = evenOrOdd["odd"].length,
          evenCount = evenOrOdd["even"].length;

      if(oddCount===1 && evenCount>1 || evenCount===1 && oddCount>1) {
          break;
      }

      arr[i]%2===1 ?
        evenOrOdd["odd"].push(arr[i]) :
        evenOrdOdd["even"].push(arr[i]);
   });

   return evenOrOdd["odd"].length===1 ? 
            evenOrOdd["odd"][0] :
            evenOrOdd["even"][0];         
}

function findOutlier(integers) {
    //your code here
    integers.sort();
    var count = 0;
    for (var i = 0; i < 3; i++) {
        if (integers[i] % 2 === 0) {
            count += 1;
        }
    }
    if (count >= 2) {
        var r = integers.filter(function(x) {
            return x % 2 !== 0;
        });
    } else {
        var r = integers.filter(function(x) {
            return x % 2 === 0;
        });
    }

    return r[0];
}

def find_outlier(integers):
    lst_odd = [] # makin new odd list
    lst_even = [] # making new even list
    for i in integers:
     # checking if these numbers are even or odd.
        if i % 2 == 0 :
             # if even they will be added in this list otherwise only one is added.
            lst_even.append(i) 
        else:
     # if odd, they are added here, otherwise, only one is added
            lst_odd.append(i)

    #checking if whether these two list contains only one element.  if so we return that element.
    if len(lst_odd) == 1:
        return lst_odd[0]
    else:
        return lst_even[0]
    

function findOutlier(integers){
  //your code here

  if (integers[0]%2 === 0 && integers[1]%2 === 0 ) {
      return integers.find(integer => integer %2 !== 0)
 } else if(integers[0]%2 !== 0 && integers[1]%2 !== 0) {
      return integers.find(integer => integer % 2 === 0)
 } else {
      if(integers[2]%2 === 0){
          return integers.find(integer => integer %2 !==0)
      }
      else {
          return  integers.find(integer => integer %2 ===0)
      }
}