Javascript函数来显示所跟随城市的路线

我正在codewars.com上练习编码。 我发现：

我们正在追踪我们的流氓探员马修·奈特，又称罗伊·米勒 他从一个地方到另一个地方旅行以避免被跟踪。每个 他的旅行是基于一份不寻常或不寻常的旅行路线清单 顺序不正确。任务是确定他将采取的路线 他的每一次旅行。你会得到他的一系列路线 行程。只列出他要去的正确地点 根据他的行程订购

示例：路线=

[[USA，BRA]，[JPN，PHL]，[BRA，UAE]，[UAE，JPN]]

结果：

“美国、巴西、阿联酋、日本、菲律宾”

我已尝试使用以下代码：

function findRoutes(routes) {

    let newArr = Array.prototype.concat.apply([], routes)
    let unique = newArr.filter((v, i, a) => a.indexOf(v) === i);

    return unique.join(', ');
  
}
console.log(findRoutes([["USA","BRA"],["JPN","PHL"],["BRA","UAE"],["UAE","JPN"]]))

它仅适用于给定的案例，但当我尝试对抗另一个测试案例时：

[["Chicago", "Winnipeg"], ["Halifax", "Montreal"], ["Montreal", "Toronto"], ["Toronto", "Chicago"], ["Winnipeg", "Seattle"]]

如果失败了……因此我知道有些事情不对，因为运动应该是有序的。

---

我很乐意改进它或从另一个想法重写它。

这里有一个算法，它遵循一个接一个的目标：

function findFrom(routes, dest) {
  let from = null;
    routes.forEach(function(cv, i, arr) {
    if (cv[1] == dest) {
      //console.log('found - ' + cv[1]);
      from = cv[0];
    }
  });
  return from;
}

function findDest(routes, from) {
  let dest = null;
    routes.forEach(function(cv, i, arr) {
    if (cv[0] == from) {
      //console.log('found - ' + cv[1]);
      dest = cv[1];
    }
  });
  return dest;
}

function findRoutes(routes) {
    var output = [];
  //start with first one
  if (routes.length == 0) {
    return output;
  }
  
  //find starting point
  var firstFrom = null;
  var from = routes[0][0]; 
  var dest = null;
  var counter = 0;
  do {    
    firstFrom = findFrom(routes, from);
    if (firstFrom != null) {
      from = firstFrom
    }
    counter++;
  } while (firstFrom != null && counter < routes.length);
  
  //write down starting point
  output.push(from);
  
  //find subsequent elements
  counter = 0; //reset
  do {
    dest = findDest(routes, from);
    if (dest != null) {
      output.push(dest);
      from = dest;
    }
    counter++;
  } while (dest != null && counter < routes.length);
  return output;
}

console.log(findRoutes([["USA","BRA"],["JPN","PHL"],["BRA","UAE"],["UAE","JPN"]]));

console.log(findRoutes([["Chicago", "Winnipeg"], ["Halifax", "Montreal"], ["Montreal", "Toronto"], ["Toronto", "Chicago"], ["Winnipeg", "Seattle"]]));

函数findFrom（路由、目的地）{
let from=null；
forEach路由（功能（cv、i、arr）{
如果（cv[1]==dest）{
//console.log（'found-'+cv[1]）；
from=cv[0]；
}
});
返乡；
}
函数findTest（路由、自）{
设dest=null；
forEach路由（功能（cv、i、arr）{
如果（cv[0]==从）{
//console.log（'found-'+cv[1]）；
dest=cv[1]；
}
});
返回目的地；
}
函数findrootes（路由）{
var输出=[]；
//从第一个开始
如果（routes.length==0）{
返回输出；
}
//找到起点
var firstFrom=null；
var from=路由[0][0]；
var dest=null；
var计数器=0；
做{
firstFrom=findFrom（路由，自）；
if（firstFrom！=null）{
from=firstFrom
}
计数器++；
}while（firstFrom！=null&&counter

我把它保存在这个

结果是：

它是如何工作的？ 它通过任何给定元素寻找起点（我们将从第一个元素开始）。 找到起点后，就可以找到所有后续元素。 它查看给定的对，每一步遍历数组一次。一旦你有了一个城市，你就可以从这一对中得到目的地。现在，以目标为起点再次查看所有数组

我还添加了一个循环检查。有一个计数器变量，一旦数组的整个长度被检查完毕，它将停止任何搜索。因此，如果目的地包含一个循环，它将只在目的地循环一次

你的怎么了？您会发现城市的第一个索引如下：

---

这里有一个解决方案。我不会说这是最好的策略，但它是有效的。我就是这样做的：

使用双循环查找第一个城市（没有任何以其名称开头的项目的城市）

从routes数组中删除包含第一个城市的元素

遍历routes数组以查找下一个城市并删除元素，直到列表为空

添加您要查找的最后一个“下一个”城市（最后一个元素的第二个城市）

let routes=[[“芝加哥”、“温尼伯”、“哈利法克斯”、“蒙特利尔”、“蒙特利尔”、“多伦多”、“多伦多”、“芝加哥”、“温尼伯”、“西雅图”]]
设解=[]；
让next=''；
对于（i=0；i=路由长度）{
解决方案：推送（第一）；
线路.拼接（i，1）；
打破
}
}
while（routes.length！==0）{
对于（i=0；iconsole.log（解决方案）可以按如下方式执行：

function findRoutes(routes) {
  let result = '';
  let next = '';
  const routesArr = routes.reduce((returnArr, arr) => {
      returnArr[0].push(arr[0]);
      returnArr[1].push(arr[1]);
      return returnArr;
  }, [[], []]);

  const start = routesArr[0].filter(str => 
  !routesArr[1].includes(str))[0];
  result += start;
  next = start;

  for(let i = 0; i < routesArr[0].length; i++) {
    const index = routesArr[0].indexOf(next);
    next = routesArr[1][index];
    result += `, ${next}`;
  }

  return result;
}

函数findrootes（路由）{
让结果=“”；
让next=''；
const routesArr=路由。reduce（（returnArr，arr）=>{
returnArr[0]。推送（arr[0]）；
returnArr[1]。push（arr[1]）；
返回arr；
}, [[], []]);
const start=routesArr[0]。筛选器（str=>
！routesArr[1]。包括（str））[0]；
结果+=开始；
下一步=开始；
for（设i=0；i
尝试为每个元组查找上一个元组。如果你找不到，这是第一个行程。从这一点开始，找到下一个元组，其中原点是当前元组的目标。我错了，更正了代码。看一看。