आपके दोस्त कहाँ बैठेंगे?

Question

आप और कुछ दोस्त गेंदबाजी कर रहे हैं। कुल एन गेंदबाज हैं। हालांकि, इसमें बैठने के लिए केवल एन -1 कुर्सियां ​​हैं। समाधान सरल है: जो कोई भी इसे चालू करता है उसे कुर्सी नहीं मिलती है। फिर जब उनकी बारी आती है, तो वे उस व्यक्ति की कुर्सी पर बैठते हैं जो आगे जाता है।

एक उदाहरण लेते हैं। Say You का नाम A है , और आपके चार दोस्तों का नाम B , C , D , और E है । हर खिलाड़ी वर्णमाला क्रम में चलता है, इसलिए आपको पहले जाना होगा। चूंकि 5 खिलाड़ी हैं, केवल 4 सीटें हैं। आपके मित्र इस क्रम में चार सीटों पर बैठते हैं:

CEBD

तुम जाओ, और तुम एक हड़ताल हो जाओ! यह B का अगला मोड़ है, इसलिए आप उसकी कुर्सी पर बैठें। अब यह इस तरह दिखता है:

Céad

B चला जाता है। Gutterball! फिर वह C के स्थान पर बैठता है , और C अगले मोड़ पर जाता है।

मनका

तब C , D की कुर्सी पर बैठता है ।

BEAC

और D , E की कुर्सी पर बैठता है

BDAC

और अंत में, ई आपकी कुर्सी पर बैठता है।

BDEC

आप देखेंगे कि अब सभी की सीट (छद्म) फेरबदल हो गई है। आपको पता लगाना चाहिए कि एक्स के मुड़ने के बाद , कौन कहां बैठा होगा?

इनपुट

आपके प्रोग्राम को उपयोगकर्ता से दो इनपुट लेने चाहिए, एक स्ट्रिंग और एक संख्या। कोई प्रॉम्प्ट की जरूरत नहीं है। स्ट्रिंग 1-51 वर्णनात्मक वर्ण (BZ और az) होगा जिसमें कोई दोहराव नहीं होगा। यह आपके मित्रों द्वारा बैठने के लिए चुने गए आदेश का प्रतिनिधित्व करता है। कोई अपरकेस होगा एक वजह यह है कि आप है, और आप हमेशा पहले जाओ। संख्या राउंड की कुल संख्या होगी (गेम नहीं) जो आप और आपके दोस्त खेलते हैं। यह संख्या सकारात्मक और यथोचित आकार (1000 से कम) होगी।

उत्पादन

आपके प्रोग्राम को एक्स टर्न के बाद आपके दोस्तों के बैठने के क्रम को प्रिंट करना होगा और यह किसकी बारी है। उदाहरण के लिए, यदि X चालू होने के बाद आदेश BEDGCAHF था और यह Z की बारी थी, तो आपके कार्यक्रम को यह अवश्य छापना चाहिए:

BEDGCAHF
It is Z's turn.

यहाँ कुछ नमूना इनपुट और आउटपुट दिए गए हैं।

input: E, 4 
E
It is A's turn.

input: E, 5 
A
It is E's turn.

input: Bb, 2
AB
It is b's turn.

input: dgOPZXKDQYioHflFhpqzUsSaeILwckVNEtGTCJBvnruRyWMmjxb, 999
JNuvFDqjwEPVnMSlOWXgAZyGKordIRBtkamziphcUYbxfCsTQeH
It is L's turn.

नियम

• हर कोई वर्णमाला के क्रम में जाता है, जिसमें बड़े अक्षरों में कम मामले पर वरीयता होती है।

• यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और बाइट्स में सबमिशन स्कोर किया जाता है ।

Comments

मैंने ब्रेनफ्लक के लिए इस पर काम करने में घंटों बिताए हैं। मैंने सिर्फ देखा कि मैं इसे गलत कर रहा था।

— क्रिस्टोफर

