İsterseniz, şehir adı oyun kurallarına göre şehirleri sıralayan bir program yazın.

• Şehrin her adı, önceki şehir adının son harfinden başlamalıdır. ÖrneğinLviv -> v -> Viden -> n -> Neapolis -> s -> Sidney -> y -> Yokogama -> a -> Amsterdam -> m -> Madrid -> d -> Denwer

• İlk şehir ve Sonuncu mektubun sıralı liste ilk mektupta şey eşleşmemelidir aynı harf olmak zorunda değildir.

• Şehir adlarının yalnızca harfleri olduğunu varsayabilirsiniz.
• Program çıktısı girdi ile aynı büyük harf kullanımına sahip olmalıdır

Misal:

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

Yakut, 58 55 44 karakter

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

Yine başka bir yakut uygulaması. Ayrıca büyük / küçük harf duyarsız regex kullanır ( Ventero'nun eski çözümü olarak ), ancak test farklı şekilde yapılır.

Önceki versiyon:

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

Python ( 162 141 124)

Kazanmak için kaba kuvvet.

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

Yakut 1.9, 63 54 karakter

Yeni çözüm dayanmaktadır Howard bireyin çözümü :

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

Bu, her zaman geçerli bir çözüm olacağı gerçeğini kullanır.

Dayalı Eski çözümü, w0lf 'ın çözümü :

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

Yakut 74 72104103 71 70

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

Demo: http://ideone.com/MDK5c ( gets().split()bunun yerine kullandığım demoda $*; Ideone'nin komut satırı argümanlarını simüle edip edemeyeceğini bilmiyorum).

Python, 113

@ Beary605'in cevabına çok benzer ve hatta daha kaba-zorla.

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 bayt

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

Tüm çözümleri özyineli olarak bulur. -7 bayt birincisi yerine tüm çözümleri çıktı almak için uygun. @Lynn'e sinir bozucu ithalden kurtulduğu için skordan 18 bayt tıraş!

Çevrimiçi deneyin!

GolfScript, 78 karakter

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

GolfScript'teki ilk sürüm. Ayrıca kaba kuvvet yaklaşımı da uygular. Örnek girişte çevrimiçi çalışan komut dosyasını görebilirsiniz .

Kabuk , 10 bayt

←fΛ~=o_←→P

Çevrimiçi deneyin!

açıklama

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

Alternatif olarak, 10 bayt

Ayrıca yüklemi ( #) tatmin eden , sıralayan ( Ö) sıralayan →ve aynı sayıda bayt için son elemanı ( ) alan bitişik çiftlerin sayısını da sayabiliriz :

→Ö#~=o_←→P

Çevrimiçi deneyin!

Jöle , 25 18 bayt (İyileştirmeler hoş geldiniz!)

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

Çevrimiçi deneyin!

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!

Bu geliştirmelerin çoğu için @Lynn'e teşekkürler!

25 baytlık çözelti:

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

Çevrimiçi deneyin!

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 karakter

Şehirlerin listesini tanımlayın:

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

Tüm şehirleri içeren yolu bulun:

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

Çıktı:

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

Yukarıdaki yaklaşım, şehirlerin bir yol grafiği olarak düzenlenebileceğini varsayar.

P grafiği aşağıda gösterilmiştir:

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

Komut satırı bağımsız değişkenleri olarak ülke adlarıyla çalıştırın

Not:

• kaba kuvvet permütasyon üretimi
• kontrol etmek için ülke adlarının büyük harfle başladığını ve küçük harfle sona erdiğini varsayar.
• sadece bir cevap olduğunu varsayar
• C'de, main () öğesinin ** v dizisinin yazılabilir olduğunu varsayar

J, 69 65 60 59 54 karakter

Biraz hızda.

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

Misal:

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

Ve Linq 5 sentli C #

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 bayt

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

Çevrimiçi deneyin!

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