Si lo desea, escriba un programa que clasifique las ciudades de acuerdo con las reglas del juego de nombres de ciudades.

• Cada nombre de la ciudad debe comenzar desde la última letra del nombre de la ciudad anterior. P.ejLviv -> v -> Viden -> n -> Neapolis -> s -> Sidney -> y -> Yokogama -> a -> Amsterdam -> m -> Madrid -> d -> Denwer

• En la lista ordenada, la primera letra de la primera ciudad y la última letra de la última no deben coincidir con nada , no tiene que ser la misma letra.

• Puede suponer que los nombres de ciudades solo tienen letras.
• La salida del programa debe tener la misma capitalización que la entrada

Ejemplo:

% ./script Neapolis Yokogama Sidney Amsterdam Madrid Lviv Viden Denwer
["Lviv", "Viden", "Neapolis", "Sidney", "Yokogama", "Amsterdam", "Madrid", "Denwer"]

Ruby, 58 55 44 caracteres

p$*.permutation.find{|i|i*?,!~/(.),(?!\1)/i}

Otra implementación más de rubí. También utiliza expresiones regulares sin distinción entre mayúsculas y minúsculas (como la antigua solución de Ventero ), pero la prueba se realiza de manera diferente.

Versión previa:

p$*.permutation.find{|i|(i*?,).gsub(/(.),\1/i,"")!~/,/}

Python ( 162 141 124)

Fuerza bruta para la victoria.

from itertools import*
print[j for j in permutations(raw_input().split())if all(x[-1]==y[0].lower()for x,y in zip(j,j[1:]))]

Ruby 1.9, 63 54 caracteres

La nueva solución se basa en la solución de Howard :

p$*.permutation.max_by{|i|(i*?,).scan(/(.),\1/i).size}

Esto utiliza el hecho de que siempre habrá una solución válida.

Solución anterior, basada en la solución de w0lf :

