Sort a list of pairs representing an acyclic, partial automorphism





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}







9












$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$



migrated from stackoverflow.com 2 days ago


This question came from our site for professional and enthusiast programmers.


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    2 days ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    2 days ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    2 days ago


















9












$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$



migrated from stackoverflow.com 2 days ago


This question came from our site for professional and enthusiast programmers.


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    2 days ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    2 days ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    2 days ago














9












9








9





$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$




I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)






javascript algorithm sorting graph






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited yesterday









Solomon Ucko

1,1891415




1,1891415










asked 2 days ago









Shivam BhallaShivam Bhalla

21715




21715




migrated from stackoverflow.com 2 days ago


This question came from our site for professional and enthusiast programmers.









migrated from stackoverflow.com 2 days ago


This question came from our site for professional and enthusiast programmers.














  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    2 days ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    2 days ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    2 days ago


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    2 days ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    2 days ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    2 days ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    2 days ago
















$begingroup$
is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
$endgroup$
– karthick
2 days ago




$begingroup$
is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
$endgroup$
– karthick
2 days ago












$begingroup$
Is from unique for all elements?
$endgroup$
– Taplar
2 days ago




$begingroup$
Is from unique for all elements?
$endgroup$
– Taplar
2 days ago












$begingroup$
@karthick yes the origin and final should be the same.
$endgroup$
– Shivam Bhalla
2 days ago




$begingroup$
@karthick yes the origin and final should be the same.
$endgroup$
– Shivam Bhalla
2 days ago












$begingroup$
@Taplar yes from is unique
$endgroup$
– Shivam Bhalla
2 days ago




$begingroup$
@Taplar yes from is unique
$endgroup$
– Shivam Bhalla
2 days ago












$begingroup$
The task you want to perform is a simple kind of topological sorting.
$endgroup$
– 200_success
2 days ago




$begingroup$
The task you want to perform is a simple kind of topological sorting.
$endgroup$
– 200_success
2 days ago










5 Answers
5






active

oldest

votes


















7












$begingroup$

