之前，我在Codewars上看到一道名为Recover a secret string from random triplets的题，这道题使我寻思了良久，终究在朋侪的协助下我完成了这个问题。当我完成这个问题而且看到其他大神的答案时， 我就以为我真的很有必要纪录一下这道题，而且思索它在JavaScript中的完成。

这道问题的也许意义是讲：有一个暗码字符串存在，而你会取得这个暗码字符串的随机三个字符的鸠合，依据这个鸠合你须要复原出这个暗码字符串。
已知：
1.暗码字符串中不会涌现反复的字母
2.这个鸠合包括了足能够推断出暗码字符串的信息
3.暗码字符串不会不包括鸠合中的字母

英文好的朋侪能够看下面的原文题干，问题作者诠释的比我清晰：

There is a secret string which is unknown to you. Given a collection
of random triplets from the string, recover the original string.

A triplet here is defined as a sequence of three letters such that each letter occurs somewhere before the next in the given string.

“whi” is a triplet for the string “whatisup”.

As a simplification, you may assume that no letter occurs more than once in the secret string.
You can assume nothing about the triplets given to you other than that they are valid triplets and that they contain sufficient

information to deduce the original string. In particular, this means
that the secret string will never contain letters that do not occur in
one of the triplets given to you.

也能够经由过程一个例子来明白问题：

secret1 = "whatisup"    // 暗码字符串-->递次的输出
triplets1 = [           // 鸠合 --> 递次的输入
  ['t','u','p'],
  ['w','h','i'],
  ['t','s','u'],
  ['a','t','s'],
  ['h','a','p'],
  ['t','i','s'],
  ['w','h','s']
]
var recoverSecret = function(triplets) {
// ... -->递次的完成
}

我以为这道问题做起来很惬意，虽然答案并非第一时间很快就写出来的，然则题干清晰简单就免除了浏览明白的干扰也是杜绝了由于题意冗杂 明白不到位造成了递次毛病。而且完成要领也多种多样，在做完答案后看看大神的最好实践也是一种享用。

下面是我的解决方案：
起首，列出鸠合中一切的字母，由于鸠合和暗码字符串中的字母品种是一致且无反复的，所以只须要把列出的一切字母去重就能够获得暗码字符串的无序分列。

triplets1 = [           // 原鸠合
  ['t','u','p'],
  ['w','h','i'],
  ['t','s','u'],
  ['a','t','s'],
  ['h','a','p'],
  ['t','i','s'],
  ['w','h','s']
]

triplets2 =['t','u','p',  // 列出的一切鸠合字母
'w','h','i','t','s','u',
'a','t','s','h','a','p',
't','i','s','w','h','s']

triplets3 =['t','u','p','w','h','i','s','a']  // 去重后的鸠合 无序字符串

然后我们再依据原鸠合给出的分列规则将无序字符串举行分列，而经由过程视察，我发明原鸠合中每一个小数组之间的递次关联太甚冗杂以至有的小数组之间都没有递次关联（比方 triplets1[0] 和 triplets1[1] ），那末最轻易完成的解决办法就是只顾及每一个小数组三个字母之间的递次关联：

['t','u','p'] // 粗体--> 第一个小数组的第一个递次关联
['t','u','p','w','h','i','s','a'] // 找到 't' 和 'u' 发明递次准确
['t','u','p'] // 粗体--> 第一个小数组的第二个递次关联
['t','u','p','w','h','i','s','a'] // 找到 'u' 和 'p' 发明递次准确
['w','h','i'] // 粗体--> 第二个小数组的第一个递次关联
['t','u','p','w','h','i','s','a'] // 找到 'w' 和 'h' 发明递次准确
['w','h','i'] // 粗体--> 第二个小数组的第二个递次关联
['t','u','p','w','h','i','s','a'] // 找到 'h' 和 'i' 发明递次准确
['t','s','u'] //粗体--> 第三个小数组的第一个递次关联
['t','u','p','w','h','i','s','a'] // 找到 't' 和 's' 发明递次不准确
['s','u','p','w','h','i','t','a'] // 交流位置
// ...顺次类推，末了的效果是
['w','t','a','h','p','i','u','s']

很明显能够看到只依据一次的比较还不足以获得效果的递次，所以我们要外衣一个轮回，继承运用原鸠合的递次信息继承排序，直到悉数排序完成输出答案。

下面是我JavaScript的递次完成：

const recoverSecret =(triplets)=> {
let result = ""
//  分列鸠合字符串 去重
  for(let i=0; i < triplets.length; i++){      
    for(let j = 0; j < triplets[i].length; j++){
      if (result.indexOf(triplets[i][j]) == -1){
        result += triplets[i][j]
      }
    }
  }
 // 用于标识while大轮回是不是举行
  var flag = true
  while(flag){
  flag = false
   for(let i = 0; i < triplets.length; i++){
     for(let j = 0; j < 2; j++){
       if (result.indexOf(triplets[i][j]) > result.indexOf(triplets[i][j+1])){
         flag = true
// 给交流字母位置
         result = result.replace(triplets[i][j], triplets[i][j+1]).replace(triplets[i][j+1], triplets[i][j])
       }
     }
   }
   }
  return result
}

代码中用到的API比较少，差不多为以下两个：

String.indexOf(searchValue)
要领返回挪用String对象中第一次涌现的指定值的索引，最先在 fromIndex举行搜刮。
searchValue示意被查找的值

String.replace(regexp, substr)
要领返回一个由替代值替代一些或一切婚配的形式后的新字符串。形式能够是一个字符串或许一个正则表达式, 替代值能够是一个字符串或许一个每次婚配都要挪用的函数。
regexp示意要被替代的字符串
substr示意替代的字符串

*以上API材料来源于MDN

末了我要说 这个问题还远远没有完，而它的诱人的地方就在于它不止一个解决办法，假如你没有思绪，能够在Codewars上粘贴我上面的代码并提交（如许你才能够看到他人的答案）研讨大神的解决方案就会发明它的魅力。闻一知十，多多思索，多多实践才是进修前端的最好实践。