p$*.permutation.find{|i|i.inject{|a,e|a&&e[0]=~/#{a[-1]}/i&&e}}

Rubí 74 72104103 71 70

p$*.permutation.find{|i|i.inject{|a,e|a[-1].casecmp(e[0])==0?e:?,}>?,}

Demostración: http://ideone.com/MDK5c (en la demostración que he usado en gets().split()lugar de $*; No sé si Ideone puede simular argumentos de línea de comandos).

Python, 113

Muy similar a la respuesta de @ beary605, e incluso más forzada.

from random import*
l=raw_input().split()
while any(x[-1]!=y[0].lower()for x,y in zip(l,l[1:])):
 shuffle(l)
print l

Haskell , 94 74 bytes

g[a]=[[a]]
g c=[b:r|b<-c,r<-g[x|x<-c,x/=b],last b==[r!!0!!0..]!!32]
head.g

Recurrentemente encuentra todas las soluciones. -7 bytes si está bien generar todas las soluciones en lugar de la primera. ¡Gracias a @Lynn por deshacerse de la molesta importación, eliminando 18 bytes de la puntuación!

Pruébalo en línea!

GolfScript, 78 caracteres

" ":s/.{1${1$=!},{:h.,{1$-1={1$0=^31&!{[1$1$]s*[\](\h\-c}*;}+/}{;.p}if}:c~;}/;

Una primera versión en GolfScript. También hace un enfoque de fuerza bruta. Puede ver el script que se ejecuta en la entrada de ejemplo en línea .

Casco , 10 bytes

←fΛ~=o_←→P

Pruébalo en línea!

Explicación

←fΛ~=(_←)→P  -- example input: ["Xbc","Abc","Cba"]
          P  -- all permutations: [["Xbc","Abc","Cba"],…,[Xbc","Cba","Abc"]]
 f           -- filter by the following (example with ["Xbc","Cba","Abc"])
  Λ          -- | all adjacent pairs ([("Xbc","Cba"),("Cba","Abc")])
   ~=        -- | | are they equal when..
     (_←)    -- | | .. taking the first character lower-cased
         →   -- | | .. taking the last character
             -- | : ['c'=='c','a'=='a'] -> 4
             -- : [["Xbc","Cba","Abc"]]
←            -- take the first element: ["Xbc","Cba","Abc"]

Alternativamente, 10 bytes

También podríamos contar el número de pares adyacentes que satisfacen el predicado ( #), ordenar en ( Ö) eso y tomar el último elemento ( →) para el mismo número de bytes:

→Ö#~=o_←→P

Pruébalo en línea!

Jelly , 25 18 bytes (¡Se aceptan mejoras!)

UżḢŒuE
ḲŒ!çƝẠ$ÐfḢK

Pruébalo en línea!

UżḢŒuE        dyadic (2-arg) "check two adjacent city names" function:
Uż            pair (żip) the letters of the reversed left argument with the right argument,
  Ḣ           get the Ḣead of that pairing to yield just the last letter of left and the first letter of right,
   Œu         capitalize both letters,
     E       and check that they're equal!
ḲŒ!çƝẠ$ÐfḢK    i/o and check / fold function:
ḲŒ!            split the input on spaces and get all permutations of it,
   çƝẠ$        run the above function on every adjacent pair (çƝ), and return true if Ȧll pairs are true
       Ðf      filter the permutations to only get the correct ones,
         ḢK    take the first of those, and join by spaces!

¡Gracias a @Lynn por la mayoría de estas mejoras!

Solución de 25 bytes:

Uḣ1Œu=⁹ḣ1
çƝȦ
ḲŒ!©Ç€i1ị®K

Pruébalo en línea!

Uḣ1Œu=⁹ḣ1      dyadic (2-arg) "check two adjacent city names" function:
Uḣ1Œu          reverse the left arg, get the ḣead, and capitalize it (AKA capitalize the last letter),
     =⁹ḣ1      and check if it's equal to the head (first letter) of the right argument.
çƝȦ            run the above function on every adjacent pair (çƝ), and return true if Ȧll pairs are true
ḲŒ!©Ç€i1ị®K     main i/o function:
ḲŒ!©           split the input on spaces and get all its permutations, ©opy that to the register
    Ç€         run the above link on €ach permutation,
      i1       find the index of the first "successful" permutation,
        ị®K    and ®ecall the permutation list to get the actual ordering at that ịndex, separating output by spaces

Mathematica 236 caracteres

Defina la lista de ciudades:

d = {"Neapolis", "Yokogama", "Sidney", "Amsterdam", "Madrid", "Lviv", "Viden", "Denver"}

Encuentra el camino que incluye todas las ciudades:

c = Characters; f = Flatten;
w = Outer[List, d, d]~f~1;
p = Graph[Cases[w, {x_, y_} /;x != y \[And] (ToUpperCase@c[x][[-1]]== c[y][[1]]) :> (x->y)]];
v = f[Cases[{#[[1]], #[[2]], GraphDistance[p, #[[1]], #[[2]]]} & /@  w, {_, _, Length[d] - 1}]];
FindShortestPath[p, v[[1]], v[[2]]]

Salida:

{"Lviv", "Viden", "Neapolis", "Sidney", "Yokogama", "Amsterdam","Madrid", "Denver"}

El enfoque anterior supone que las ciudades se pueden organizar como un gráfico de ruta.

El gráfico p se muestra a continuación:

C, 225

#define S t=v[c];v[c]=v[i];v[i]=t
#define L(x)for(i=x;i<n;i++)
char*t;f;n=0;main(int c,char**v){int i;if(!n)n=c,c=1;if(c==n-1){f=1;L(2){for(t=v[i-1];t[1];t++);if(v[i][0]+32-*t)f=n;}L(f)puts(v[i]);}else L(c){S;main(c+1,v);S;}}

Ejecutar con nombres de países como argumentos de línea de comando

Nota:

• generación de fuerza bruta de permutaciones
• para verificarlo, se supone que los nombres de países comienzan con mayúsculas y terminan en minúsculas.
• asume que solo hay una respuesta
• En C, se supone que la matriz ** v de main () se puede escribir

J, 69 65 60 59 54 caracteres

Algo fuera del ritmo.

{.l\:+/2=/\|:tolower;"2({.,{:)@>l=.(i.@!@#A.]);:1!:1[1

Ejemplo:

   {.l\:+/2=/\|:tolower;"2({.,{:)@>l=.(i.@!@#A.]);:1!:1[1
Neapolis Yokogama Sydney Amsterdam Madrid Lviv Viden Denwer
+----+-----+--------+------+--------+---------+------+------+
|Lviv|Viden|Neapolis|Sydney|Yokogama|Amsterdam|Madrid|Denwer|
+----+-----+--------+------+--------+---------+------+------+

C #, 398

Y aquí está C # con Linq 5 centavos

IEnumerable<string>CityNameGame(string[]input){var cities=new List<string>(input);string lastCity=null;while(cities.Any()){var city=lastCity??cities.First();lastCity=cities.First(name=>string.Equals(city.Substring(city.Length-1),name.Substring(0,1),StringComparison.CurrentCultureIgnoreCase));cities.RemoveAll(name=>name==city||name==lastCity);yield return string.Format("{0}→{1}",city,lastCity);}}

K, 96

{m@&{&/(~).'+(,_1_1#'x),,-1_-1#'x}@'$m:{$[x=1;y;,/.z.s[x-1;y]{x,/:{x@&~x in y}[y;x]}\:y]}[#x;x]}

.

k){m@&{&/(~).'+(,_1_1#'x),,-1_-1#'x}@'$m:{$[x=1;y;,/.z.s[x-1;y]{x,/:{x@&~x in y}[y;x]}\:y]}[#x;x]}`Neapolis`Yokogama`Sidney`Amsterdam`Madrid`Lviv`Viden`Denver
Lviv Viden Neapolis Sidney Yokogama Amsterdam Madrid Denver

C # (.NET Core) , 297 bytes

using System;
using System.Linq;

var S="";int I=0,C=s.Count();for(;I<C;I++)S=Array.Find(s,x=>s[I].Substring(0,1).ToUpper()==x.Substring(x.Length-1).ToUpper())==null?s[I]:S;for(I=0;I<C;I++){Console.Write(S+" ");S=C>I?Array.Find(s,x=>S.Substring(S.Length-1).ToUpper()==x.Substring(0,1).ToUpper()):"";}

Pruébalo en línea!

using System;
using System.Linq;

var S = "";
int I = 0, C = s.Count();
for (; I < C; I++)
    S = Array.Find(
        s, x =>
        s[I].Substring(0, 1).ToUpper() == x.Substring(x.Length - 1).ToUpper()
    ) == null ?
    s[I] :
    S;
for (I = 0; I < C; I++) {
    Console.Write(S + " ");
    S = C > I ? Array.Find(s, x => S.Substring(S.Length - 1).ToUpper() == x.Substring(0, 1).ToUpper()) : "";
}