Sie und einige Freunde gehen bowlen. Es gibt insgesamt N Bowler. Es gibt jedoch nur N- 1-Stühle. Die Lösung ist einfach: Wer gerade an der Reihe ist, bekommt keinen Stuhl. Dann, wenn sie an der Reihe sind, sitzen sie auf dem Stuhl der Person, die als nächstes geht.

Nehmen wir ein Beispiel. Sagen Sie den Namen A und Ihre vier Freunde sind benannt B , C , D und E . Jeder Spieler bewegt sich in alphabetischer Reihenfolge, so dass Sie zuerst gehen können. Da es 5 Spieler gibt, gibt es nur 4 Sitze. Deine Freunde sitzen auf den vier Plätzen in dieser Reihenfolge:

CEBD

Du gehst und du bekommst einen Streik! Als nächstes ist B an der Reihe, und Sie setzen sich auf seinen Stuhl. Nun sieht es so aus:

CEAD

B geht. Gutterball! Dann setzt er sich in C ‚s Stelle und C geht nächsten Zug.

KORN

dann C sitzt in der D ‚s Stuhl.

BEAC

und D sitzt in Es Stuhl

BDAC

und zuletzt sitzt E auf deinem Stuhl.

BDEC

Sie werden feststellen, dass jetzt alle Sitzplätze (pseudo) gemischt sind. Sie müssen herausfinden , wer nach X Kurven wo sitzen wird?

Eingang

Ihr Programm muss zwei Eingaben vom Benutzer annehmen, eine Zeichenfolge und eine Zahl. Es sind keine Eingabeaufforderungen erforderlich. Die Zeichenfolge besteht aus 1 bis 51 alphabetischen Zeichen (BZ und az) ohne Wiederholungen. Dies ist die Reihenfolge, in der Ihre Freunde sitzen. Es wird kein A in Großbuchstaben geben, denn das bist du und du gehst immer zuerst. Die Anzahl ist die Gesamtanzahl der Runden (keine Spiele), die Sie und Ihre Freunde spielen. Diese Zahl ist positiv und hat eine angemessene Größe (weniger als 1000).

Ausgabe

Ihr Programm muss die Reihenfolge ausdrucken, in der Ihre Freunde nach X Runden sitzen und wer an der Reihe ist. Wenn also zum Beispiel nach X Runden die Reihenfolge BEDGCAHF war und Z an der Reihe war, muss Ihr Programm genau dies ausgeben :

BEDGCAHF
It is Z's turn.

Hier einige Beispiele für Ein- und Ausgänge.

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.

Regeln

• Jeder geht in alphabetischer Reihenfolge vor, wobei Großbuchstaben Vorrang vor Kleinbuchstaben haben.

• Dies ist Code-Golf, daher gelten Standard-Regelungslücken, und Einsendungen werden in Bytes gewertet .

Pyth, 37 Bytes

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

Online-Demonstration: Pyth-Compiler / -Executor

Der Algorithmus basiert auf der @ isaacg-Lösung. Wie er beginne ich mit der anfänglichen Sitzreihenfolge und benutze wiederholt die Ersetzungsfunktion von X, um den nächsten Spieler durch den aktuellen Spieler zu ersetzen.

Aber im Gegensatz zu seiner Implementierung, die das Zeichen des nächsten Spielers durch das Zeichen des aktuellen Spielers in der Sitzordnung ersetzt, verwende ich es umfassender. Ich ersetze jedes Zeichen des aktuellen Spielers durch das nächste Zeichen und jedes Zeichen des nächsten Spielers durch das aktuelle Zeichen. Dies wird erreicht, indem beide Spieler als zweites Argument übergeben und das dritte Argument ( XG"ab")anstelle von XG"a""b") weggelassen werden . Da der aktuelle Spieler nicht Teil der Saite ist (er spielt), hat der erste Ersatz überhaupt keine Wirkung. Aber es erlaubt mir, beide Spieler gleichzeitig zu generieren, während @isaacg sie einzeln generieren muss.