Code style




  • Use constants for variables that do not change. Eg const sortedArray = ;


  • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



  • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



    However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



  • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


  • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


  • Rather than use Array.filter you can use Array.find. It will find the first instance.


  • Using for...of rather than for(;;) reduces the code complexity.


  • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


  • Put a space between if and (


  • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


  • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



Using the above points to modify your code we get



function tripFrom(trips, from) {
const sorted = ;
const first = trips.find(trip => trip.from === from);
sorted.push(first);

for (const trip of trips) {
if (first.to === trip.from) {
sorted.push(trip);
break;
}
}
for (const trip of trips) {
if (sorted[sorted.length - 1].to === trip.from) {
sorted.push(trips);
break;
}
}
return sorted;
}

sortByLinked(trips, "JFK");


This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



Improving the function.



It can all be done within a single loop and work for any length array.



To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




  1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

  2. That the array does not contain circular trips shorter than the array length.

  3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

  4. Locations are case sensitive.

  5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


Example



function tripFrom(trips, from) {
const result = ;
while (result.length < trips.length) {
const trip = trips.find(trip => trip.from === from);
if (!trip) { break }
from = trip.to;
result.push(trip);
}
return result;
}
tripFrom(trips, "JFK");


Or if it is known that the trip is the same length as the input array.



function tripFrom(trips, from) {
const res = ;
while (res.length < trips.length) {
from = (res[res.length] = trips.find(trip => trip.from === from)).to;
}
return res;
}
tripFrom(trips, "JFK");


It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



function tripFrom(trips, from) {
const res = ;
while (res.length < trips.length) {
from = (res[res.length] = trips.find(trip => trip.from === from)).to;
}
trips.length = 0;
trips.push(...res);
return trips;
}
tripFrom(trips, "JFK");





share|improve this answer









$endgroup$













  • $begingroup$
    It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
    $endgroup$
    – Adam
    yesterday










  • $begingroup$
    @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
    $endgroup$
    – Blindman67
    yesterday










  • $begingroup$
    Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
    $endgroup$
    – Adam
    yesterday



















5












$begingroup$

It would be good if your function could work for more than 3 trips.



And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






function sortByLinked(trips, origin = "JFK") {
const map = new Map(trips.map(trip => [trip.from, trip]));
const result = ;
for (let trip; trip = map.get(origin); origin = trip.to) {
result.push(trip);
map.delete(origin);
}
return result;
}

const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
const sorted = sortByLinked(trips, "JFK");
console.log(sorted);








share|improve this answer









$endgroup$













  • $begingroup$
    Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
    $endgroup$
    – Eric Duminil
    yesterday










  • $begingroup$
    Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
    $endgroup$
    – trincot
    yesterday



















4












$begingroup$

Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



Here's one way to sort it in place and can handle any number of trips greater than 1.






function sortByLinked(trips, origin = 'JFK') {

// this will be useful
function swap(array, index1, index2){
let temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}

// find first one
let first = trips.filter(trip => trip.from === origin)[0];

// put him in the front of the list
swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

// sort it in place
for(let i=1; i<trips.length; i++){
swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
}
}








share|improve this answer










New contributor




matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






$endgroup$













  • $begingroup$
    Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
    $endgroup$
    – Sᴀᴍ Onᴇᴌᴀ
    2 days ago





















0












$begingroup$

You could also solve the problem by introducing an object mo (as a makeshift associative array) like shown in the following example



const trav=[{from:"bos",to:"sfo"},{from:"jer",to:"jfk"},{from:"zur",to:"brm"},{from:"haj",to:"cdg"},{from:"pma",to:"mlg"},{from:"sfo",to:"zur"},
{from:"cdg",to:"hav"},{from:"jfk",to:"haj"},{from:"man",to:"cdg"},
{from:"mlg",to:"jer"},{from:"brm",to:"pma"},{from:"hav",to:"bos"}],
mo={},srt=;
var fr='jfk',v,n=20;
trav.forEach(v=>mo[v.from]=v);
while (n--&&(v=mo[fr])){srt.push(v);fr=v.to;}
console.log(JSON.stringify(srt));


The n is a "safety switch` that gets you out when the sequence turns out to be circular (as is the case in my example).






share|improve this answer










New contributor




cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






$endgroup$









  • 2




    $begingroup$
    Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
    $endgroup$
    – chicks
    yesterday



















0












$begingroup$

This problem is related to graph theory, and you're looking for an Eulerian cycle:




In graph theory, an Eulerian trail (or Eulerian path) is a trail in a
finite graph which visits every edge exactly once. Similarly, an
Eulerian circuit or Eulerian cycle is an Eulerian trail which starts
and ends on the same vertex.




You can find a Eulerian cycle if and only if every airport is connected to an even number of airports. To find the cycle in linear time, you can use Hierholzer's algorithm.



You could use a graph library for Javascript, e.g. Cytoscape.






share|improve this answer









$endgroup$














    Your Answer






    StackExchange.ifUsing("editor", function () {
    StackExchange.using("externalEditor", function () {
    StackExchange.using("snippets", function () {
    StackExchange.snippets.init();
    });
    });
    }, "code-snippets");

    StackExchange.ready(function() {
    var channelOptions = {
    tags: "".split(" "),
    id: "196"
    };
    initTagRenderer("".split(" "), "".split(" "), channelOptions);

    StackExchange.using("externalEditor", function() {
    // Have to fire editor after snippets, if snippets enabled
    if (StackExchange.settings.snippets.snippetsEnabled) {
    StackExchange.using("snippets", function() {
    createEditor();
    });
    }
    else {
    createEditor();
    }
    });

    function createEditor() {
    StackExchange.prepareEditor({
    heartbeatType: 'answer',
    autoActivateHeartbeat: false,
    convertImagesToLinks: false,
    noModals: true,
    showLowRepImageUploadWarning: true,
    reputationToPostImages: null,
    bindNavPrevention: true,
    postfix: "",
    imageUploader: {
    brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
    contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
    allowUrls: true
    },
    onDemand: true,
    discardSelector: ".discard-answer"
    ,immediatelyShowMarkdownHelp:true
    });


    }
    });














    draft saved

    draft discarded


















    StackExchange.ready(
    function () {
    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217351%2fsort-a-list-of-pairs-representing-an-acyclic-partial-automorphism%23new-answer', 'question_page');
    }
    );

    Post as a guest















    Required, but never shown

























    5 Answers
    5






    active

    oldest

    votes








    5 Answers
    5






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes









    7












    $begingroup$

    Code style




    • Use constants for variables that do not change. Eg const sortedArray = ;


    • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



    • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



      However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



    • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


    • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


    • Rather than use Array.filter you can use Array.find. It will find the first instance.


    • Using for...of rather than for(;;) reduces the code complexity.


    • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


    • Put a space between if and (


    • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


    • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



    Using the above points to modify your code we get



    function tripFrom(trips, from) {
    const sorted = ;
    const first = trips.find(trip => trip.from === from);
    sorted.push(first);

    for (const trip of trips) {
    if (first.to === trip.from) {
    sorted.push(trip);
    break;
    }
    }
    for (const trip of trips) {
    if (sorted[sorted.length - 1].to === trip.from) {
    sorted.push(trips);
    break;
    }
    }
    return sorted;
    }

    sortByLinked(trips, "JFK");


    This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



    Improving the function.



    It can all be done within a single loop and work for any length array.



    To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




    1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

    2. That the array does not contain circular trips shorter than the array length.

    3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

    4. Locations are case sensitive.

    5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


    Example



    function tripFrom(trips, from) {
    const result = ;
    while (result.length < trips.length) {
    const trip = trips.find(trip => trip.from === from);
    if (!trip) { break }
    from = trip.to;
    result.push(trip);
    }
    return result;
    }
    tripFrom(trips, "JFK");


    Or if it is known that the trip is the same length as the input array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    return res;
    }
    tripFrom(trips, "JFK");


    It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    trips.length = 0;
    trips.push(...res);
    return trips;
    }
    tripFrom(trips, "JFK");





    share|improve this answer









    $endgroup$













    • $begingroup$
      It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
      $endgroup$
      – Adam
      yesterday










    • $begingroup$
      @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
      $endgroup$
      – Blindman67
      yesterday










    • $begingroup$
      Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
      $endgroup$
      – Adam
      yesterday
















    7












    $begingroup$

    Code style




    • Use constants for variables that do not change. Eg const sortedArray = ;


    • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



    • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



      However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



    • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


    • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


    • Rather than use Array.filter you can use Array.find. It will find the first instance.


    • Using for...of rather than for(;;) reduces the code complexity.


    • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


    • Put a space between if and (


    • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


    • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



    Using the above points to modify your code we get



    function tripFrom(trips, from) {
    const sorted = ;
    const first = trips.find(trip => trip.from === from);
    sorted.push(first);

    for (const trip of trips) {
    if (first.to === trip.from) {
    sorted.push(trip);
    break;
    }
    }
    for (const trip of trips) {
    if (sorted[sorted.length - 1].to === trip.from) {
    sorted.push(trips);
    break;
    }
    }
    return sorted;
    }

    sortByLinked(trips, "JFK");


    This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



    Improving the function.



    It can all be done within a single loop and work for any length array.



    To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




    1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

    2. That the array does not contain circular trips shorter than the array length.

    3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

    4. Locations are case sensitive.

    5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


    Example



    function tripFrom(trips, from) {
    const result = ;
    while (result.length < trips.length) {
    const trip = trips.find(trip => trip.from === from);
    if (!trip) { break }
    from = trip.to;
    result.push(trip);
    }
    return result;
    }
    tripFrom(trips, "JFK");


    Or if it is known that the trip is the same length as the input array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    return res;
    }
    tripFrom(trips, "JFK");


    It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    trips.length = 0;
    trips.push(...res);
    return trips;
    }
    tripFrom(trips, "JFK");





    share|improve this answer









    $endgroup$













    • $begingroup$
      It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
      $endgroup$
      – Adam
      yesterday










    • $begingroup$
      @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
      $endgroup$
      – Blindman67
      yesterday










    • $begingroup$
      Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
      $endgroup$
      – Adam
      yesterday














    7












    7








    7





    $begingroup$

    Code style




    • Use constants for variables that do not change. Eg const sortedArray = ;


    • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



    • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



      However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



    • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


    • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


    • Rather than use Array.filter you can use Array.find. It will find the first instance.


    • Using for...of rather than for(;;) reduces the code complexity.


    • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


    • Put a space between if and (


    • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


    • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



    Using the above points to modify your code we get



    function tripFrom(trips, from) {
    const sorted = ;
    const first = trips.find(trip => trip.from === from);
    sorted.push(first);

    for (const trip of trips) {
    if (first.to === trip.from) {
    sorted.push(trip);
    break;
    }
    }
    for (const trip of trips) {
    if (sorted[sorted.length - 1].to === trip.from) {
    sorted.push(trips);
    break;
    }
    }
    return sorted;
    }

    sortByLinked(trips, "JFK");


    This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



    Improving the function.



    It can all be done within a single loop and work for any length array.



    To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




    1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

    2. That the array does not contain circular trips shorter than the array length.

    3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

    4. Locations are case sensitive.

    5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


    Example



    function tripFrom(trips, from) {
    const result = ;
    while (result.length < trips.length) {
    const trip = trips.find(trip => trip.from === from);
    if (!trip) { break }
    from = trip.to;
    result.push(trip);
    }
    return result;
    }
    tripFrom(trips, "JFK");


    Or if it is known that the trip is the same length as the input array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    return res;
    }
    tripFrom(trips, "JFK");


    It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    trips.length = 0;
    trips.push(...res);
    return trips;
    }
    tripFrom(trips, "JFK");





    share|improve this answer









    $endgroup$



    Code style




    • Use constants for variables that do not change. Eg const sortedArray = ;


    • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



    • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



      However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



    • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


    • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


    • Rather than use Array.filter you can use Array.find. It will find the first instance.


    • Using for...of rather than for(;;) reduces the code complexity.


    • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


    • Put a space between if and (


    • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


    • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



    Using the above points to modify your code we get



    function tripFrom(trips, from) {
    const sorted = ;
    const first = trips.find(trip => trip.from === from);
    sorted.push(first);

    for (const trip of trips) {
    if (first.to === trip.from) {
    sorted.push(trip);
    break;
    }
    }
    for (const trip of trips) {
    if (sorted[sorted.length - 1].to === trip.from) {
    sorted.push(trips);
    break;
    }
    }
    return sorted;
    }

    sortByLinked(trips, "JFK");


    This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



    Improving the function.



    It can all be done within a single loop and work for any length array.



    To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




    1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

    2. That the array does not contain circular trips shorter than the array length.

    3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

    4. Locations are case sensitive.

    5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


    Example



    function tripFrom(trips, from) {
    const result = ;
    while (result.length < trips.length) {
    const trip = trips.find(trip => trip.from === from);
    if (!trip) { break }
    from = trip.to;
    result.push(trip);
    }
    return result;
    }
    tripFrom(trips, "JFK");


    Or if it is known that the trip is the same length as the input array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    return res;
    }
    tripFrom(trips, "JFK");


    It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    trips.length = 0;
    trips.push(...res);
    return trips;
    }
    tripFrom(trips, "JFK");






    share|improve this answer












    share|improve this answer



    share|improve this answer










    answered 2 days ago









    Blindman67Blindman67

    9,5201622




    9,5201622












    • $begingroup$
      It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
      $endgroup$
      – Adam
      yesterday










    • $begingroup$
      @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
      $endgroup$
      – Blindman67
      yesterday










    • $begingroup$
      Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
      $endgroup$
      – Adam
      yesterday


















    • $begingroup$
      It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
      $endgroup$
      – Adam
      yesterday










    • $begingroup$
      @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
      $endgroup$
      – Blindman67
      yesterday










    • $begingroup$
      Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
      $endgroup$
      – Adam
      yesterday
















    $begingroup$
    It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
    $endgroup$
    – Adam
    yesterday




    $begingroup$
    It's common practice to avoid using braces in inline if-statements (your first example). Also, you make a comment about a missing semicolon and I'd like to point out, just for the sake of having options, that completely getting rid of semicolons is a growing practice since it generally looks nicer.
    $endgroup$
    – Adam
    yesterday












    $begingroup$
    @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
    $endgroup$
    – Blindman67
    yesterday




    $begingroup$
    @Adam It may be a common practice to not delimit single line statement blocks, but that does not make it a good practice.Consistency is the most important part of good style. If you use semicolon then use them, not just sometimes. Generally I advice that if you are not going to use them then you should know every case where automatic insertion will not happen but is required to mark the end of line. Eg "(()=>{});n()" is not the same as "(()=>{})n()" (as string to show new line location)
    $endgroup$
    – Blindman67
    yesterday












    $begingroup$
    Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
    $endgroup$
    – Adam
    yesterday




    $begingroup$
    Right. I'm not saying he shouldn't use a semicolon in that specific spot. I'm just making it known that completely getting rid of semicolon delimiters is a very common practice nowadays.
    $endgroup$
    – Adam
    yesterday













    5












    $begingroup$

    It would be good if your function could work for more than 3 trips.



    And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);








    share|improve this answer









    $endgroup$













    • $begingroup$
      Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
      $endgroup$
      – Eric Duminil
      yesterday










    • $begingroup$
      Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
      $endgroup$
      – trincot
      yesterday
















    5












    $begingroup$

    It would be good if your function could work for more than 3 trips.



    And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);








    share|improve this answer









    $endgroup$













    • $begingroup$
      Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
      $endgroup$
      – Eric Duminil
      yesterday










    • $begingroup$
      Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
      $endgroup$
      – trincot
      yesterday














    5












    5








    5





    $begingroup$

    It would be good if your function could work for more than 3 trips.



    And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);








    share|improve this answer









    $endgroup$



    It would be good if your function could work for more than 3 trips.



    And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);








    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);





    function sortByLinked(trips, origin = "JFK") {
    const map = new Map(trips.map(trip => [trip.from, trip]));
    const result = ;
    for (let trip; trip = map.get(origin); origin = trip.to) {
    result.push(trip);
    map.delete(origin);
    }
    return result;
    }

    const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
    const sorted = sortByLinked(trips, "JFK");
    console.log(sorted);






    share|improve this answer












    share|improve this answer



    share|improve this answer










    answered 2 days ago









    trincottrincot

    48737




    48737












    • $begingroup$
      Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
      $endgroup$
      – Eric Duminil
      yesterday










    • $begingroup$
      Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
      $endgroup$
      – trincot
      yesterday


















    • $begingroup$
      Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
      $endgroup$
      – Eric Duminil
      yesterday










    • $begingroup$
      Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
      $endgroup$
      – trincot
      yesterday
















    $begingroup$
    Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
    $endgroup$
    – Eric Duminil
    yesterday




    $begingroup$
    Interesting. It doesn't work with cycles, though, does it? e.g. [{from: "JFK",to: "XXX"},{from: "XXX",to: "YYY"},{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}]
    $endgroup$
    – Eric Duminil
    yesterday












    $begingroup$
    Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
    $endgroup$
    – trincot
    yesterday




    $begingroup$
    Indeed, it is not expecting multiple trip objects with the same from property. That would need a more comprehensive tree traversal.
    $endgroup$
    – trincot
    yesterday











    4












    $begingroup$

    Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



    Here's one way to sort it in place and can handle any number of trips greater than 1.






    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }








    share|improve this answer










    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$













    • $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      2 days ago


















    4












    $begingroup$

    Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



    Here's one way to sort it in place and can handle any number of trips greater than 1.






    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }








    share|improve this answer










    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$













    • $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      2 days ago
















    4












    4








    4





    $begingroup$

    Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



    Here's one way to sort it in place and can handle any number of trips greater than 1.






    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }








    share|improve this answer










    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$



    Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



    Here's one way to sort it in place and can handle any number of trips greater than 1.






    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }








    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }





    function sortByLinked(trips, origin = 'JFK') {

    // this will be useful
    function swap(array, index1, index2){
    let temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
    }

    // find first one
    let first = trips.filter(trip => trip.from === origin)[0];

    // put him in the front of the list
    swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

    // sort it in place
    for(let i=1; i<trips.length; i++){
    swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
    }
    }






    share|improve this answer










    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.









    share|improve this answer



    share|improve this answer








    edited 2 days ago









    Sᴀᴍ Onᴇᴌᴀ

    10.4k62168




    10.4k62168






    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.









    answered 2 days ago









    matthewlam.jsmatthewlam.js

    411




    411




    New contributor




    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.





    New contributor





    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.












    • $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      2 days ago




















    • $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      2 days ago


















    $begingroup$
    Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
    $endgroup$
    – Sᴀᴍ Onᴇᴌᴀ
    2 days ago






    $begingroup$
    Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
    $endgroup$
    – Sᴀᴍ Onᴇᴌᴀ
    2 days ago













    0












    $begingroup$

    You could also solve the problem by introducing an object mo (as a makeshift associative array) like shown in the following example



    const trav=[{from:"bos",to:"sfo"},{from:"jer",to:"jfk"},{from:"zur",to:"brm"},{from:"haj",to:"cdg"},{from:"pma",to:"mlg"},{from:"sfo",to:"zur"},
    {from:"cdg",to:"hav"},{from:"jfk",to:"haj"},{from:"man",to:"cdg"},
    {from:"mlg",to:"jer"},{from:"brm",to:"pma"},{from:"hav",to:"bos"}],
    mo={},srt=;
    var fr='jfk',v,n=20;
    trav.forEach(v=>mo[v.from]=v);
    while (n--&&(v=mo[fr])){srt.push(v);fr=v.to;}
    console.log(JSON.stringify(srt));


    The n is a "safety switch` that gets you out when the sequence turns out to be circular (as is the case in my example).






    share|improve this answer










    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$









    • 2




      $begingroup$
      Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
      $endgroup$
      – chicks
      yesterday
















    0












    $begingroup$

    You could also solve the problem by introducing an object mo (as a makeshift associative array) like shown in the following example



    const trav=[{from:"bos",to:"sfo"},{from:"jer",to:"jfk"},{from:"zur",to:"brm"},{from:"haj",to:"cdg"},{from:"pma",to:"mlg"},{from:"sfo",to:"zur"},
    {from:"cdg",to:"hav"},{from:"jfk",to:"haj"},{from:"man",to:"cdg"},
    {from:"mlg",to:"jer"},{from:"brm",to:"pma"},{from:"hav",to:"bos"}],
    mo={},srt=;
    var fr='jfk',v,n=20;
    trav.forEach(v=>mo[v.from]=v);
    while (n--&&(v=mo[fr])){srt.push(v);fr=v.to;}
    console.log(JSON.stringify(srt));


    The n is a "safety switch` that gets you out when the sequence turns out to be circular (as is the case in my example).






    share|improve this answer










    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$









    • 2




      $begingroup$
      Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
      $endgroup$
      – chicks
      yesterday














    0












    0








    0





    $begingroup$

    You could also solve the problem by introducing an object mo (as a makeshift associative array) like shown in the following example



    const trav=[{from:"bos",to:"sfo"},{from:"jer",to:"jfk"},{from:"zur",to:"brm"},{from:"haj",to:"cdg"},{from:"pma",to:"mlg"},{from:"sfo",to:"zur"},
    {from:"cdg",to:"hav"},{from:"jfk",to:"haj"},{from:"man",to:"cdg"},
    {from:"mlg",to:"jer"},{from:"brm",to:"pma"},{from:"hav",to:"bos"}],
    mo={},srt=;
    var fr='jfk',v,n=20;
    trav.forEach(v=>mo[v.from]=v);
    while (n--&&(v=mo[fr])){srt.push(v);fr=v.to;}
    console.log(JSON.stringify(srt));


    The n is a "safety switch` that gets you out when the sequence turns out to be circular (as is the case in my example).






    share|improve this answer










    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    $endgroup$



    You could also solve the problem by introducing an object mo (as a makeshift associative array) like shown in the following example



    const trav=[{from:"bos",to:"sfo"},{from:"jer",to:"jfk"},{from:"zur",to:"brm"},{from:"haj",to:"cdg"},{from:"pma",to:"mlg"},{from:"sfo",to:"zur"},
    {from:"cdg",to:"hav"},{from:"jfk",to:"haj"},{from:"man",to:"cdg"},
    {from:"mlg",to:"jer"},{from:"brm",to:"pma"},{from:"hav",to:"bos"}],
    mo={},srt=;
    var fr='jfk',v,n=20;
    trav.forEach(v=>mo[v.from]=v);
    while (n--&&(v=mo[fr])){srt.push(v);fr=v.to;}
    console.log(JSON.stringify(srt));


    The n is a "safety switch` that gets you out when the sequence turns out to be circular (as is the case in my example).







    share|improve this answer










    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.









    share|improve this answer



    share|improve this answer








    edited yesterday





















    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.









    answered yesterday









    cars10mcars10m

    1012




    1012




    New contributor




    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.





    New contributor





    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.






    cars10m is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.








    • 2




      $begingroup$
      Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
      $endgroup$
      – chicks
      yesterday














    • 2




      $begingroup$
      Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
      $endgroup$
      – chicks
      yesterday








    2




    2




    $begingroup$
    Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
    $endgroup$
    – chicks
    yesterday




    $begingroup$
    Welcome to Code Reviews, cars10m. Providing an alternative implementation is interesting and handy on some level, but it doesn't constitute a code review. Was there something so wrong with the original that you needed to rewrite it instead of tweaking it in smaller ways?
    $endgroup$
    – chicks
    yesterday











    0












    $begingroup$

    This problem is related to graph theory, and you're looking for an Eulerian cycle:




    In graph theory, an Eulerian trail (or Eulerian path) is a trail in a
    finite graph which visits every edge exactly once. Similarly, an
    Eulerian circuit or Eulerian cycle is an Eulerian trail which starts
    and ends on the same vertex.




    You can find a Eulerian cycle if and only if every airport is connected to an even number of airports. To find the cycle in linear time, you can use Hierholzer's algorithm.



    You could use a graph library for Javascript, e.g. Cytoscape.






    share|improve this answer









    $endgroup$


















      0












      $begingroup$

      This problem is related to graph theory, and you're looking for an Eulerian cycle:




      In graph theory, an Eulerian trail (or Eulerian path) is a trail in a
      finite graph which visits every edge exactly once. Similarly, an
      Eulerian circuit or Eulerian cycle is an Eulerian trail which starts
      and ends on the same vertex.




      You can find a Eulerian cycle if and only if every airport is connected to an even number of airports. To find the cycle in linear time, you can use Hierholzer's algorithm.



      You could use a graph library for Javascript, e.g. Cytoscape.






      share|improve this answer









      $endgroup$
















        0












        0








        0





        $begingroup$

        This problem is related to graph theory, and you're looking for an Eulerian cycle:




        In graph theory, an Eulerian trail (or Eulerian path) is a trail in a
        finite graph which visits every edge exactly once. Similarly, an
        Eulerian circuit or Eulerian cycle is an Eulerian trail which starts
        and ends on the same vertex.




        You can find a Eulerian cycle if and only if every airport is connected to an even number of airports. To find the cycle in linear time, you can use Hierholzer's algorithm.



        You could use a graph library for Javascript, e.g. Cytoscape.






        share|improve this answer









        $endgroup$



        This problem is related to graph theory, and you're looking for an Eulerian cycle:




        In graph theory, an Eulerian trail (or Eulerian path) is a trail in a
        finite graph which visits every edge exactly once. Similarly, an
        Eulerian circuit or Eulerian cycle is an Eulerian trail which starts
        and ends on the same vertex.




        You can find a Eulerian cycle if and only if every airport is connected to an even number of airports. To find the cycle in linear time, you can use Hierholzer's algorithm.



        You could use a graph library for Javascript, e.g. Cytoscape.







        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered yesterday









        Eric DuminilEric Duminil

        2,1111613




        2,1111613






























            draft saved

            draft discarded




















































            Thanks for contributing an answer to Code Review Stack Exchange!


            • Please be sure to answer the question. Provide details and share your research!

            But avoid



            • Asking for help, clarification, or responding to other answers.

            • Making statements based on opinion; back them up with references or personal experience.


            Use MathJax to format equations. MathJax reference.


            To learn more, see our tips on writing great answers.




            draft saved


            draft discarded














            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217351%2fsort-a-list-of-pairs-representing-an-acyclic-partial-automorphism%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown





















































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown

































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown







            Popular posts from this blog

            數位音樂下載

            When can things happen in Etherscan, such as the picture below?

            格利澤436b