शहर के नाम का खेल

Question

यदि आप चाहें, तो एक प्रोग्राम लिखें, जो शहर के नाम के खेल के नियमों के अनुसार शहरों की तरह हो।

• शहर का प्रत्येक नाम पिछले शहर के नाम के अंतिम अक्षर से शुरू होना चाहिए। उदाहरण के लिएLviv -> v -> Viden -> n -> Neapolis -> s -> Sidney -> y -> Yokogama -> a -> Amsterdam -> m -> Madrid -> d -> Denwer

• पहले शहर के क्रमबद्ध सूची में पहले शहर और आखिरी के अंतिम अक्षर से कुछ भी मेल नहीं खाना चाहिए ।

• आप मान सकते हैं कि शहर के नाम में केवल अक्षर हैं।
• प्रोग्राम आउटपुट में इनपुट के समान कैपिटलाइज़ेशन होना चाहिए

उदाहरण:

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

Comments

क्या हम मान सकते हैं कि हमेशा एक वैध समाधान होगा?

— गारेथ

@ गैरेथ हाँ, आप कर सकते हैं

— डिफाल्ट करें

दूसरा नियम - "[...] कुछ भी मेल नहीं खाना चाहिए" - क्या यह एक आवश्यकता है या सिर्फ एक कथन है कि पहले और आखिरी पत्र के बीच बेमेल होना ठीक है? (पूर्व: ["Viden" ... "Lviv"]अमान्य की तरह एक सूची है ?)

— क्रिस्टियन लुपस्कू

@ w0lf "नहीं" से मेरा मतलब है कि यह नहीं है, यह अनिवार्य नहीं है। तो आपका उदाहरण मान्य है।

— परिभाषित करें

संकेत: यदि आप एक अच्छा समाधान चाहते हैं, तो आप इसे यूलरियन रास्तों की गणना के लिए कम कर सकते हैं, जहां प्रत्येक अक्षर एक शीर्ष है और प्रत्येक शब्द एक किनारे है। (उदाहरण के लिए, बर्लिन का किनारा B → N है ) यह O (n) में हल करने योग्य है, जहाँ n किनारों की संख्या है।

— 22

Answer 1

रूबी, 58 55 44 वर्ण

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

फिर भी एक और रूबी कार्यान्वयन। उपयोग असंवेदनशील रेगेक्स ( वेंटरो के पुराने समाधान के रूप में ) का भी उपयोग करते हैं, लेकिन परीक्षण अलग तरीके से किया जाता है।

पुराना वर्जन:

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

Comments

बहुत अच्छा! और मुझे लगता है कि आप इसे 55 से नीचे !~ला सकते हैं यदि आप पूरी अभिव्यक्ति को नकारने के बजाय इसका उपयोग करते हैं।

— क्रिस्टियन लुपस्कू

वह स्मार्ट

— रेगेक्सप है

@ w0lf बेशक! मैं यह कैसे नहीं सोच सकता था?

— हावर्ड

Answer 2

पायथन ( 162 141 124)

जीत के लिए क्रूर बल।

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

Comments

मुझे लगता है कि आप &(j[0][0]!=j[-1][-1])हालत को दूर कर सकते हैं; प्रश्न टिप्पणी ऊपर देखें।

— क्रिस्चियन लुपस्कू

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

— एवगेनस

मैं इस समारोह में क्या चल रहा है उसके चारों ओर अपना सिर लपेटने की कोशिश कर रहा हूं। वास्तव में कर रहे हैं क्या j, x, y? उन्हें कैसे परिभाषित किया जाता है? मुझे खेद है कि अगर ये प्रश्न लंगड़े हैं, तो मैं अजगर के लिए नया हूं और इसके साथ कुछ और काम करना चाहूंगा।

— रोब

