Tu e alcuni amici andate a bowling. Ci sono un totale di N giocatori. Tuttavia, ci sono solo sedie N -1 in cui sedersi. La soluzione è semplice: chiunque la giri al momento non ha una sedia. Quindi quando il loro turno è finito, si siedono sulla sedia della persona che va dopo.

Facciamo un esempio. Dici di essere nominato A , ei tuoi quattro amici si chiamano B , C , D , ed E . Ogni giocatore si muove in ordine alfabetico, quindi devi iniziare per primo. Dato che ci sono 5 giocatori, ci sono solo 4 posti. I tuoi amici si siedono nei quattro posti in questo ordine:

CEBD

Vai e fai uno sciopero! È il turno di B , quindi ti siedi sulla sua sedia. Ora sembra così:

CEAD

B va. Gutterball! Poi si siede in C posto s', e C va turno successivo.

BEAD

poi C si siede sulla sedia di D.

BEAC

e D si siede sulla sedia di E.

BDAC

e, infine, E si siede sulla tua sedia.

BDEC

Noterai che ora il posto di tutti è (pseudo) mescolato. Devi scoprire, dopo X giri, chi sarà seduto dove?

Ingresso

Il tuo programma deve ricevere due input dall'utente, una stringa e un numero. Non sono necessari prompt. La stringa avrà 1-51 caratteri alfabetici (BZ e az) senza ripetizioni. Questo rappresenta l'ordine in cui i tuoi amici hanno scelto di sedersi. Non ci sarà A maiuscola perché sei tu, e vai sempre per primo. Il numero sarà il numero totale di round (non i giochi) a cui tu e i tuoi amici giocate. Questo numero sarà positivo e di dimensioni ragionevoli (meno di 1000).

Produzione

Il tuo programma deve stampare l'ordine in cui si trovano i tuoi amici dopo X turni e di chi è il turno. Quindi, ad esempio, se dopo X giri l'ordine era BEDGCAHF ed era il turno Z , il tuo programma deve stampare esattamente questo:

BEDGCAHF
It is Z's turn.

Ecco alcuni esempi di input e output.

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.

Regole

• Tutti vanno in ordine alfabetico, con le lettere maiuscole che hanno la precedenza su lettere minuscole.

• Si tratta di code-golf, quindi si applicano scappatoie standard e gli invii vengono calcolati in byte .

Pyth, 37 byte

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

Dimostrazione online: compilatore / esecutore Pyth

L'algoritmo è in qualche modo basato sulla soluzione di @ isaacg. Come lui, comincio con l'ordine dei posti iniziale e uso ripetutamente la funzionalità di Xsostituzione di per sostituire il giocatore successivo con quello attuale.

Ma a differenza della sua implementazione, che sostituisce il personaggio del giocatore successivo con il giocatore attuale nell'ordine dei posti, lo uso in un modo più ampio. Sostituisco ogni personaggio del giocatore attuale con il giocatore successivo e ogni personaggio del giocatore successivo con il giocatore attuale. Ciò si ottiene passando entrambi i giocatori come secondo argomento e omettendo il terzo argomento ( XG"ab")anziché XG"a""b"). Poiché il giocatore attuale non fa parte della corda (sta giocando), la prima sostituzione non ha alcun effetto. Ma mi permette di generare entrambi i giocatori contemporaneamente, mentre @isaacg deve generarli singolarmente.

Un'altra nuova pazza funzionalità che utilizzo è l'operatore di assegnazione. Fino a poco tempo fa è =N1stato tradotto in N = 1, che è stato eseguito con Python. Ma al giorno d'oggi si compila assign('N',1). Questa funzione assegna Ncon 1 e restituisce il valore (ma non lo stampa). Ciò consente di salvare risultati intermedi, che si verificano ad esempio in un'operazione di riduzione. Usando questo sono stato in grado di memorizzare la coppia di giocatori, che ha cambiato posizione per ultimo, e stampare il secondo giocatore.

Spiegazione dettagliata

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

Pyth, 39 38 byte

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

Questo si basa su ripete applicazioni della ricerca e sostituzione di funzionamento, X. Il primo bit definisce una funzione di ricerca y, che trova bil giocatore nell'ordine del giocatore. Quindi, eseguiamo ripetutamente sostituzioni per trovare l'ordine dei posti finale e infine stampare di chi è il turno.

In modo divertente, il codice per trovare l'ordine dei posti finale è più breve (18 byte) rispetto al codice da stampare di cui è il turno (21 byte).

Il codice prende la stringa di posti sulla prima riga di STDIN e il numero di giri sulla seconda.

Dimostrazione.

Spiegazione:

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.

CJam, 49 45 43 byte

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

Penso che funzioni. Esegue semplicemente l'algoritmo così com'è.

Provalo online.

Spiegazione

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

Python 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)

Una versione ottimizzata della soluzione Sp3000 utilizzandoreplace . L'elenco Sscorre ciclicamente le lettere presenti in ordine. Eseguiamo ripetute sostituzioni nella stringa data di ciascun carattere di Squella precedente.

Clip 10 , 59 56 byte

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

Esempio

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

Spiegazione

Il primo input è l'elenco dei giocatori, assegnato alla variabile x.

Il secondo input è il numero di turni con cui il programma ottiene 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           -.

Grazie a Sp3000 per l'idea di usare "sostituisci".

Python 3, 128 byte

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

Accetta due righe di input tramite STDIN: l'ordine iniziale dei posti a sedere, quindi il numero di giri.

Questa è sostanzialmente la stessa idea di ricerca e sostituzione della mia soluzione CJam . L'unica parte difficile è che restiamo Asul retro dell'ordine di bowling e rendiamo il nostro indice il'indice del prossimo bowler, sfruttando così l'indicizzazione di -1 ed evitandoIndexError s.

Questo è un po 'più corto di Python 2, ma sto postando Python 3 per il confronto con la soluzione di OP.

JavaScript (ES6) 116

116 byte come programma con I / O tramite finestra popup. 114 come funzione testabile.

Esegui lo snippet di codice in Firefox per testare.

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

PowerShell, 168 byte

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

Ho deciso che tutte le mie risposte su questo sito saranno in PowerShell. Un giorno avrò una risposta che può competere ...

chiama la funzione in questo modo: x Bb 2

Questa risposta non vincerà, ma la proverò comunque.

Python 3, 167 byte

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.")

Pip , 54 byte

Non molto competitivo, ma almeno riesco a mostrare le stringhe mutabili di Pip e il comando Swap. Accetta l'ordine dei posti a sedere e il numero di round come argomenti della riga di comando (che vengono assegnati rispettivamente a ae b).

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

Spiegazione:

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)

Sarebbe stato 49 se mi fossi preso la briga di implementare SS(ordinamento come stringhe) allo stesso tempo SN(ordinamento numerico) ... Ah bene, i pericoli di avere un linguaggio in sviluppo.

Python 2 , 105 byte

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

Provalo online!

Golf di:

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

Perl 5 , 102 + 1 (-n) = 103 byte

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

Provalo online!

Ingresso

Ordine dei posti, seguito dal numero di giri senza spazi:

SEatingOrder###