{({}[()])({}<({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>>)}

— क्रिस्टोफर

यह इसे फेरबदल करता है और स्टैक पर पहला आइटम उत्तर है।

— क्रिस्टोफर

आपके लिए यह आश्चर्य की बात थी: P

— क्रिस्टोफर

Answer 1

पायथ, 37 बाइट्स

uXGK<.<+\ASzH2)QzpeK"It is ""'s turn.

ऑनलाइन प्रदर्शन: पायथ कंपाइलर / एक्ज़िक्यूटर

एल्गोरिथ्म थो @ @ आईएएसएसीजी के समाधान पर आधारित है। उसकी तरह मैं शुरुआती सीट-क्रम से शुरू करता हूं और बार-बार Xमौजूदा खिलाड़ी के साथ अगले खिलाड़ी को बदलने की कार्यक्षमता का उपयोग करता हूं ।

लेकिन उनके कार्यान्वयन के विपरीत, जो सीटिंग क्रम में वर्तमान खिलाड़ी द्वारा अगले खिलाड़ी के चार्ट को बदल देता है, मैं इसे और अधिक व्यापक तरीके से उपयोग करता हूं। मैं वर्तमान खिलाड़ी के प्रत्येक खिलाड़ी को अगले खिलाड़ी द्वारा और अगले खिलाड़ी को प्रत्येक खिलाड़ी को वर्तमान खिलाड़ी द्वारा बदल देता हूं। यह दोनों खिलाड़ियों को दूसरे arg के रूप में उत्तीर्ण करता है और तीसरे arg (के XG"ab")बजाय XG"a""b") को छोड़ देता है। चूंकि वर्तमान खिलाड़ी स्ट्रिंग का हिस्सा नहीं है (वह खेल रहा है), पहले प्रतिस्थापन का कोई प्रभाव नहीं है। लेकिन यह मुझे एक ही समय में दोनों खिलाड़ियों को उत्पन्न करने की अनुमति देता है, जबकि @isaacg को उन्हें व्यक्तिगत रूप से उत्पन्न करना है।

एक और पागल नई सुविधा जो मैं उपयोग करता हूं वह असाइनमेंट ऑपरेटर है। कुछ समय पहले तक इसका =N1अनुवाद किया N = 1गया था, जिसे पायथन के साथ निष्पादित किया गया था। लेकिन आजकल इसका संकलन किया जाता है assign('N',1)। यह फ़ंक्शन N1 के साथ असाइन करता है और मान देता है (लेकिन इसे प्रिंट नहीं करता है)। यह मध्यवर्ती परिणामों को बचाने की अनुमति देता है, जो कम ऑपरेशन में उदाहरण के लिए होते हैं। इसका उपयोग करके मैं खिलाड़ियों की जोड़ी को स्टोर करने में सक्षम था, जो पिछले पदों को बदल देता है, और दूसरे खिलाड़ी को प्रिंट करता है।

विस्तृत विवरण

                      implicit: z = input string, Q = input number
u              Qz     reduce for H in range(Q), start with G = z
                        update G with:
       +\ASz              "A" + sorted(z)
     .<     H             cyclic shifted by H
    <        2            get the first 2 elements (current + next player)
   K                      store the result in K
 XG           )           replace next player by current player in G
                      implicit print 

peK"It is ""'s turn.  print "It is" + K[-1] (current player) + "'s turn."

Answer 2

पायथ, 39 38 बाइट्स

L@+\ASzbuXGyhHyHQzpyQ"It is ""'s turn.

यह खोज के बार-बार किए गए अनुप्रयोगों और ऑपरेशन को बदलने के लिए आधारित है X। पहला बिट एक लुकअप फ़ंक्शन को परिभाषित करता है y, जो bखिलाड़ी क्रम में वें प्लेयर को ढूंढता है । फिर, हम अंतिम बैठने के क्रम को खोजने के लिए बारी-बारी से बारी-बारी से प्रदर्शन करते हैं, और अंत में यह पता लगा लेते हैं कि यह किसकी बारी है।

स्पष्ट रूप से, अंतिम सीटिंग ऑर्डर को खोजने के लिए कोड (18 बाइट्स) कोड की तुलना में कम है, जिसके प्रिंट की बारी है (21 बाइट्स)।

कोड एसटीडीआईएन की पहली पंक्ति पर सीटिंग स्ट्रिंग लेता है, और दूसरे पर मुड़ता है।

प्रदर्शन।

स्पष्टीकरण:

L@+\ASzbuXGyhHyHQzpyQ"It is ""'s turn.
                                          Implicit:
                                          z = input()
                                          Q = eval(input())

L                                         def y(b): return
  +\ASz                                    "A" + sorted(z)
 @     b                                  (               )[b]
        u       Qz                        reduce for H in range(len(Q)),
                                          G starts as z.
         XGyhHyH                          replace in G y(H+1) with y(H).
                  pyQ"It is ""'s turn.    Print out whose turn it is.

Comments

@ Sp3000 पकड़ने के लिए धन्यवाद।

— isaacg

कभी भी उपयोग न करें %, यदि आप केवल एक चीज डालें। यहां तक ++कि एक बाइट भी बचा सकता है, लेकिन सबसे अच्छा तरीका (2 बाइट्स) उपयोग कर रहा है p:pyQ"It is ""'s turn