@ मायिकड्रिक: jमें शहरों का एक क्रमांकन शामिल है, जो permutationsकमांड के साथ उत्पन्न होता है । ifअंत में बड़ा मूल रूप से मान्य करता है कि सभी मानों के लिए j, एक मान का अंतिम अक्षर jअगले मूल्य के पहले अक्षर के समान है j। ईमानदारी से, मैं या तो नहीं जानता कि क्या zipकरता है, zipरहस्यमय तरीके से काम करता है।

— बेय्युक ५०५

ठीक है, स्पष्टीकरण के लिए धन्यवाद! +1

— रोब

Answer 3

रूबी 1.9, 63 ५४ अक्षर

नया समाधान पर आधारित है हावर्ड के समाधान :

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

यह इस तथ्य का उपयोग करता है कि हमेशा एक वैध समाधान होगा।

पुराना समाधान, w0lf के समाधान पर आधारित है :

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

Comments

के साथ अच्छा विचार है max_by। और आपके नए संस्करण ने खुद को एक और भी नए (और छोटे) के लिए प्रेरित किया।

— हावर्ड

@ हावर्ड धन्यवाद! आपका नया समाधान वास्तव में बहुत बढ़िया है, इसे हरा पाना मुश्किल होगा। ;)

— वेंचरो

Answer 4

रूबी 74 72 104 103 71 70

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

डेमो: http://ideone.com/MDK5c ( gets().split()इसके बजाय मैंने जिस डेमो में उपयोग किया है $*, मुझे नहीं पता कि आइडोन कमांड-लाइन आर्ग्स का अनुकरण कर सकता है)।

Comments

मेरे वैरिएंट के समान दिखता है $*.permutation{|p|p p if p.inject(p[0][0]){|m,e|m.casecmp(e[0])==0?e[-1]:?_}>?_}लेकिन आपका चरित्र 9 अक्षर छोटा है!

— डिफाल्ट

p$*.permutation.find{|i|i.inject{|a,e|a&&e[0]=~/#{a[-1]}/i&&e}}काफी छोटा है। एक रूबी 1.8 (!) समाधान जो और भी छोटा है:p$*.permutation.find{|i|i.inject{|a,e|a&&a[-1]-32==e[0]&&e}}

— वेंटरो

@Ventero केस-असंवेदनशील रेगेक्स का उपयोग करना एक शानदार विचार है! कृपया इसे अपने उत्तर के रूप में पोस्ट करें; मैं इसका इस्तेमाल करने के लायक नहीं हूं। :)

— क्रिस्टियन लुपस्कू

@ वेंटरो -32समाधान भी बहुत सरल है, लेकिन यह इस तथ्य पर निर्भर करता है कि नाम एक बड़े अक्षर से शुरू होते हैं और एक लोअरकेस के साथ समाप्त होते हैं, जो हमेशा मामला नहीं हो सकता है।

— क्रिस्टियन लुपस्कू

@ w0lf आप सही हैं, मैंने सोचा कि मैं ऐनक में पढ़ता हूं कि यह मामला होगा, लेकिन जाहिर है कि मुझसे गलती हुई है। ;)

— वेंटरो

Answer 5

अजगर, 113

बहुत हद तक @ beary605 के जवाब के समान, और इससे भी अधिक क्रूर-मजबूर।

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

Comments

वोहू, बोगो-तरह की शैली!

— भालूy605

Answer 6

हास्केल , 94 74 बाइट्स

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

पुनरावर्ती सभी समाधान ढूँढता है। -7 बाइट्स अगर पहले के बजाय सभी समाधानों का उत्पादन करना ठीक है। Pesky आयात से छुटकारा पाने के लिए @Lynn को धन्यवाद, स्कोर से 18 बाइट शेविंग!

इसे ऑनलाइन आज़माएं!

Comments

आप के Data.Charसाथ आयात से छुटकारा पा सकते हैं last b==[r!!0!!0..]!!32। इसके अलावा, आप में कोष्ठक की जरूरत नहीं हैg[x|x<-c,x/=b]

