Nếu bạn thích, hãy viết một chương trình sắp xếp các thành phố theo quy tắc của trò chơi tên thành phố.

• Mỗi tên của thành phố nên bắt đầu từ chữ cái cuối cùng trong tên thành phố trước đó. Ví dụLviv -> v -> Viden -> n -> Neapolis -> s -> Sidney -> y -> Yokogama -> a -> Amsterdam -> m -> Madrid -> d -> Denwer

• Trong danh sách được sắp xếp, chữ cái đầu tiên của thành phố đầu tiên và chữ cái cuối cùng của chữ cuối cùng không nên khớp với bất cứ thứ gì không phải là cùng một chữ cái.

• Bạn có thể giả sử tên thành phố chỉ có chữ cái.
• Đầu ra chương trình nên có cùng chữ viết hoa với đầu vào

Thí dụ:

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

Ruby, 58 55 44 ký tự

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

Một thực hiện ruby ​​khác. Sử dụng cũng trường hợp regex không nhạy cảm (như giải pháp cũ của Ventero ) nhưng thử nghiệm được thực hiện khác nhau.

Phiên bản trước:

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

Con trăn ( 162 141 124)

Lực lượng vũ phu cho chiến thắng.

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 ký tự

Giải pháp mới dựa trên giải pháp của Howard :

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

Điều này sử dụng thực tế là sẽ luôn có một giải pháp hợp lệ.

Giải pháp cũ, dựa trên giải pháp của w0lf :

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

Ruby 74 72 104 103 71 70

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

Bản trình diễn: http://ideone.com/MDK5c (trong bản demo tôi đã sử dụng gets().split()thay vì $*; Tôi không biết liệu Ideone có thể mô phỏng các đối số dòng lệnh không).

Con trăn, 113

Rất giống với câu trả lời của @ beary605, và thậm chí còn tàn bạo hơn.

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 byte

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

Đệ quy tìm tất cả các giải pháp. -7 byte nếu xuất ra tất cả các giải pháp thay vì đầu tiên. Cảm ơn @Lynn vì đã thoát khỏi việc nhập khẩu phiền phức, loại bỏ 18 byte khỏi điểm số!

Hãy thử trực tuyến!

GolfScript, 78 ký tự

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

Một phiên bản đầu tiên trong GolfScript. Nó cũng làm một cách tiếp cận vũ phu. Bạn có thể thấy tập lệnh chạy trên ví dụ đầu vào trực tuyến .

Husk , 10 byte

←fΛ~=o_←→P

Hãy thử trực tuyến!

Giải trình

←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"]

Ngoài ra, 10 byte

Chúng ta cũng có thể đếm số lượng các cặp liền kề thỏa mãn vị ngữ ( #), sắp xếp trên ( Ö) và lấy phần tử cuối cùng ( →) cho cùng một số byte:

→Ö#~=o_←→P

Hãy thử trực tuyến!

Jelly , 25 18 byte (Chào mừng cải tiến!)

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

Hãy thử trực tuyến!

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!

Cảm ơn @Lynn vì hầu hết những cải tiến này!

Giải pháp 25 byte:

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

Hãy thử trực tuyến!

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

Toán học 236 ký tự

Xác định danh sách các thành phố:

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

Tìm đường dẫn bao gồm tất cả các thành phố:

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]]]

Đầu ra:

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

Cách tiếp cận trên giả định rằng các thành phố có thể được sắp xếp dưới dạng biểu đồ đường dẫn.

Biểu đồ p được hiển thị dưới đây:

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;}}

Chạy với tên quốc gia làm đối số dòng lệnh

Ghi chú:

• thế hệ vũ phu của hoán vị
• để kiểm tra, giả sử rằng tên quốc gia bắt đầu bằng chữ in hoa và kết thúc bằng chữ thường.
• giả sử chỉ có một câu trả lời
• Trong C, giả sử rằng mảng ** v của hàm main () có thể ghi được

J, 69 65 60 59 54 ký tự

Hơi lạc nhịp.

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

Thí dụ:

   {.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

Và đây là C # với Linq 5 xu

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 byte

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()):"";}

Hãy thử trực tuyến!

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()) : "";
}