Question

我一直在尝试解决我遇到的在线Javascript挑战。所以问题是这样的我有一个数组

let strng="103 123 4444 99 2000"

所以我必须根据各个元素的总和将它们按升序排列

103=1+0+3=4
123=1+2+3=6
4444=4+4+4+4=16
99=9+9=18
2000=2+0+0+0=2

所以现在基于结果，需要按升序对strng数组中的元素进行排序最终答案应该是

["2000" "103" "123" "4444" "99"]

因此，我尝试了一下，然后我就下一步该做什么完全感到困惑下面是我的代码

let s=[]

let f=strng.split(' ')
console.log(f)
f.map(item=>{
  let d=item.split('').reduce((a,b)=>Number(a)+Number(b),0)
  s.push(d)

  s.sort((a,b)=>a-b)


})
 console.log(s)     // gives me [2, 4, 6, 16, 18]

因此，我已根据它们对它们进行了排序。总和单个元素的位数，但现在我应该怎样或如何将元素排列在strng数组中？我需要通过按升序排序返回strng数组。因此，作为初学者，我想问的下一步是什么？我完全陷在这里了。

Answer 1

您的一般方法很好，但是不要使用map，而要使用sort。毕竟这就是目的。 :-)我也可能会给自己一个sumDigits函数：

function sumDigits(str) {
    return str.split("").reduce((s, v) => s + Number(v), 0);
}

然后sort大致（array是原始字符串上split(" ")的结果）

array.sort((a, b) => sumDigits(a) - sumDigits(b));

然后大概需要通过.join(" ")将结果重新连接为单个字符串。

请注意，我没有故意提供完整的联合解决方案，因为我的感觉是您需要帮助弄清楚这一点，而不是将解决方案交给您。：-）

Answer 2

这是我的解决方法：

const string = "103 123 4444 99 2000".split(' ');
const sumString = (str) => str.split('').reduce((s, c) => s + Number(c), 0)

string.sort((a, b) => {
    return sumString(a) - sumString(b);
});

console.log(string); //["2000", "103", "123", "4444", "99"]

Answer 3

您可以将问题分解成较小的部分，例如一个用于获取总和的函数或一个用于存储给定字符串的总和的函数，以防止将同一字符串累加。

最后使用预先计算的总和进行排序。

let sum = s => Array.from(s, Number).reduce((a, b) => a + b, 0),
    strings = ["103", "321", "123", "4444", "99", "2000", "20"],
    sums = strings.reduce((m, s) => m.set(s, sum(s)), new Map);

strings.sort((a, b) => sums.get(a) - sums.get(b));

console.log(strings);

Answer 4

也许是这样的：

   let strng="103 123 4444 99 2000";

   var string_arr = strng.split(' ');
   for(var key_sa in string_arr){
   	   var cur_str = string_arr[key_sa];
   	   var cur_str_arr =  cur_str.split('');
   	   var cur_str_sum = 0;
   	   for(var key_csa in cur_str_arr){
   	   	    cur_str_sum += parseInt(cur_str_arr[key_csa]) || 0;
   	   }
   	   console.log(cur_str_sum);
   }

Answer 5

请检查以下代码段。可能有帮助。

function arrangeNums(s) {
   function getSum(num) {
    return num.split('').map(n => parseInt(n)).reduce((acc, curr) => acc + curr, 0);
   }
   
   return s.split(' ').sort((a,b) => getSum(a) - getSum(b)).join(' ');
}

let strng="103 321 123 4444 99 2000 20";
console.log(arrangeNums(strng));

Answer 6

代码的功能样式。

str.split(/\s+/)
   .map(a => [a, 
              a.split('')
               .reduce((acc, b) => acc + Number(b), 0)])
   .sort((a, b) => a[1] -  b[1])
   .map(e => e[0])

let str = "103 321 123 4444 99 2000 20"

let res = str.split(/\s+/)
            .map(a => [a
                      ,a.split('')
                        .reduce((acc, b) => acc + Number(b), 0)
                      ])
            .sort((a, b) => a[1] -  b[1])
            .map(e => e[0])
            
 console.log(res)

Answer 7

我的2美分（忍者代码？）

这个想法实现了，我最终意识到“ 321”和“ 123”是同一和（6）；
同上代表“ 4444”和“ 88”，甚至是“ 2000”和“ 2” ...
在这些平等的情况下，有必要保持自然秩序

即：

sortStrArray('103 123 4444 99 20') -> '20 103 123 4444 99'
sortStrArray('2000 99 123 4444 2') -> '2 2000 123 4444 99'
sortStrArray('321 4444 123 88 99') -> '123 321 88 4444 99'

const sum =s=>[...s].reduce((t,x)=>t+(+x),0)
  ,   sortStrArray =s=>s.split(' ').sort((a,b)=>{r=sum(a)-sum(b);return (r?r:(+a)-(+b))}).join(' ')
  ;

const values= [ '103 123 4444 99 20'
              , '2000 99 123 4444 2'
              , '321 4444 123 88 99'
              ];

// proof (run snippeet)
values.forEach(val=>console.log(`sortStrArray('${val}') -> '${sortStrArray(val) }'`))

.as-console-wrapper { max-height: 100% !important; top: 0; }

根据数组中元素的数量之和对元素进行排序

7 个答案: