цикл по объекту javascript без сортировки по ключам

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

Вот еще одно однострочное решение с использованием функций 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]);

Answer 3

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 4

Давайте удостоверимся, что порядок ключей на карте определен сначала.

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 5

Используйте 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 6

Вы можете попробовать использовать Array.reduce, и результирующий массив будет иметь долю положительного числа в нулевом индексе, отрицательного в 1 и нулевого во втором индексе.

Теперь, если вы хотите контролировать количество элементов после десятичной точки, используйте 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 7

Вы можете использовать уменьшить.

Здесь идея

• Первый цикл по исходному массиву и проверка значения.
• Если значение равно нулю, мы увеличиваем счетчик ключа 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)