Tú y algunos amigos van a jugar bolos. Hay un total de N jugadores de bolos. Sin embargo, solo hay sillas N -1 para sentarse. La solución es simple: quienquiera que sea el turno actual no obtiene una silla. Luego, cuando termina su turno, se sientan en la silla de la persona que sigue.

Tomemos un ejemplo. Digamos que usted es nombrado A , y sus cuatro amigos nombre figura B , C , D , y E . Cada jugador se mueve en orden alfabético, por lo que debes ir primero. Como hay 5 jugadores, solo hay 4 asientos. Tus amigos se sientan en los cuatro asientos en este orden:

CEBD

¡Ve, y sí, tienes una huelga! Es el turno de B a continuación, así que te sientas en su silla. Ahora se ve así:

CEAD

B va. Gutterball! Luego se sienta en el lugar de C , y C va al siguiente turno.

TALÓN

entonces C se sienta en la silla de D.

BEAC

y D se sienta en la silla de E

BDAC

y por último, E se sienta en tu silla.

BDEC

Notarás que ahora el asiento de todos está (pseudo) barajado. Debes descubrir, después de X turnos, ¿quién estará sentado dónde?

Entrada

Su programa debe tomar dos entradas del usuario, una cadena y un número. No se necesitan indicaciones. La cadena tendrá 1-51 caracteres alfabéticos (BZ y az) sin repeticiones. Esto representa el orden en que tus amigos eligieron sentarse. No habrá A mayúscula porque ese eres tú, y tú siempre vas primero. El número será el número total de rondas (no juegos) que jueguen usted y sus amigos. Este número será positivo y de tamaño razonable (menos de 1000).

Salida

Su programa debe imprimir el orden en el que están sentados sus amigos después de X turnos, y de quién es el turno. Entonces, por ejemplo, si después de que X gira el pedido era BEDGCAHF y era el turno de Z , su programa debe imprimir exactamente esto:

BEDGCAHF
It is Z's turn.

Aquí hay algunas entradas y salidas de muestra.

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.

Reglas

• Todos van en orden alfabético, con mayúsculas que tienen prioridad sobre las minúsculas.

• Este es el código de golf, por lo que se aplican las lagunas estándar y las presentaciones se puntúan en bytes .

Pyth, 37 bytes

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

Demostración en línea: Pyth Compiler / Executor

El algoritmo se basa en la solución de @ isaacg. Al igual que él, comienzo con el orden inicial de los asientos y uso repetidamente la funcionalidad de Xreemplazo para reemplazar al siguiente jugador con el jugador actual.

Pero a diferencia de su implementación, que reemplaza el carácter del próximo jugador por el jugador actual en el orden de asientos, lo uso de una manera más amplia. Reemplazo cada personaje del jugador actual por el siguiente jugador y cada personaje del siguiente jugador por el jugador actual. Esto se logra pasando a ambos jugadores como segundo argumento y omite el tercer argumento (en XG"ab")lugar de XG"a""b"). Como el jugador actual no forma parte de la cadena (está jugando), el primer reemplazo no tiene ningún efecto. Pero me permite generar ambos jugadores al mismo tiempo, mientras que @isaacg tiene que generarlos individualmente.

Otra nueva característica loca que uso es el operador de asignación. Hasta hace poco =N1se tradujo a N = 1, que se ejecutó con Python. Pero hoy en día se compila assign('N',1). Esta función se asigna Ncon 1 y devuelve el valor (pero no lo imprime). Esto permite guardar resultados intermedios, que ocurren por ejemplo en una operación de reducción. Usando esto pude almacenar el par de jugadores, que cambiaron las posiciones al final, e imprimir el segundo jugador.

Explicación detallada

                      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 bytes

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

Esto se basa en la aplicación repetida de la operación de búsqueda y reemplazo, X. El primer bit define una función de búsqueda y, que encuentra al bjugador en el orden del jugador. Luego, repetidamente realizamos sustituciones para encontrar el orden final de asientos, y finalmente imprimimos de quién es el turno.

Divertidamente, el código para encontrar el orden de asiento final es más corto (18 bytes) que el código para imprimir de quién es el turno (21 bytes).

El código toma la cadena de asiento en la primera línea de STDIN y el número de vueltas en la segunda.

Demostración.

Explicación:

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 bytes

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

Creo que esto funciona. Simplemente ejecuta el algoritmo tal como está.

Pruébalo en línea.

Explicación

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

Pitón 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 versión optimizada de la soluciónreplace de Sp3000 usando . La lista se Sdesplaza por las letras presentes en orden. Realizamos reemplazos repetidos en la cadena dada de cada carácter de Spor el anterior.

Clip 10 , 59 56 bytes

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

Ejemplo

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

Explicación

La primera entrada es la lista de jugadores, asignada a la variable x.

La segunda entrada es el número de turnos con los que obtiene el programa 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           -.

Gracias a Sp3000 por la idea de usar "reemplazar".

Python 3, 128 bytes

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

Toma dos líneas de entrada a través de STDIN: orden de asiento inicial y luego número de vueltas.

Esta es básicamente la misma idea de buscar y reemplazar que mi solución CJam . La única parte difícil es que nos quedamos Aen la parte posterior del orden de bolos y hacemos de nuestro índice iel índice del próximo jugador de bolos, aprovechando así la indexación por -1 y evitando IndexErrors.

Esto es unos bytes más cortos en Python 2, pero estoy publicando Python 3 para compararlo con la solución de OP.

JavaScript (ES6) 116

116 bytes como programa con E / S a través de una ventana emergente. 114 como una función comprobable.

Ejecute el fragmento de código en Firefox para probar.

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

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

He decidido que todas mis respuestas en este sitio estarán en PowerShell. Algún día tendré una respuesta que pueda competir ...

llama a la función así: x Bb 2

Esta respuesta no va a ganar, pero la arrojaré de todos modos.

Python 3, 167 bytes

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 bytes

No es muy competitivo, pero al menos puedo mostrar las cadenas mutables de Pip y el comando Intercambiar. Toma el orden de asiento y el número de rondas como argumentos de línea de comandos (que se asignan a ay b, respectivamente).

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

Explicación:

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)

Hubiera sido 49 si me hubiera molestado en implementar SS(ordenar como cadenas) al mismo tiempo que lo hice SN(ordenar numérico) ... Ah, bueno, los peligros de tener un lenguaje en desarrollo.

Python 2 , 105 bytes

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

Pruébalo en línea!

Golf de:

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 bytes

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

Pruébalo en línea!

Entrada

Orden de asientos, seguido por número de vueltas sin espacios:

SEatingOrder###