Vous et certains copains allez au bowling. Il y a un total de N quilleurs. Cependant, il n'y a que des chaises N -1 pour s'asseoir. La solution est simple: celui qui le fait actuellement n'a pas de chaise. Puis, à la fin de leur tour, ils s'assoient sur la chaise de la personne suivante.

Prenons un exemple. Dites que vous êtes nommé A , et vos amis à quatre nom figure B , C , D et E . Chaque joueur se déplace dans l'ordre alphabétique, vous devez donc y aller en premier. Puisqu'il y a 5 joueurs, il n'y a que 4 sièges. Vos amis sont assis dans les quatre sièges dans cet ordre:

CEBD

Vous partez, et vous obtenez une grève! C'est au tour de B ensuite, alors asseyez-vous sur sa chaise. Maintenant, cela ressemble à ceci:

CEAD

B s'en va. Gutterball! Puis il se trouve dans C place de, et C va au prochain tour.

PERLE

puis C s'assoit sur la chaise de D.

BEAC

et D est assis sur la chaise d' E

BDAC

et enfin, E est assis sur votre chaise.

BDEC

Vous remarquerez que maintenant le siège de tout le monde est (pseudo) mélangé. Vous devez savoir, après X tours, qui sera assis où?

Contribution

Votre programme doit prendre deux entrées de l'utilisateur, une chaîne et un nombre. Aucune invite n'est nécessaire. La chaîne sera composée de 1 à 51 caractères alphabétiques (BZ et az) sans répétition. Cela représente l'ordre que vos amis ont choisi de s'asseoir. Il n'y aura pas de A majuscule parce que c'est vous, et vous allez toujours en premier. Le nombre sera le nombre total de tours (pas de jeux) auxquels vous et vos amis jouez. Ce nombre sera positif et de taille raisonnable (moins de 1000).

Sortie

Votre programme doit imprimer l'ordre dans lequel vos amis sont assis après X tours, et dont c'est le tour. Ainsi, par exemple, si après X tours la commande était BEDGCAHF et que c'était le tour de Z , votre programme doit imprimer exactement ceci:

BEDGCAHF
It is Z's turn.

Voici quelques exemples d'entrées et de sorties.

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.

Règles

• Tout le monde suit l'ordre alphabétique, les majuscules ayant priorité sur les minuscules.

• Il s'agit de code-golf, donc les failles standard s'appliquent et les soumissions sont notées en octets .

Pyth, 37 octets

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

Démonstration en ligne: compilateur / exécuteur Pyth

L'algorithme est un peu basé sur la solution de @ isaacg. Comme lui, je commence par l'ordre initial des sièges et j'utilise à plusieurs reprises la fonctionnalité de Xremplacement de pour remplacer le joueur suivant par le joueur actuel.

Mais contrairement à son implémentation, qui remplace le caractère du joueur suivant par le joueur actuel dans l'ordre des places assises, je l'utilise de manière plus large. Je remplace chaque personnage du joueur actuel par le joueur suivant et chaque personnage du joueur suivant par le joueur actuel. Ceci est accompli en passant les deux joueurs comme deuxième argument et en omettant le troisième argument ( XG"ab")au lieu de XG"a""b"). Étant donné que le joueur actuel ne fait pas partie de la chaîne (il joue), le premier remplacement n'a aucun effet. Mais cela me permet de générer les deux joueurs en même temps, tandis que @isaacg doit les générer individuellement.

Une autre nouvelle fonctionnalité folle que j'utilise est l'opérateur d'affectation. Jusqu'à récemment, il a =N1été traduit en N = 1, qui a été exécuté avec Python. Mais de nos jours, il se compile pour assign('N',1). Cette fonction assigne Navec 1 et renvoie la valeur (mais ne l'imprime pas). Cela permet d'enregistrer des résultats intermédiaires, qui se produisent par exemple lors d'une opération de réduction. Grâce à cela, j'ai pu stocker la paire de joueurs, qui a changé de position en dernier, et imprimer le deuxième joueur.

Explication détaillée

                      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 octets

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

Ceci est basé autour des applications répétées de la recherche et de remplacement fonctionnement, X. Le premier bit définit une fonction de recherche y, qui trouve le be joueur dans l'ordre des joueurs. Ensuite, nous effectuons à plusieurs reprises des substitutions pour trouver l'ordre final des places assises et enfin imprimer à qui appartient le tour.

De manière amusante, le code pour trouver l'ordre final des places assises est plus court (18 octets) que le code pour imprimer à qui il appartient (21 octets).

Le code prend la chaîne assise sur la première ligne de STDIN et le nombre de tours sur la seconde.

Manifestation.

Explication:

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 octets

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

Je pense que cela fonctionne. Il exécute simplement l'algorithme tel quel.

Essayez-le en ligne.

Explication

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)

Une version optimisée de la solutionreplace de Sp3000 utilisant . La listeS parcourt les lettres dans l'ordre. Nous effectuons des remplacements répétés dans la chaîne donnée de chaque caractère de Spar le précédent.

Extrait 10 , 59 56 octets

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

Exemple

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

Explication

La première entrée est la liste des joueurs, assignée à la variable x .

La deuxième entrée est le nombre de tours avec lequel le programme obtient 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           -.

Merci à Sp3000 pour l'idée d'utiliser "replace".

Python 3, 128 octets

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

Prend deux lignes d'entrée via STDIN - ordre de placement initial puis nombre de tours.

Il s'agit essentiellement de la même idée de recherche et remplacement que ma solution CJam . La seule partie délicate est que nous restons Aà l' arrière de l'ordre de bowling et faisons de notre index il'index du prochain joueur, profitant ainsi de l'indexation par -1 et évitantIndexError s.

C'est quelques octets plus court en Python 2, mais je poste Python 3 pour comparaison avec la solution OP.

JavaScript (ES6) 116

116 octets en tant que programme avec E / S via une fenêtre contextuelle. 114 comme fonction testable.

Exécutez l'extrait de code dans Firefox pour tester.

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

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

J'ai décidé que toutes mes réponses sur ce site seront dans PowerShell. Un jour, j'aurai une réponse qui pourra rivaliser ...

appeler la fonction comme ceci: x Bb 2

Cette réponse ne va pas gagner, mais je vais la jeter quand même.

Python 3, 167 octets

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

Pépin , 54 octets

Pas très compétitif, mais au moins je peux montrer les chaînes mutables de Pip et la commande Swap. Prend l'ordre des sièges et le nombre de tours comme arguments de ligne de commande (qui sont respectivement attribués à aet b).

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

Explication:

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)

Il aurait été de 49 si j'avais pris la peine d'implémenter SS(trier en tant que chaînes) en même temps que je l'ai fait SN(trier en numérique) ... Eh bien, les dangers d'avoir un langage en développement.

Python 2 , 105 octets

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

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Contribution

Ordre des places, suivi du nombre de tours sans espaces:

SEatingOrder###