— जकुबे

उफ़। आखिर में बात याद आ गई। तो के रूप ++में एक ही बाइट गिनती है %, और pकेवल 1 बाइट बचाता है।

— जकुबे

Answer 3

CJam, 49 45 43 बाइट्स

l_'A+$ri{:L2<(erL(+}*1<"
It is "\"'s turn."

मुझे लगता है कि यह काम करता है। यह सिर्फ एल्गोरिदम को चलाता है।

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

व्याख्या

l                       Read line (initial seating order)
_'A+$                   Copy, add "A" and sort to give bowling order

ri{          }*         Do <number of turns> times...
   :L                     Save bowling order as L
     2<(                  Get next and current bowlers
        er                Replace next with current in seating
          L(+             Push bowling order again and update (rotate)

1<                      Get current bowler from start of bowling order
"                  
It is "\"'s turn."      Output message

Answer 4

अजगर 3, 110

s=input()
S=sorted(s+'A')*999
exec("y,*S=S;s=s.replace(S[0],y);"*int(input()))
print(s+"\nIt is %s's turn."%y)

का उपयोग कर Sp3000 के समाधान काreplace एक अनुकूलित संस्करण । सूची Sचक्र हालांकि आदेश में मौजूद पत्र। हम Sपिछले एक द्वारा प्रत्येक वर्ण के दिए गए स्ट्रिंग में बार-बार प्रतिस्थापन करते हैं ।

Comments

अच्छी तरह से खेला, हर बार :)

— Sp3000

@ Sp3000 मैं हालांकि अपने समाधान का इस्तेमाल किया।

— xnor

Answer 5

क्लिप 10 , 59 56 बाइट्स

[t{)k[qa)qglqtg(lqt}wx)nyN"It is "gnyt"'s turn.."`]s,x'A

उदाहरण

[t{)k[qa)qglqtg(lqt}wx)nyN"It is "gnyt"'s turn.."`]s,x'A
dgOPZXKDQYioHflFhpqzUsSaeILwckVNEtGTCJBvnruRyWMmjxb
999
JNuvFDqjwEPVnMSlOWXgAZyGKordIRBtkamziphcUYbxfCsTQeH
It is L's turn.

व्याख्या

पहला इनपुट खिलाड़ियों की सूची है, जो चर को सौंपा गया है x।

दूसरा इनपुट टर्न की संख्या है, जिसे प्रोग्राम प्राप्त करता है ny।