— लिन

@ अच्छा, मैं किसी भी तरह सोचा fromEnumहोगा एक होगा। अजीब बात है, मैं उन कोष्ठकों को पहले से ही एक बार दूर ले गया, लेकिन मैंने गलत टैब से कॉपी किया होगा ...

— एंग्स

Answer 7

GolfScript, 78 वर्ण

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

GolfScript में पहला संस्करण। यह एक क्रूर बल दृष्टिकोण भी करता है। आप स्क्रिप्ट उदाहरण इनपुट पर चल रहा है देख सकते हैं ऑनलाइन ।

Answer 8

भूसी , 10 बाइट्स

←fΛ~=o_←→P

इसे ऑनलाइन आज़माएं!

व्याख्या

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

वैकल्पिक रूप से, 10 बाइट्स

हम आसन्न जोड़े की संख्या की गणना भी कर सकते हैं जो विधेय को संतुष्ट करती हैं ( #), Öउस पर क्रमबद्ध करें ( ) और अंतिम तत्व ( →) को समान संख्या में बाइट्स के लिए लें:

→Ö#~=o_←→P

इसे ऑनलाइन आज़माएं!

Answer 9

जेली , 25 18 बाइट्स (सुधार का स्वागत है!)

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

इसे ऑनलाइन आज़माएं!

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!

इनमें से अधिकांश सुधारों के लिए @Lynn को धन्यवाद!

25-बाइट समाधान:

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

इसे ऑनलाइन आज़माएं!

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

Comments

कुछ सुधार: इसे ऑनलाइन आज़माएं! मैंने "इनपुट" फ़ील्ड में थोड़ा चैंज लिखा। (ओह, के बाद Ðfमैं Xपहले वाले के बजाय एक यादृच्छिक समाधान चुनने के लिए उपयोग करता हूं , लेकिन Ḣसाथ ही साथ काम भी करता है।)

— लिन

@Lynn बहुत बहुत धन्यवाद! जिप वाला हिस्सा बहुत चालाक था, और मुझे लगता है कि मैं Ðfकुछ अन्य स्थानों को बचाने के लिए अपने अन्य कार्यक्रमों में उस त्वरित का उपयोग कर सकता हूं!

— हैरी

Answer 10

गणितज्ञ 236 वर्ण

शहरों की सूची को परिभाषित करें:

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

उस पथ को खोजें जिसमें सभी शहर शामिल हैं:

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

आउटपुट:

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

उपर्युक्त दृष्टिकोण मानता है कि शहरों को एक पथ ग्राफ के रूप में व्यवस्थित किया जा सकता है।

---

ग्राफ पी नीचे दिखाया गया है:

Answer 11

सी, 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;}}

कमांड लाइन तर्क के रूप में देश के नाम के साथ चलाएं

ध्यान दें:

• क्रमपरिवर्तन की क्रूर बल पीढ़ी
• यह जाँचने के लिए कि देश के नाम ऊपरी मामले से शुरू होते हैं और निचले मामले में समाप्त होते हैं।
• मानता है कि केवल एक ही उत्तर है
• सी में, मानता है कि मुख्य का ** v सरणी () योग्य है

Comments

सुनिश्चित नहीं है कि यह बिल्कुल मान्य है, लेकिन यदि आप करते हैं #define L(x)for(int i=x;i<n;i++)और आप iशुरुआत में घोषणा नहीं करते हैं mainतो 1 बाइट बचाएं।

— त्सथोगगुआ

Answer 12

जे, ६ ९ ६५ ६० ५ ९ ५४ अक्षर

कुछ हद तक गति।

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

उदाहरण:

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

Answer 13

सी #, 398

और यहाँ पर Linq 5 सेंट के साथ 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);}}

Answer 14

के, 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

Answer 15

सी # (.NET कोर) , 297 बाइट्स

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

इसे ऑनलाइन आज़माएं!

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