শহরের নাম খেলা

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"]অবৈধ?)

— ক্রিস্টিয়ান Lupascu

@ w0lf by "should not" বলতে চাইছি এটির দরকার নেই, এটি বাধ্যতামূলক নয়। সুতরাং আপনার উদাহরণ বৈধ।

— 16:39

ইঙ্গিত: আপনি যদি খুব ভাল সমাধান চান তবে আপনি এটি ইউরিরিয়ান পাথের গণনায় কমাতে পারেন, যেখানে প্রতিটি অক্ষর একটি শীর্ষবিন্দু এবং প্রতিটি শব্দই একটি প্রান্ত। (উদাহরণস্বরূপ, বার্লিন প্রান্ত B → N ) এটি হে (এন) এ দ্রবণীয়, যেখানে n প্রান্তের সংখ্যা।

— FUZxxl

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রহস্যজনক উপায়ে কাজ করে।

— beary605

ঠিক আছে, ব্যাখ্যার জন্য আপনাকে ধন্যবাদ! +1

— রব

Answer 3

রুবি ১.৯, 63 54 টি অক্ষর

নতুন সমাধান উপর ভিত্তি করে তৈরি হাওয়ার্ড এর সমাধান :

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

এটি সর্বদা একটি বৈধ সমাধান হবে তা এই সত্যটি ব্যবহার করে।

ডাব্লু0এলএফ এর সমাধানের উপর ভিত্তি করে পুরানো সমাধান :

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

Comments

সাথে ভাল ধারণা max_by। এবং আপনার নতুন সংস্করণ আমাকে আরও নতুন (এবং আরও ছোট) জন্য অনুপ্রাণিত করেছে।

— হাওয়ার্ড

ধন্যবাদ! আপনার নতুন সমাধানটি সত্যিই দুর্দান্ত that ;)

— ভেন্টোরো

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 টি অক্ষর ছোট sh

— ডিফ্ল্ট করুন

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

— ভেন্টোরো

@ ভেন্তোর কেস-সংবেদনশীল রেইগেক্স ব্যবহার করা একটি উজ্জ্বল ধারণা! আপনার নিজের উত্তর হিসাবে এটি পোস্ট করুন; আমি এটি ব্যবহারের যোগ্য নই। :)

— ক্রিশ্চিয়ান লুপাস্কু

@ ভেন্তোরো -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

উহু, বোগো সাজানোর স্টাইল!

— beary605

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 বাইটস যদি প্রথমে পরিবর্তে সমস্ত সমাধান আউটপুট করা ঠিক থাকে। স্কোর থেকে 18 বাইট শেভ করে পেস্কি আমদানি থেকে মুক্তি পাওয়ার জন্য @ লিনকে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

Comments

এর মাধ্যমে আপনি Data.Charআমদানি থেকে মুক্তি পেতে পারেন last b==[r!!0!!0..]!!32। এছাড়াও, আপনার এতে পেরেনগুলির দরকার নেইg[x|x<-c,x/=b]

— লিন

@ লিন সুন্দর, আমি একরকম ভেবেছিলাম fromEnumএকটি আবশ্যক হবে। মজার কথা, আমি এই বন্ধনীগুলি ইতিমধ্যে একবার নিয়ে গিয়েছিলাম, তবে আমার অবশ্যই ভুল ট্যাবটি থেকে অনুলিপি করা উচিত ...

— অ্যাঙ্গস

Answer 7

গল্ফস্ক্রিপ্ট, characters 78 টি অক্ষর

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

গল্ফস্ক্রিপ্টের প্রথম সংস্করণ। এটি একটি নিষ্ঠুর শক্তি পদ্ধতিরও করে। আপনি উদাহরণটি ইনপুটটিতে অনলাইনে চলমান স্ক্রিপ্টটি দেখতে পাবেন ।

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!

এই উন্নতির বেশিরভাগ জন্য @ লিনকে ধন্যবাদ!

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প্রথমটির পরিবর্তে এলোমেলো সমাধান বেছে নেওয়ার পরেও Ḣঠিক একইভাবে কাজ করি))

— লিন

@ লিন আপনাকে অনেক ধন্যবাদ! জিপ অংশটি খুব চালাক ছিল, এবং আমি মনে করি যে আমি Ð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;}}

কমান্ড লাইন আর্গুমেন্ট হিসাবে দেশের নাম দিয়ে চালান

বিঃদ্রঃ:

• ক্রমাগত জোর জেনারেশন
• এটি যাচাইয়ের জন্য ধরে নেওয়া হয় যে দেশের নামগুলি একটি বড় হাতের সাথে শুরু হয় এবং লোয়ার ক্ষেত্রে শেষ হয়।
• ধরে নিই সেখানে একটি মাত্র উত্তর আছে
• সিতে, ধরে নেওয়া যাক যে মূলের (*) এর ** ভি অ্যারেটি লেখার যোগ্য

Comments

এটি ঠিক বৈধ কিনা তা নিশ্চিত নন, তবে আপনি যদি শুরুতে #define L(x)for(int i=x;i<n;i++)ঘোষণা iকরেন এবং না করেন তবে main1 বাইট সংরক্ষণ করুন।

— সাসাথোগগুয়া

Answer 12

জে, 69 65 60 59 54 টি অক্ষর

কিছুটা গতি থেকে দূরে।

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

এবং এখানে লিনক 5 সেন্ট সহ সি # রয়েছে

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

সি # (.নেট কোর) , 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()) : "";
}