[t                                        ]s,x'A .-t is the sorted list of players including A-.
  {                                      `       .-Print the following:            -.
    k[q            }wx)ny                        .-In each round (q is all the previous rounds)-.
       a)q                                       .-Replace                         -.
          glqt                                   .-the next player                 -.
              g(lqt                              .-with the previous player        -.

                     N                           .-Also print a newline            -.
                      "It is "    "'s turn.."
                              gnyt               .-The ny'th player in t           -.

"बदलें" का उपयोग करने के विचार के लिए Sp3000 का धन्यवाद।

Answer 6

पायथन 3, 128 बाइट्स

L=input()
S=sorted(L)+["A"]
i=0
exec("L=L.replace(S[i],S[i-1]);i=-~i%len(S);"*int(input()))
print(L+"\nIt is %s's turn."%S[i-1])

STDIN के माध्यम से इनपुट की दो लाइनें लेता है - प्रारंभिक बैठने का क्रम फिर बदल जाता है।

यह मूल रूप से मेरे सीजेम समाधान के समान खोज-और-जगह विचार है । एकमात्र मुश्किल हिस्सा यह है कि हम गेंदबाजी क्रम Aमें सबसे पीछे रहते हैं और अपने सूचकांक iको अगले गेंदबाज का सूचकांक बनाते हैं , इस प्रकार -1 से सूचकांक का लाभ उठाते हैं और IndexErrorएस से बचते हैं ।

यह पायथन 2 में कुछ बाइट्स छोटा है, लेकिन मैं ओपी के समाधान के साथ तुलना के लिए पायथन 3 पोस्ट कर रहा हूं।

Comments

अजगर 2 में क्या सुधार है? मैं देखता हूं कि लाइन 1 पर इनपुट raw_input (+4) int(input())हो जाता है और लाइन 4 पर इनपुट (-4) हो जाता है ताकि कैंसिल हो जाए। फिर कोष्ठक को प्रिंट से हटा दें और कुल 127 के लिए एक स्थान जोड़ें। क्या मुझे कुछ याद आ रहा है?

— DJMcMayhem

@DJMcMayhem आप के लिए कोष्ठक भूल गएexec

— Sp3000

Answer 7

जावास्क्रिप्ट (ईएस 6) 116

पॉपअप विंडो के माध्यम से आई / ओ के साथ कार्यक्रम के रूप में 116 बाइट्स। एक परीक्षण समारोह के रूप में 114।

परीक्षण करने के लिए फ़ायरफ़ॉक्स में कोड स्निपेट चलाएँ।

// as a program with I/O
for(t=[...s=(P=prompt)()].sort(),x=P(),p='A';x--;p=n)t.push(p),s=s.replace(n=t.shift(),p);P(`${s}
It is ${p}' turn`)

// as a function with 2 parameters, returning output as a 2 lines string
f=(s,x)=>{for(t=[...s].sort(),p='A';x--;p=n)t.push(p),s=s.replace(n=t.shift(),p);return(`${s}
It is ${p}' turn`)}

// Test suite
test=[
['CEBD',5], ['E', 4],['E',5],['Bb', 2],
['dgOPZXKDQYioHflFhpqzUsSaeILwckVNEtGTCJBvnruRyWMmjxb', 999]];

Out=x=>OUT.innerHTML=OUT.innerHTML+x;

test.forEach(([p,x])=>Out(p+' '+x+':\n'+f(p,x)+'\n'))

Test cases from OP:
<pre id=OUT></pre>

Answer 8

पॉवरशेल, 168 बाइट्स

function x($s,$t){$p="A"+$s-split''|?{$_}|%{[int][char]$_}|sort|%{[char]$_};$l=$p.count;1..$t|%{$s=$s.replace($p[$_%$l],$p[($_-1)%$l])};$s;"It is $($p[$t%$l])'s turn."}

मैंने तय किया है कि इस साइट पर मेरे सभी जवाब पॉवरशेल में होंगे। एक दिन मेरे पास एक उत्तर होगा जो प्रतिस्पर्धा कर सकता है ...

फ़ंक्शन को इस तरह से कॉल करें: x Bb 2

Answer 9

यह जवाब जीतने वाला नहीं है, लेकिन मैं इसे वैसे भी बाहर फेंक दूंगा।

पायथन 3, 167 बाइट्स

s=input()
n=int(input())
c='A'
t=sorted(set(s+c))
F=len(t)
f=list(s)
for i in range(n):
 I=f.index(t[(i+1)%F]);c,f[I]=f[I],c
print(''.join(f)+'\nIt is '+c+"'s turn.")

Answer 10

पिप , 54 बाइट्स

बहुत प्रतिस्पर्धी नहीं है, लेकिन कम से कम मुझे पिप के उत्परिवर्तनीय तार और स्वैप कमांड को दिखाने के लिए मिलता है। बैठने के क्रम और राउंड की संख्या को कमांड-लाइन तर्कों के रूप में लेता है (जो क्रमशः aऔर b, सौंपे जाते हैं)।

u:'Ao:SN A^u.aLbSu(aa@?C(o++i))Pa"It is ".u."'s turn."

स्पष्टीकरण:

u:'A                   u = player who's currently up

o:SN A^u.a
      ^u.a             Append "A" to the seating order, split into list of characters
o:SN A                 ASCII value of each char, sort the resulting list, assign to o

LbSu(aa@?C(o++i))
Lb                     Repeat b times:
  Su                   Swap u with:
    (a          )      The character of a at index:
      a@?              Find in a:
         C(o++i)       chr(ASCII value of next player from o)
                       (Subscripts wrap around, as in CJam, so no need for mod)

Pa                     Print the final lineup
"It is ".u."'s turn."  Current player (auto-printed)

यदि मैं SSएक ही समय में SN(सॉर्ट न्यूमेरिक) एक ही समय में लागू करने के लिए परेशान होता, तो 49 साल का होता ।

Answer 11

पायथन 2 , 105 बाइट्स

a,s='A',input()
exec"b=a<max(s)and min(e for e in s if e>a)or'A';s=s.replace(b,a);a=b;"*input()
print s,b

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

का गोल्फ:

s=input()
n=input()
a='A'
for i in range(n):
 try:
  b=min(e for e in s if e>a)
 except:
  b='A'
 s=s.replace(b,a)
 a=b
print s
print b

Answer 12

पर्ल 5 , 102 + 1 (एन) = 103 बाइट्स

s/\d+//;$t=$&;@p=sort'A',split//;for$i(1..$t){s/$p[$i%@p]/$p[--$i%@p]/}say"$_
It is $p[$t%@p]'s turn."

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

इनपुट

बैठने का क्रम, इसके बाद बिना रिक्त स्थान की संख्या के:

SEatingOrder###