Eine andere verrückte neue Funktion, die ich benutze, ist der Zuweisungsoperator. Bis vor kurzem =N1wurde übersetzt N = 1, was mit Python ausgeführt wurde. Aber heutzutage kompiliert es zu assign('N',1). Diese Funktion weist N1 zu und gibt den Wert zurück (druckt ihn aber nicht aus). Dies ermöglicht das Speichern von Zwischenergebnissen, die beispielsweise bei einer Reduktionsoperation auftreten. Auf diese Weise konnte ich das zuletzt geänderte Spielerpaar speichern und den zweiten Spieler drucken.

Ausführliche Erklärung

                      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.

Dies basiert auf wiederholten Anwendungen der Such- und Ersetzungsoperation X. Das erste Bit definiert eine Suchfunktion y, die den bSpieler in der Reihenfolge findet , in der er spielt. Dann führen wir wiederholt Ersetzungen durch, um die endgültige Sitzordnung zu ermitteln, und drucken schließlich aus, wer an der Reihe ist.

Amüsanterweise ist der Code zum Auffinden der endgültigen Sitzordnung kürzer (18 Byte) als der zu druckende Code, der an der Reihe ist (21 Byte).

Der Code nimmt die Sitzfolge in der ersten Zeile von STDIN und die Anzahl der Umdrehungen in der zweiten Zeile.

Demonstration.

Erläuterung:

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

Ich denke das funktioniert. Der Algorithmus wird so ausgeführt, wie er ist.

Probieren Sie es online aus.

Erläuterung

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)

Eine optimierte Version der Sp3000-Lösung mitreplace . Die Liste Sdurchläuft die Buchstaben der Reihe nach. Wir führen wiederholte Ersetzungen in der angegebenen Zeichenfolge jedes Zeichens Sdurch die vorherige Zeichenfolge durch.

Clip 10 , 59 56 Bytes

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

Beispiel

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

Erläuterung

Die erste Eingabe ist die Liste der Spieler, die der Variablen zugewiesen sind x.

Die zweite Eingabe ist die Anzahl der Umdrehungen, die das Programm erhält 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           -.

Vielen Dank an Sp3000 für die Idee, "replace" zu verwenden.

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

Nimmt zwei Eingabezeilen über STDIN auf - anfängliche Sitzreihenfolge, dann Anzahl der Umdrehungen.

Dies ist im Grunde die gleiche Idee zum Suchen und Ersetzen wie bei meiner CJam-Lösung . Der einzige schwierige Teil ist , dass wir halten Aan der Rückseite der Bowling Ordnung und machen unseren Index ides Index des nächsten Bowler, also Vorteil der Indexierung Einnahme von -1 und der Vermeidung von IndexErrors.

Dies ist in Python 2 ein paar Bytes kürzer, aber ich veröffentliche Python 3 zum Vergleich mit der OP-Lösung.

JavaScript (ES6) 116

116 Bytes als Programm mit E / A über Popup-Fenster. 114 als testbare Funktion.

Führen Sie zum Testen das Code-Snippet in Firefox aus.

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

Ich habe beschlossen, dass alle meine Antworten auf dieser Website in PowerShell erfolgen. Eines Tages werde ich eine Antwort haben, die mithalten kann ...

Rufen Sie die Funktion folgendermaßen auf: x Bb 2

Diese Antwort wird nicht gewinnen, aber ich werfe sie trotzdem raus.

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

Nicht sehr wettbewerbsfähig, aber zumindest kann ich Pips veränderbare Saiten und den Swap-Befehl vorführen. Nimmt die Sitz Reihenfolge und die Anzahl von Runden als Befehlszeilenargumente (die zugewiesen zu bekommen aund b, jeweils).

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

Erläuterung:

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)

Es wäre 49 gewesen, wenn ich mich die Mühe gemacht hätte, zur SSgleichen Zeit wie ich zu implementieren (als Zeichenketten zu SNsortieren) (numerische Sortierung) ... Nun, die Gefahren, eine Sprache in der Entwicklung zu haben.

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

Probieren Sie es online!

Golf von:

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

Probieren Sie es online!

Eingang

Sitzreihenfolge, gefolgt von der Anzahl der Runden ohne Leerzeichen:

SEatingOrder###