Você e alguns amigos vão jogar boliche. Há um total de N jogadores. No entanto, existem apenas cadeiras N -1 para sentar. A solução é simples: quem quer que seja a vez atualmente não recebe uma cadeira. Então, quando termina sua vez, eles se sentam na cadeira da pessoa que segue em seguida.

Vamos dar um exemplo. Digamos que você é chamado A , e seus quatro amigos são nomeados B , C , D , e E . Todo jogador se move em ordem alfabética, então você começa primeiro. Uma vez que existem 5 jogadores, existem apenas 4 lugares. Seus amigos estão sentados nos quatro assentos nesta ordem:

CEBD

Você vai, e sim você recebe uma greve! É a vez de B a seguir, então você se senta na cadeira dele. Agora fica assim:

CEAD

B vai. Gutterball! Então ele se senta no lugar de C , e C vai no próximo turno.

BEAD

então C se senta na cadeira de D.

BEAC

e D senta na cadeira de E

BDAC

e por último, E senta na sua cadeira.

BDEC

Você notará que agora o assento de todo mundo está (pseudo) embaralhado. Você deve descobrir, depois de X rodar, quem estará sentado onde?

Entrada

Seu programa deve receber duas entradas do usuário, uma sequência e um número. Não são necessários avisos. A sequência terá de 1 a 51 caracteres alfabéticos (BZ e az) sem repetições. Isso representa a ordem em que seus amigos escolheram sentar. Não haverá A maiúsculo porque esse é você, e você sempre vai primeiro. O número será o número total de rodadas (não jogos) que você e seus amigos jogam. Esse número será positivo e de tamanho razoável (menor que 1000).

Saída

Seu programa deve imprimir a ordem em que seus amigos estão depois de X turnos e de quem é a vez. Por exemplo, se depois de X girar a ordem for BEDGCAHF e a vez de Z , seu programa deverá imprimir exatamente isso:

BEDGCAHF
It is Z's turn.

Aqui estão algumas amostras de entradas e saídas.

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.

Regras

• Todo mundo vai em ordem alfabética, com letras maiúsculas tendo precedência sobre letras minúsculas.

• Isso é código-golfe, então as brechas padrão se aplicam e as submissões são pontuadas em bytes .

Pitão, 37 bytes

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

Demonstração Online: Pyth Compiler / Executor

O algoritmo é baseado na solução do @ isaacg. Como ele, começo com a ordem de assento inicial e uso repetidamente a funcionalidade de Xsubstituição de para substituir o próximo jogador pelo atual.

Mas, diferentemente de sua implementação, que substitui o caractere do próximo jogador pelo atual na ordem de classificação, eu o uso de uma maneira mais ampla. Substituo cada caractere do jogador atual pelo próximo jogador e cada caractere do próximo jogador pelo atual. Isso é feito passando os dois jogadores como segundo argumento e omitindo o terceiro argumento (em XG"ab")vez de XG"a""b"). Como o jogador atual não faz parte da corda (ele está tocando), a primeira substituição não tem efeito algum. Mas isso me permite gerar os dois jogadores ao mesmo tempo, enquanto o @isaacg precisa gerá-los individualmente.

Outro recurso novo e louco que eu uso é o operador de atribuição. Até recentemente, =N1foi traduzido para N = 1, que foi executado com Python. Mas hoje em dia ele compila assign('N',1). Esta função atribui Ncom 1 e retorna o valor (mas não o imprime). Isso permite salvar resultados intermediários, que ocorrem, por exemplo, em uma operação de redução. Com isso, pude armazenar o par de jogadores, que trocaram de posição por último, e imprimir o segundo jogador.

Explicação detalhada

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

Pitão, 39 38 bytes

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

Isso se baseia em aplicações repetidas da operação de localização e substituição X. O primeiro bit define uma função de pesquisa y, que encontra o bth player na ordem do player. Em seguida, executamos repetidamente substituições para encontrar a ordem de assentamento final e, finalmente, imprimimos de quem é a vez.

Divertidamente, o código para encontrar a ordem de assentamento final é mais curto (18 bytes) do que o código para imprimir de quem é a vez (21 bytes).

O código pega a sequência de assentos na primeira linha do STDIN e o número de voltas na segunda.

Demonstração.

Explicação:

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

Eu acho que isso funciona. Apenas executa o algoritmo como está.

Experimente online.

Explicação

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)

Uma versão otimizada da solução do Sp3000 usandoreplace . A lista Scircula pelas letras presentes em ordem. Realizamos substituições repetidas na sequência especificada de cada caractere Spelo anterior.

Clipe 10 , 59 56 bytes

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

Exemplo

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

Explicação

A primeira entrada é a lista de jogadores, atribuídos à variável x.

A segunda entrada é o número de voltas que o programa obtém 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           -.

Agradecemos ao Sp3000 pela ideia de usar "substituir".

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 duas linhas de entrada via STDIN - ordem de assentos inicial e número de voltas.

Essa é basicamente a mesma ideia de pesquisar e substituir que minha solução CJam . A única parte complicada é que ficamos Ana parte de trás da ordem do boliche e tornamos nosso índice io índice do próximo jogador, aproveitando a indexação por -1 e evitando IndexErrors.

Estes são alguns bytes mais curtos no Python 2, mas estou postando o Python 3 para comparação com a solução do OP.

JavaScript (ES6) 116

116 bytes como programa com E / S via janela pop-up. 114 como uma função testável.

Execute o snippet de código no Firefox para testar.

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

Decidi que todas as minhas respostas neste site estarão no PowerShell. Um dia terei uma resposta que pode competir ...

chame a função assim: x Bb 2

Essa resposta não vai ganhar, mas eu a jogo de qualquer maneira.

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

Não é muito competitivo, mas pelo menos eu consigo mostrar as cordas mutáveis ​​de Pip e o comando Swap. Toma a ordem dos assentos e o número de rodadas como argumentos da linha de comando (que são atribuídos a ae b, respectivamente).

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

Explicação:

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)

Teria sido 49 se eu me desse ao trabalho de implementar SS(classificar como strings) ao mesmo tempo que o fiz SN(classificar numérico) ... Ah, bem, os perigos de ter uma linguagem em desenvolvimento.

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

Experimente online!

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

Experimente online!

Entrada

Ordem de lugares, seguida do número de voltas sem espaços:

SEatingOrder###