Given two strings s1 and s2, we want to visualize how different the two strings are. We will only take into account the lowercase letters (a to z). First let us count the frequency of each lowercase letters in s1 and s2.
原题地址: https://www.codewars.com/kata/5629db57620258aa9d000014/train/javascript
译者等级:codewars.com
题目等级:codewars.com
本文意图: 题目翻译 + 答案的注解
如有侵权, 请联系本文作者
译
有两个字符串 s1、s2，我们想要展现他俩有什么不同。我们将仅充分考虑小写字母（如：a-z）。首先让我们统计一下 s1、s2 每个小写字母的出现次数。
s1 = "A aaaa bb c"
s2 = "& aaa bbb c d"
s1 has 4 'a', 2 'b', 1 'c'
s2 has 3 'a', 3 'b', 1 'c', 1 'd'
在 s1、s2 中，‘a’ 的最大出现次数是 4 来自 s1；‘b’ 的最大出现次数是 3 来自 s2。接下来，我们将不考虑最大出现次数小于或等于 1 的字母。
我们可以整理 s1、s2 在接下来字符串中的不同：“1:aaaa/2:bbb” 中 1 在 1:aaa 代表字符串 s1 以及 aaaa 是由于 a 的最大出现次数是 4。相同的方式 2:bbb 代表字符串 s2 以及 bbb 是由于 b 的最大出现次数是 3。
该任务是生成一个字符串，其中 s1 或 s2 的小写字母的最大出现次数如果严格大于 1，则显示为最大出现次数; 这些字母将以字符串的数量作为前缀，它们在 : 后以最大的次数出现。如果最大出现次数在 s1 和 s2 中相同，则前缀为 =:。
在结果中，子字符串(子字符串为例 2:nnnnn 或 1:hhh; 它包含前缀)将会以其长度的递减顺序排列，当它们有相同长度的按升序排列顺序排列(字母和数字——更精确地按codepoint排序);不同的组将被“/”分开。参见示例和 “示例测试”。
希望其他的例子能让这个更清楚。
s1 = "my&friend&Paul has heavy hats! &"
s2 = "my friend John has many many friends &"
mix(s1, s2) --> "2:nnnnn/1:aaaa/1:hhh/2:mmm/2:yyy/2:dd/2:ff/2:ii/2:rr/=:ee/=:ss"
s1 = "mmmmm m nnnnn y&friend&Paul has heavy hats! &"
s2 = "my frie n d Joh n has ma n y ma n y frie n ds n&"
mix(s1, s2) --> "1:mmmmmm/=:nnnnnn/1:aaaa/1:hhh/2:yyy/2:dd/2:ff/2:ii/2:rr/=:ee/=:ss"
s1="Are the kids at home? aaaaa fffff"
s2="Yes they are here! aaaaa fffff"
mix(s1, s2) --> "=:aaaaaa/2:eeeee/=:fffff/1:tt/2:rr/=:hh"
Note for Swift
译者注: 本节不做翻译
The prefix =: is replaced by E:
s1 = "mmmmm m nnnnn y&friend&Paul has heavy hats! &"
s2 = "my frie n d Joh n has ma n y ma n y frie n ds n&"
mix(s1, s2) --> "1:mmmmmm/=:nnnnnn/1:aaaa/1:hhh/2:yyy/2:dd/2:ff/2:ii/2:rr/E:ee/E:ss"
解
译者注: 这里是自己尝试的解答
/**
* 辅助工具函数
* 传入字符串，用于为字符计数
* @param {*} s
*/
function m(s) {
let o = {};
/**
* 遍历每一个字符
* 将字符串转为数组，并遍历元素
*/
s.split('').map((v) => {
/**
* 根据题目要求，仅统计小写字母
*/
if (v >= 'a' && v <= 'z') {
o[v] = o[v] || 0;
o[v] += 1;
}
});
return o;
}
/**
* 主内容
* @param {*} s1
* @param {*} s2
*/
function mix(s1, s2) {
let ret = [];
let s = 'abcdefghijklmnopqrstuvwxyz';
/**
* 获取两个字符串中的字符计数
*/
let a1 = m(s1);
let a2 = m(s2);
/**
* 将小写字母集遍历
*/
s.split('').map((v) => {
let n,z;
/**
* 初始化当前小写字母统计数
*/
a1[v] = a1[v] || 0;
a2[v] = a2[v] || 0;
/**
* 小于或等于 1 不做统计
*/
if (a1[v] <=1 && a2[v] <= 1) return;
/**
* 用于得出 : 前为 1/2/=，以及字母重复次数
*/
if (a1[v] > a2[v]) {
n = '1';
z = a1[v];
} else if (a1[v] < a2[v]) {
n = '2';
z = a2[v];
} else {
n = '=';
z = a2[v];
}
/**
* 将符合条件的值加入集合
*/
ret.push({
n,
z,
v
});
});
/**
* 按照题目要求排序
*/
ret.sort((m, n) => {
/**
* 根据字母重复次数降序
*/
if (m.z - n.z) return -(m.z - n.z);
/**
* 字母数相同的情况，按照 1/2/= 排序
*/
if (m.n > n.n) return 1;
if (m.n < n.n) return -1;
/**
* 在 1/2/= 相同的情况下，按照字母升序
*/
if (m.v > n.v) return 1;
if (m.v < n.v) return -1;
/**
* 保险返回，应该无效
*/
return 0;
});
/**
* 将结果集合格式化
*/
return ret.map((v) => {
/**
* 形如
* 1:aaaaa
*/
return v.n + ':' + (new Array(v.z + 1).join(v.v));
}).join('/');
}
注
译者注: 截止 2017.10.10, 获得 [Best Practices] 最多的答案
译者注: 截止 2017.10.10, 获得 [Clever] 最多的答案
巧了，同一个
原答案观摩
function mix(s1, s2) {
var counter = s => s.replace(/[^a-z]/g,'').split('').sort().reduce((x,y)=> (x[y] = 1 + (x[y]||0), x),{});
s1 = counter(s1); s2 = counter(s2);
var res = [], keys = new Set(Object.keys(s1).concat(Object.keys(s2)));
keys.forEach(key => {
var c1 = s1[key]||0, c2 = s2[key]||0, count = Math.max(c1, c2);
if (count>1) {
var from = [1, '=', 2][Math.sign(c2-c1)+1];
var str = [...Array(count)].map(_=>key).join('');
res.push(from+':'+str);
}
});
return res.sort((x, y) => y.length - x.length || (x < y ? -1 : 1)).join('/');
}
解析注释
function mix(s1, s2) {
/**
* 辅助工具函数
* 传入字符串，用于为字符计数
* @param {*} s
*/
var counter = s => s
// 使用正则筛选去掉小写字母外的字符
.replace(/[^a-z]/g,'')
.split('')
.sort()
// 👍 使用 reduce 一步将统计结果输入
.reduce((x,y)=> (x[y] = 1 + (x[y]||0), x),{});
/**
* 获取两个字符串中的字符计数
*/
s1 = counter(s1); s2 = counter(s2);
/**
* 👍 合并两者统计结果，并使用 Set 去重
* 与我的答案相比，省去了对全部小写字母的遍历
*/
var res = [], keys = new Set(Object.keys(s1).concat(Object.keys(s2)));
keys.forEach(key => {
var c1 = s1[key]||0, c2 = s2[key]||0, count = Math.max(c1, c2);
if (count>1) {
/**
* 👍 使用 Math.sign 得出 1/2/=
*/
var from = [1, '=', 2][Math.sign(c2-c1)+1];
/**
* 得到字母重复
*/
var str = [...Array(count)].map(_=>key).join('');
/**
* 将格式化结果推入集合
*/
res.push(from+':'+str);
}
});
/**
* 👍 直接使用总长度 + 首字母排序，不需要提前排序
*/
return res.sort((x, y) => y.length - x.length || (x < y ? -1 : 1)).join('/');
}
做到最后，译者本人还有点小激动。
虽然高票答案仍然让我学到了不少。
但基本思路是一致的，岂不是非常自豪?
