给定一个数组，找到两个最短的字符串，提取它们并将它们附加到末尾，直到只剩下一个字符串

Question

我被困在两个小时的编码挑战中，需要帮助。完整说明如下：

给定一个字符串数组，生成一个字符串如下：

当数组中有多个字符串时重复以下步骤：

在数组中找到最短的字符串（如果有几个相同长度的字符串取最左边的那个）；

在其余字符串中找到最短的字符串（如果有几个字符串 一样长取最右边的那个）；

从数组中提取选中的字符串；

将它们连接的结果（第二个字符串应该添加到第一个字符串的末尾）附加到数组的右端。

算法完成后，数组中会剩下一个字符串。返回那个字符串。

我的解决方案尝试

function concatenationProcess(init) {
  var shortestString = init[0];
  var shorterString = init[0];
  var appendedString = "";
  while (init.length > 0) {
    for (i = init.length - 1; i >= 0; i--) {
      if (init[i].length <= shortestString.length) {
        shortestString = init[i];
      }
    }
    var newArray = init;
    newArray = init.splice(init.indexOf(shortestString), 1)
    for (i = 0; i < init.length; i++) {
      if (init[i].length <= shorterString.length) {
        shorterString = init[i];
      }
    }
    init.splice(init.indexOf(shorterString), 1)
    var newInit = init;
    console.log(shorterString, "shorter string")
    appendedString = shortestString + shorterString
    init.push(appendedString)
    console.log(init)
  }
}

Answer 1

这个条件使循环无限：

while (init.length > 0) {

当数组中只剩下 1 个元素时需要停止， 所以把 0 改成 1。

你也有一个错误。 您需要在每次迭代结束时更新shortestString 和shorterString 的值， 否则他们可能会保持过时的价值观。 例如，在示例输入["thinking", "whatface", "cantare", "wait", "jay", "cutler"] 中，它们将保持设置为jay 和wait， 永不改变， 并导致输出不正确。

你可能想在函数结束时return init[0]。

Answer 2

这里有一个完整的工作模型。每次都可以看到数组是如何变化的！！运行它。 思路很简单，找到shortest和shorter元素，删除，追加appended字符串。重复此操作，直到数组长度大于1。

顺便说一句，如果你想要这个值，那么当然用console.log或return替换alert。

function concatenationProcess(init) {
    while(init.length>1){
      var shortest = init[0];
      var appended = "";
      var p=0; // for storing the position of shortest/shorter
        for (i = init.length - 1; i >= 0; i--) {// find shortest
          if (init[i].length <= shortest.length) {
            shortest = init[i];
            p=i;
          }
        }
        init.splice(p,1); // remove shortest
        var shorter= init[0];
        for (i = 0; i <init.length; i++) { // find shorter
          if (init[i].length <= shorter.length) {
            shorter = init[i];
            p=i;
          }
        }
        init.splice(p,1); // remove shorter
       appended = shortest+shorter;
       init.push(appended); //append the appended string
       alert(init);
       }
    }
    var x = [ "thinking", "whatface", "cantare", "wait", "jay", "cutler"];
    concatenationProcess(x);

Answer 3

运行你的程序后，我想我发现了你的问题。您第一次通过数组正确设置了shortestString 和shorterString，但在第二次之前不要重置它们。这导致程序无法找到较短或相等长度的字符串并崩溃。但是，像您现在所做的重置会导致类似的问题：如果第一个字符串是最短的，则返回最短和较短的字符串（因为在删除之前它已保存到 shorterString 中）。要解决这个问题，只需存储每个字符串的长度，以便您可以将它们都初始化为Number.MAX_SAFE_INTEGER（或者我猜Infinity 会起作用）。停止while 循环的条件是init.length > 0 而不是> 1。您有几个毫无意义且未使用的作业（即newArray 和newInit）。无论如何，在从头开始编写你的函数之后，我最终得到了这个：

function concatenationProcess (init) {
    var shortestLength;
    while (init.length > 1) {
        shortestLength = Number.MAX_SAFE_INTEGER;
        var shortestString;
        for (var i = init.length-1; i >= 0; i--) {
            if (init[i].length <= shortestLength) {
                shortestString = init[i];
            }
        }
        init.splice(init.indexOf(shortestString), 1);

        shortestLength = Number.MAX_SAFE_INTEGER;
        var shorterString;
        for (var i = 0; i < init.length; i++) {
            if (init[i].length <= shortestLength) {
                shorterString = init[i];
            }
        }
        init.splice(init.indexOf(shorterString), 1);

        init.push(shortestString + shorterString);
    }
    return init[0]
}

Answer 4

这样的问题需要递归解决方案。

考虑一下这个问题以及一种不同的思考方式，这会导致一个非常简洁的解决方案（正如递归函数经常做的那样）：

function conArray(arr) {
  if (arr.length === 1) return arr
  var idx = arr.reduce((acc, curr, i) => curr.length < arr[acc].length ? i : acc, 0)  
  var str = arr.splice(idx, 1) 

  idx = arr.reduce((acc, curr, i) => curr.length <= arr[acc].length ? i : acc, 0) 
  str = str + arr.splice(idx, 1)

  arr.push(str)
  return conArray(arr)
}
conArray(["a","abc","abcc","aaa","z","","qw"])
// [ 'abcaaaabccqwaz' ]

这需要一个数组。如果数组只有一个元素，就完成了，直接返回即可。否则，找到最短的（从左边开始）和下一个从右边开始的最短的，将它们推到数组上并将其反馈给函数。