您和一些伙伴正在打保龄球。总共有N个保龄球。但是，只有N -1个椅子可坐。解决方案很简单：现在轮到谁都没有椅子。然后，当他们的转弯结束时，他们坐在下一个人的椅子上。

让我们举个例子。说你是叫一个，你的四个朋友被命名为乙，Ç，d，和ē。每个玩家都按字母顺序移动，因此您必须先走。由于有5位玩家，因此只有4个席位。您的朋友按以下顺序坐在四个座位中：

中央商务区

你走了，是的，你罢工了！它的乙轮到下一个，让你在他坐在椅子上。现在看起来像这样：

中国教育发展学会

B去。天沟！然后他坐在C的位置，然后C转到下一弯。

珠子

然后C坐在D的椅子上。

BEAC

和d坐在ë的椅子

数模转换器

最后，E坐在您的椅子上。

BDEC

您会注意到，现在每个人的座位都被伪装了。您必须找出X转弯之后，谁会坐在哪里？

输入项

您的程序必须接受用户的两个输入，即字符串和数字。无需提示。该字符串将是1-51个字母字符（BZ和az），且没有重复。这代表您的朋友选择坐的顺序。不会有大写字母A，因为那是您，并且您始终优先。该数字将是您和您的朋友玩的回合总数（不是游戏）。该数字应为正数，大小应合理（小于1000）。

输出量

您的程序必须打印出X圈后您的朋友坐在的顺序，以及该轮到谁。因此，例如，如果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.

规则

• 每个人都按字母顺序排列，大写字母优先于小写字母。

• 这是代码高尔夫球，因此存在标准漏洞，并且提交内容以字节为单位。

Pyth，37个字节

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

在线演示：Pyth编译器/执行器

该算法有点基于@isaacg的解决方案。像他一样，我从最初的座位顺序开始，并反复使用的替换功能X将下一个玩家替换为当前玩家。

但是与他的执行方式不同（我按照座位顺序将当前玩家替换为下一位玩家的字符），我以更广泛的方式使用它。我用下一个玩家替换当前玩家的每个字符，并用当前玩家替换下一个玩家的每个字符。这可以通过将两个玩家同时作为第二个arg并省略第三个arg（XG"ab")而不是XG"a""b"）来实现。由于当前播放器不是字符串的一部分（他正在播放），因此第一个替换项根本不起作用。但是它允许我同时生成两个玩家，而@isaacg必须分别生成它们。

我使用的另一个疯狂的新功能是赋值运算符。直到最近=N1才翻译成N = 1，并使用Python执行。但是如今，它可以编译为assign('N',1)。该函数N用1 赋值并返回值（但不打印）。这允许保存中间结果，该中间结果例如发生在归约运算中。使用此程序，我可以存储最后更改位置的那对播放器，并打印第二个播放器。

详细说明

                      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字节

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

这基于查找和替换操作的重复应用X。第一位定义了一个查找功能，y该功能b按播放器顺序查找第一个播放器。然后，我们反复进行替换以找到最终的座位顺序，最后打印出轮到谁。

有趣的是，找到最终座位顺序的代码（18字节）比要打印的轮到的代码（21字节）短。

该代码在STDIN的第一行采用座位字符串，第二行采用匝数。

示范。

说明：

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字节

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

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)

使用的Sp3000解决方案replace的优化版本。列表S按字母顺序循环显示。我们在给定的每个字符字符串中S用上一个重复替换。

夹子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使用“替换”的想法。

Python 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接受两行输入-初始座位顺序，然后是匝数。

这与我的CJam解决方案基本上是相同的搜索和替换想法。唯一棘手的部分是，我们坚持A在后面的保龄球秩序，使我们的指数i的指数下一个投球手，从而利用索引-1和避免IndexError秒。

在Python 2中这要短几个字节，但是我将发布Python 3以与OP解决方案进行比较。

JavaScript（ES6）116

通过弹出窗口使用I / O进行程序编程时为116字节。114作为可测试的功能。

在Firefox中运行代码段进行测试。

// 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个字节

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

我已经决定在此站点上所有答案都将在PowerShell中使用。有一天我会得到一个可以竞争的答案...

像这样调用函数： x Bb 2

这个答案不会赢，但我还是会把它扔出去。

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

点，54字节

竞争性不是很好，但是至少我可以炫耀Pip的可变字符串和Swap命令。将座位顺序和回合数量作为命令行参数（分别分配给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岁。嗯，开发语言的危险。

Python 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

Perl 5，102 +1（-n）= 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###