javascript求出最小的两位数

Question

如题 不知道有没有大神可以做出来 小弟想了半天 也没有思路

Answer 1

都没要求要连续，那不是排序一下，把前面的依次判断相加就行了

Answer 2

可以对数组进行两次求最小值的操作。
第一次求完最小值就把他pop出去，放进一个数组；然后再次求最小值，把值放进前面的数组。最后求和即可。

Answer 3

let arr = [1,-1,2,1,4,7,3,-5,0,23];
arr.sort((a,b) => a > b);
let len = arr.findIndex(n => n >= 0);
arr.length = Math.max(len, 2);
console.log(arr);

Answer 4

分而治之
把查找最小数组的和值 => 查找数组最小值 => 合围最小子数组
1.if语句查找数组最小值---

  2种情况：minVal > 0  返回最小值结束
          minVal <= 0  删除最小值，暂存删除的最小值到新数组              

2.情况2 while语句判断是否继续上述判断

          minVal <= 0  删除最小值，暂存删除的最小值到新数组

3.返回 最小数组的和

Answer 5

将数组按升序排列,取出前两个拼成一个新数组,这样可以吗

Answer 6

先把小于0的数字找出来，然后相加就可以了？还是我想简单了？

Answer 7

先从小到大冒泡排序，判断最小值是否是小数，不是小数直接返回最小数，是小数的话遍历新数组，求和，判断array[i]是否为小数，是的话停止遍历，最小数组是array.slice(0,i-1)

Answer 8

var munber = arrFn(arr);
        function arrFn (arr){
            var mun = Infinity;
            var munn = [];
            if(arr.push) {
                for(var i = 0; i<arr.length; i++){
                    if(mun > arr[i]){
                         mun = arr[i];
                         munn.push(mun)
                    }
                }
                return munn[munn.length-1] +  munn[munn.length-2];
            }
        

这是我写的代码 但是有点不严谨 反正我现在的思路就是这样的

Answer 9

> [1,-1,-2,1].sort().slice(0,2).reduce((x,y)=>x+y)
-3

---

改进

> [1,-1,-2,1,10,20,-15].sort((a,b)=>a-b).slice(0,2).reduce((x,y)=>x+y)
-17

---

3改

刚开始审题不清

> [1,-1,-2,1,10,20,-15].sort((a,b)=>a-b).reduce((x,y)=>(x+y<x?x+y:x))
-18

Answer 10

var array = [1, -1, -2, 1];
var minSum = 0;
function arrFn(array) {
    let minEle = 0;
    let minArray = [];
    array.map((item, index)=>{
        if (item < minEle) {
            minEle = item; //用于存储数组最小值
        }
        if (item < 0) {
            minArray.push(item);
            minSum += item;
        }
    })
    if (minArray.length === 0) { //如果数组中没有负数，将最小值放进最小和数组中
        minArray.push(minEle);
        minSum += minEle;
    }
    return minArray;
}
console.log("最小和数组为:" + arrFn(array)); //最小和数组为:-1,-2
console.log("最小和为:" + minSum); //最小和为:-3

Answer 11

1.排序后数组arr,最小和n；
2.如果arr[0]+arr[1]的和大于arr[0]，则最小和n为arr[0];如果小于arr[0]，则判断arr[0]+arr[1]+arr[2]的和是否大于arr[0]+arr[1]，假如大于，则最小和为arr[0]+arr[1]。

Answer 12

难道不是简单的排序，然后index 0 和 1的相加嘛？

Answer 13

二维数组的情况要考虑么?
[1,-2,4,-5,[-1,-7,-6]] 这种的?

我的想法,
做一次排序,取出来最小的两个值
排序的时候对元素是否为数字校验,如果为数组,则递归某个函数,继续判断类型,相加总和,返回和,作为这个元素的值,比如:
[-14,-5,-2,1,4]

Answer 14

想了下,应该这样做

1. 判断是否存在负数,如果存在则 返回负数数组组合

2. 如果没有负数,则取最小的正数

function minArrFnc(arr) {
  var ltArr = [];
  var minNum = arr[0];
  for (var i of arr) {
    if (Array.isArray(i)) {
      var c = minArrFnc(i);
      Array.isArray(c) ? ltArr=[...ltArr,...c]: (minNum = minNum > c ? c : minNum);
    } else {
      i < 0 ? ltArr.push(i) : "";
      minNum < i ? minNum : i;
    }
  }
  if (ltArr.length > 0) {
    return ltArr;
  } else {
    return minNum;
  }
}
var arr = [-1, 1,[-2,[-4,-5],-3], 2, 3, 4];
console.log(minArrFnc(arr));

Answer 15

function test(arr) {

var tempArr = [],
    res = 0;
arr.forEach(function(item) {
    if(item < 0) {
        tempArr.push(item);
    }
})
if( tempArr.length == 0) {
    var temp = 9999999999999999999;
    item.forEach(function(item) {
        if(item < temp) {
            temp = item;
        }
    })
    tempArr = [temp];
}

tempArr.forEach(function(item) {
    res+=item;
})
return res;

}

Answer 16

有 < 0 的值，就返回 < 0 集合的和
数组元素都 > 0，就返回 最小值

function minSet(arr) {
    let minArr = [],
        min = arr[0];

    arr.forEach((item) => {
        if (item < 0) {
            minArr.push(item);
        } else if (min > item) {
            min = item;
        }
    });

    if (minArr.length) {
        return minArr.reduce((x, y) => {
            return x + y;
        });
    }

    return min;
}

Answer 17

先按从小到大排序，之后求和有两个情况：

1，小于0的所有数字相加就是最小的数值。
2，大于0的找出最接近或等于0的数值。

Answer 18

尽管是Scala写的，但思路是一样的，不知道大家是否觉得我的思路正确。

List(1, -1, -2, 9, -8, 3).sorted.reverse.foldRight(List.empty[Int]) { (i, z) => 
    z match {
        case Nil => i :: z
        case _   => if (z.sum + i < z.sum) i :: z else z
    }
}

补充一下JavaScript的代码

function sum(arr) { return [...arr].reduce((z, i) => z + i) }

[100, -20, 1, -1, -2, 3].sort().reduce((acc, n) => { 
    if (!acc) { 
        acc = []; 
        acc.push(n); 
    } else {
        let s = sum(acc);
        if (s + n < s) acc.push(n);
    }

    return acc;
}, null);

PS: 看起来Scala写代码的确是少敲键盘些。