逻辑还是错别字？

Question

我一直在试图找出解决这个问题的方法，但是我似乎找不到合适的排序顺序。

说明：

编写一种程序，该程序可以通过以下方式对数字列表进行排序：

3，-2,1,0，-1,0，-2,1 => -2，-1，-2,0,0,3,1,1

'use strict';
let myNumbers = '3,-2,1,0,-1,0,-2,1';
// I receive the input as a string and split and map it into an array
let myNumbers = gets().split(',').map(Number);

我尝试对所有小于零的整数按升序应用sort（）方法，对上述整数进行相反的处理，但这并不是预期输出中的顺序。

我还尝试在将sort（）设置为0之后拼接第一个数组，然后重新排列拼接的部分并将其连接起来。但是，这不适用于所有测试输入。

另一个例子： 3，-12,0,0,13,5,1,0，-2 => -12，-2,0,0,0,3,13,5,1

此顺序的逻辑是什么？谢谢。

Answer 1

因为这听起来像是解决家庭作业问题或类似问题的方法，所以我将让您编写代码：）但是我要做的方法是在数组中进行一次迭代，创建三个单独的数组：< / p>

负数
0s
正数

将数组挤压在一起而不进行排序，您将获得O（N）解决方案。

Answer 2

因此，根据涵盖逻辑的sketrik答案，这是代码：

const myNumbers = '3,-2,1,0,-1,0,-2,1';
const arr = myNumbers.split(',').map(Number)

const res = arr.filter(i => i < 0)
.concat(arr.filter(i => i === 0))
.concat(arr.filter(i => i > 0))

console.log(res)

这很有效，这要归功于Array.prototype的两个非常基本的JS方法：

concat和filter。我无法比文档更好地解释它们，请查看！

但基本上，我正在做的是：

使用arr.filter(i => i < 0)查找带有负数的块
使用arr.filter(i => i === 0)查找带有零的块
使用arr.filter(i => i > 0)查找带有正数的块
concat将它们全部合并为一个数组。

Answer 3

我是Neo。

'use strict';
let myInput = '3,-2,1,0,-1,0,-2,1';
let myNumbers = myInput.split(',').map(Number);
let negatives = [];
let zeroes = [];
let positives = [];
for (const element of myNumbers) {
    if (element < 0) {
        negatives.push(element);
    } else if (element === 0) {
        zeroes.push(element);
    } else if (element > 0) {
        positives.push(element);
    }
}
let sortedArr = negatives.concat(zeroes, positives);
console.log(sortedArr.join(','));

Answer 4

逻辑还是错别字？

“ ...对所有小于零的整数升序，对大于零的整数则相反...”

在问题发布之后，示例应为：

-2, -2, -1, 0, 0, 3, 1, 1 和 -12, -2, 0, 0, 0, 13, 5, 3, 1

零且较少上升：-3, -2, -1, 0。降序大于零：3, 2, 1

要获得这些结果，请参见演示1 。

严格按照示例操作比较简单：

-2, -1, -2, 0, 0, 3, 1, 1 和 -12, -2, 0, 0, 0, 3, 13, 5, 1

将负数分组，然后为零，然后为正数： [-][0][+] 。 三个阵列中的顺序均不需要。这三个组仅需订购。

要获得这些结果，请参见演示2 。

说明

演示1

首先，按升序对数组进行排序：

constordered =数组.sort（（（当前，下一个）=>当前-下一个）；
接下来，找到第一个大于0的数字的索引，然后提取所有从该索引开始到最后一个数字结束的数字。将提取的数组存储在变量中：

常量肯定=有序.splice（有序.findIndex（数字=>数字> 0））；
最后，按降序对提取的数组进行排序，然后将提取的数组连接到原始数组的末尾：

退回订单.concat（positive.sort（（current，next）=> next-current））;

演示2

创建由filter()方法返回的三个新数组：负数（n < 0），零（n === 0)和正数（n > 0）。
然后将它们串联成一个数组：


const negative = array.filter（number => number <0）;

常量零= array.filter（数字=>数字=== 0）;

const positive = array.filter（number => number> 0）;

返回negative.concat（零，正）；

演示1

const unorderedA = [3, -2, 1, 0, -1, 0, -2, 1];
const unorderedB = [3, -12, 0, 0, 13, 5, 1, 0, -2];

const illogical = array => {
  const ordered = array.sort((current, next) => current - next);
  const positive = ordered.splice(ordered.findIndex(number => number > 0));
  return ordered.concat(positive.sort((current, next) => next - current));
};

// For demonstration purposes

const log = data => {
  const string = Array.isArray(data) ? `[${data.join(', ')}]` : data;
  return console.log(string);
};

log(illogical(unorderedA));
log(illogical(unorderedB));

演示2

const unorderedA = [3, -2, 1, 0, -1, 0, -2, 1];
const unorderedB = [3, -12, 0, 0, 13, 5, 1, 0, -2];

const illogical = array => {
  const negative = array.filter(number => number < 0);
  const zero = array.filter(number => number === 0);
  const positive = array.filter(number => number > 0);
  return negative.concat(zero, positive);
};

// For demonstration purposes

const log = data => {
  const string = Array.isArray(data) ? `[${data.join(', ')}]` : data;
  return console.log(string);
};

log(illogical(unorderedA));
log(illogical(unorderedB));

以特殊顺序对数组进行排序

4 个答案:

逻辑还是错别字？

说明

演示1

演示2