Question

这是问题描述：给定整数数组，计算其元素的正数，负数和零的分数。在新行上打印每个分数的十进制值。例如，给定数组arr=[1,1,0,-1,-1]的输出应为：

0.400000
0.400000
0.200000

我知道有更简单的解决方案，对于这个愚蠢的简单问题感到抱歉，但是我想使我的代码正常工作，我的代码根据键对输出进行排序，并删除重复项。对于此arr，我的代码输出为：

0.200000
0.400000

非常感谢您的帮助。

function plusMinus(arr) {
    var freq = {};
    for (var i = 0; i < arr.length; i++){
        if (freq[arr[i]]) {
            freq[arr[i]]++;
        } else {
            freq[arr[i]] = 1;
        }
    } for(var key in freq){

        console.log((freq[key]/arr.length).toFixed(6));
    }
    }

Answer 1

您可以采用具有预定义属性的对象，这样可以防止每个循环检查是否存在，并采用一组键来按所需顺序获取结果。

function plusMinus(arr) {
    var freq = { 1: 0, '-1': 0, 0: 0 },
        i, key;

    for (i = 0; i < arr.length; i++) {
        freq[arr[i]]++;
    }

    for (key of [1, -1, 0]) {
        console.log((freq[key] / arr.length).toFixed(6));
    }
}

plusMinus([1, 1, 0, -1, -1]);

Answer 2

您可以使用reduce。

这里的想法是

首先循环遍历原始数组，然后检查值。
如果值是零，我们将增加zero键的计数。
如果值为positive，我们将增加pos键的计数。
如果值为negative，我们将增加neg键的计数。
最后，我们将每个计数除以数组的长度。

let arr = [1,1,0,-1,-1]

let op = arr.reduce((op,inp)=>{
  if(inp === 0){
    op.zero.count++
  } else if (inp > 0){
    op.pos.count++;
  } else {
    op.neg.count++;
  }
  return op
},{zero:{count:0},pos:{count:0},neg:{count:0}})


let final = Object.entries(op).map(([key,value])=>({
  [key] : value.count / arr.length
}))

console.log(final)

Answer 3

您可以尝试使用Array.reduce，结果数组将在第'0'个索引处具有正数的分数，在'1'st处具有负数，而在'2'nd索引中具有零。

现在，如果要控制小数点后的元素数计数，请在末尾使用Array.map进行转换。

const array = [1,1,0,-1,-1];
function plusMinus(arr){
  const output = arr.reduce((acc, ele) => {
  if(ele > 0){
    acc[0] = ((acc[0] || 0 ) + 1 / arr.length);
  }
  if(ele < 0){
    acc[1] = ((acc[1] || 0 ) + 1 / arr.length);
  }
  if(ele === 0) {
    acc[2] = ((acc[2] || 0 ) + 1 / arr.length);
  }
  return acc;
  }, []).map(ele => ele.toFixed(6));
 console.log(...output);
}
plusMinus(array);

Answer 4

使用reduce，map和filter：

const arr = [1, 1, 0, -1, -1];

const counts = arr.reduce((acc, curr) => {
  if (!curr) acc[0]++;
  else if (curr > 0) acc[1]++;
  else acc[2]++;
  return acc
}, [0, 0, 0]);

const result = counts.map(e => e / arr.length).filter((e, i, a) => a.indexOf(e) == i);

console.log(result);

Answer 5

让我们先定义键，以确保其在地图中的顺序。

function plusMinus(arr) {
  var freq = {
    posetive: 0,
    negative: 0,
    zero: 0
  };
  for (var i = 0; i < arr.length; i++){
    if( arr[i] < 0) {
      freq.negative++;
    } else if(arr[i] > 0) {
      freq.posetive++;
    } else {
      freq.zero++;
    }
  } 
  for(var key in freq){
    console.log((freq[key]/arr.length).toFixed(6));
  }
}
plusMinus([1,1,0,-1,-1]);

Answer 6

Math.sign是您的朋友在这里。 Math.sign

lodash确实可以帮助此代码段更加简洁，我强烈建议_.countBy。 Lodash .countBy

这是代码。

const plusMinus = (numbers) => {
  // Count by Sign (-1, 0 1)
  const countSign = _.countBy(numbers, Math.sign);
  // _.countBy return object, of counted { '1': 2, '0': 1, '-1': 2 } 
  
  // Print them in orders
  const printOrder = [1, -1, 0];
  printOrder.forEach(sign => {
    console.log((countSign[sign] / numbers.length).toFixed(6));
  });
}

const testArr = [1,1,0,-1,-1];
plusMinus(testArr);

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.11/lodash.min.js"></script>

Answer 7

这是使用Array.reduce()和Array.forEach()函数的另一种单行解决方案：

const plusMinus = arr => arr
  .reduce((res, curr) => ++res[!curr ? 2 : curr < 0 ? 1 : 0] && res, [0, 0, 0])
  .forEach(i => console.log((i / arr.length).toFixed(6)));

plusMinus([1, 1, 0, -1, -1]);

遍历javascript对象而无需根据键进行排序

7 个答案: