javascript求出最小的两位数

THIS
  • 724

图片描述

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

回复
阅读 4.8k
18 个回答
何同学
  • 110

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

user_name
  • 1.9k

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

idleb
  • 277
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);
小石头
  • 266

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

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

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

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

3.返回 最小数组的和

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

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

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

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

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

同意并接受
  • 7.2k
> [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
深蓝一人
  • 1.5k
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

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

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

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

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

HowardTangHw
  • 126

想了下,应该这样做

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

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;

}

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

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

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

尽管是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写代码的确是少敲键盘些。

宣传栏