JavaScript Mini-Max Sum-来自HackerRank网站的挑战

以下是挑战：

尽管我的答案是返回与预期结果相同的数字，但我做了一些错误的事情，因为我的答案被拒绝了。 我怎样才能解决它

以下是我尝试过的解决方案：

function miniMaxSum(arr) {   

  var arrClone1 = arr.slice() 
  var arrClone2 = arr.slice() 

  var arrMinor = arrClone1.sort(function(a, b){return a - b;})
  arrMinor.pop()

  var arrMajor = arrClone2.sort(function(a, b){return b - a;})
  arrMajor.pop()

  function getSum(a, b) {
    return a + b;
  }

  var result1 = arrMinor.reduce(getSum) 
  var result2 = arrMajor.reduce(getSum)    

  console.log(`${result1} ${result2}`) // it is returning: 10 14 

---

你说得对。唯一的问题是，你正在做java或C++编码的挑战。（这就是他们提到32位整数的原因）。

---

输入不应该是数组，而是“由五个空格分隔的整数组成的单行。”

我找到了答案。我注意到必须将函数参数命名为“input”而不是“arr”。这就是为什么答案被HackerRank平台拒绝的原因，尽管代码在我的编辑器中返回了正确的结果，而不是在HackerRank平台中。如果你只做简单的调整，它在HackerRank平台上也能工作

就这样,

function miniMaxSum(input) {   //'input' NOT 'arr'    
  var arrClone1 = input.slice()   //'input' NOT 'arr'
  var arrClone2 = input.slice()   //'input' NOT 'arr'

//... rest of the code omitted

---

这是另一个解决方案

function miniMaxSum(arr) {

let minValue = 0, maxValue = 0, minIndex = 0, maxIndex = 0, minSum = 0, maxSum = 0;
minValue = Math.min(...arr);
maxValue = Math.max(...arr);
minIndex = arr.indexOf(minValue);
maxIndex = arr.indexOf(maxValue);

for (let i = 0; i < arr.length; i++){
    if (minIndex != i) {
        maxSum += arr[i];
    }
    if (maxIndex != i) {
        minSum += arr[i];
    }
}
   console.log(minSum, maxSum);
 }
 miniMaxSum([1,2,3,4,5]);

函数miniMaxSum（arr）{
设minValue=0，maxValue=0，minIndex=0，maxIndex=0，minSum=0，maxSum=0；
minValue=Math.min（…arr）；
maxValue=Math.max（…arr）；
minIndex=arr.indexOf（最小值）；
maxIndex=arr.indexOf（maxValue）；
for（设i=0；i

使用。减少：

const arr = [1, 2, 3, 4, 5];

function miniMaxSum(arr) {
   const res = arr.sort((a,b) => a-b).reduce((prev, cur, i) => {
      if(i!=0) ( prev.max=prev.max+cur || cur);
      if(i!=arr.length-1) ( prev.min=prev.min+cur || cur);
      return prev;
   }, [{max:0},{min:0}]);
   console.log(res.min || 0, res.max || 0);
}

miniMaxSum(arr) // 10 14

---

试试这个，它适用于所有情况：

函数miniMaxSum（arr）{
设c=arr.sort（）；
设a=c.slice（0,4）
设b=c.slice（1,5）
log（a.reduce（（p，n）=>p+n，0），b.reduce（（p，n）=>p+n，0））
}

我认为解决方案应该更简单：

function miniMaxSum(arr) {
    let sum = arr.reduce((a, b) => a + b);
    let maxVal = Math.max(...arr);
    let minVal = Math.min(...arr);
    console.log((sum - maxVal) + ' ' + (sum - minVal));
}

另一个解决方案

const numbers = arr.slice('').sort();

  let min = 0;
  let max = 0;
  for (let i = 0; i < numbers.length; i++) {
    if (i < 4) {
      min = min + numbers[i];
    }
    if (i > 0 && i < 5) {
      max += numbers[i];
    }
  }

  console.log(`${min} ${max}`);

const numbers=arr.slice（“”）.sort（）；
设min=0；
设max=0；
for（设i=0；i0&&i<5）{
max+=数字[i]；
}
}
log（`${min}${max}`）；

让数字=arr.slice（“”）.sort（）；
设maxScore=0；
设minScore=0；
for（设i=0；i

函数miniMaxSum（输入）{
设minElem=0，maxElem=0，sum=0；
minElem=输入[0]；
maxElem=minElem；
sum=minElem；
for（设i=1；imaxElem）{
maxElem=输入[i]；
}
}
设minresult=sum-maxelm；
设maxresult=sum-minElem；
console.log（minresult+“”+maxresult）；
}

函数miniMaxSum（arr）{
设sortarr=arr.sort（）；
设maxSum=0；
设minSum=0；
for（设i=0；i0；j--）{
maxSum+=sortarr[j]；
}
console.log（minSum+“”+maxSum）；
}

伙计们。只是分享我的解决方案

function miniMaxSum(input) {
    
    input.sort((a,b) => a-b)
    let min = 0, max = 0;
    for(let i=0; i < input.length; i++)
    {
        min += input[i]
        max += input[i] 
    }
    
    console.log((min - input[input.length -1]) + ' ' + (max - input[0]))
}

函数miniMaxSum（输入）{
输入.排序（（a，b）=>a-b）
设min=0，max=0；
for（设i=0；i

这是我的解决方案-->这将同时处理重复值和浮点值
查看下面的实时演示：

函数miniMaxSum（arr）{
设tempArr=[]；
var sum=arr.REDUCT（（acc，cur）=>acc+cur）；
arr.map（（val）=>{
tempArr.push（数（和值））；
});
//仅限唯一值
tempArr=[…新设置（tempArr）]；
log（`${Math.min.apply（null，tempArr）}${Math.max.apply（null，tempArr）}`）；
}
miniMaxSum（[7,69,2203894]）谢谢，但是什么是最好的方法呢？@claudiobitar
'12345'.split（''）.map（x=>parseInt（x））
你在HackerRank上发布的代码对我来说非常有效。（我把你的函数体贴在下面，上面写着：“在这里写你的代码。”）请对你的问题添加一个描述，你在寻找什么？在我的答案中你怎么看，只有当你将参数命名为“input”而不是“arr”时，它才起作用，因为在hacker rank平台中传递的参数被命名为las“input”。
function miniMaxSum(input) {
    let minElem = 0, maxElem = 0, sum = 0;

    minElem = input[0];
    maxElem = minElem;
    sum = minElem;

    for (let i = 1; i < input.length; i++) {
        sum += input[i];
        if (input[i] < minElem) {
            minElem = input[i];
        }

        if (input[i] > maxElem) {
            maxElem = input[i];
        }
    }

    let minresult = sum - maxElem;
    let maxresult = sum - minElem;
    console.log(minresult + " " + maxresult);
}

function miniMaxSum(input) {
    
    input.sort((a,b) => a-b)
    let min = 0, max = 0;
    for(let i=0; i < input.length; i++)
    {
        min += input[i]
        max += input[i] 
    }
    
    console.log((min - input[input.length -1]) + ' ' + (max - input[0]))
}