Lors d'une soirée, j'ai découvert le jeu LCR. Maintenant, ce n'est pas un grand jeu car il n'y a aucune compétence mais seulement une chance aléatoire. Mais ça m'a fait réfléchir, je pouvais coder cela, et j'ai fait un programme rapide en R pour modéliser le jeu.
Règles du jeu modifiées à partir de Wikipedia pour correspondre à la façon dont nous avons joué:
Chaque joueur reçoit au moins 3 jetons. Les joueurs à leur tour lancent trois dés à six faces, chacun étant marqué d'un "L", "C", "R" d'un côté et d'un seul point des trois côtés restants. Pour chaque "L" ou "R" lancé, le joueur doit passer une puce au joueur à sa gauche ou à sa droite, respectivement. Un "C" indique une puce au centre (pot). Un point n'a aucun effet.
S'il reste moins de trois jetons à un joueur, il est toujours dans le jeu mais son nombre de jetons est le nombre de dés qu'il lance à son tour, plutôt que de lancer les trois. Lorsqu'un joueur n'a aucun jeton, il passe les dés à son tour, mais peut recevoir des jetons des autres et prendre son prochain tour en conséquence. Le gagnant est le dernier joueur à avoir placé des jetons au centre.
Concours: écrivez un programme dans la langue de votre choix qui prend en compte le nombre de joueurs et le nombre de jetons de départ et simule un jeu de LCR, montrant l'état du jeu après que chaque joueur a lancé.
Par exemple, un jeu peut être sorti en tant que:
[[[3,3,3,3],0],[[1,4,3,4],0],[[1,4,3,4],0],[[1,4,1,4],2],[[1,4,1,2],4],
[[0,4,1,3],4],[[0,3,2,3],4],[[0,3,0,3],6],[[0,3,1,1],7],[[0,3,1,1],7],
[[2,0,1,1],8],[[2,0,0,1],9],[[2,0,0,0],10],[[0,1,0,0],11],
[[1,0,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[0,0,0,0],12]]
ht: JonathanAllan
La sortie ne doit pas ressembler exactement à ceci, mais il devrait être facile de discerner le lancer de dés, le nombre de jetons que chaque joueur a et le nombre de jetons que le centre a pour chaque tour.
C'est le golf de code, donc le code le plus court gagne.
[[[3,3,3,3],0],[[1,4,3,4],0],[[1,4,3,4],0],[[1,4,1,4],2],[[1,4,1,2],4],[[0,4,1,3],4],[[0,3,2,3],4],[[0,3,0,3],6],[[0,3,1,1],7],[[0,3,1,1],7],[[2,0,1,1],8],[[2,0,0,1],9],[[2,0,0,0],10],[[0,1,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[0,0,0,0],12]]
- est-ce le cas?Réponses:
Emacs Lisp , 279 octets
Utilisez cette fonction comme
(f 4 3)
.Meilleure version lisible:
Exemple de sortie:
la source
Java 8,
281277275274253 octetsVersion qui affiche le même état lorsqu'un joueur au tour n'a plus de jetons:
Commence avec le troisième joueur du tableau.
Essayez-le en ligne.
Version qui saute les joueurs avec 0 jeton restant (274 octets):
Commence par le premier joueur du tableau.
Essayez-le en ligne.
-7 octets grâce à @ OlivierGrégoire .
Explication (de la deuxième version):
la source
s=0;for(int C:c)s+=C;
(21 octets) peut être remplacé pars=A.stream(c).sum();
(20 octets)c[i%p]-=r<3?1:0
→c[i%p]-=1-r/3
. Cela permettrait d'économiser 2 octets.A
fromjava.util.Arrays
. : D Et en le mettant dans la boucle pour économiser sur le point-virgule, c'est -2 octets. Et1-r/3
c'est en effet correct ( voir ici ). Merci.s=c[u=(i+r-1+p)%p]+=1-r&1-r/4
(économise 2 octets, par rapport às=c[u=(i+r%2*2-1+p)%p]+=r<2?1:0
)Python 2 ,
159148 octetsEssayez-le en ligne!
Imprime tous les jetons des joueurs après chaque lancer
la source
n*c - sum(players)
. Si je dois l'écrire explicitement, je le feraiGelée , 39 octets
+2 pour corriger le comportement de répétition (
¡
doit être précédé d'un nilad donc«3Ḣ$
->⁸FḢ«3
)Si nous pouvons définir les listes de sortie à faire tourner pour avoir les jetons appartenant au joueur qui a agi précédemment à gauche, nous pouvons supprimer le plus à droite 6 octets pour 33 octets (cependant, à mon avis, il est quelque peu gênant de lire cela).
Un lien dyadique acceptant les jetons par joueur à gauche et le nombre de joueurs à droite qui donne une liste de jetons comptant les joueurs au début de la partie et après chaque tour (y compris les tours où 0 jeton force une passe) .
Essayez-le en ligne!
Comment?
Chaque joueur à son tour, jusqu'à trois fois, en fonction de son nombre de jetons, lance une pièce. Lorsqu'un joueur retourne la tête , ils ne font que si elles queues à feuilles mobiles , ils roulent alors un dé à trois côtés perdre une puce à L, C ou R. (Notez que 0 flips lorsqu'un joueur a 0 jetons est équivalent à passer.)
Cette opération est répétée jusqu'à ce que la somme des jetons des joueurs soit de 0.
L'implémentation fait tourner les joueurs à gauche d'une place à chaque tour, puis fait pivoter les états résultants pour qu'ils soient tous alignés comme s'ils ne l'étaient pas.
la source
Ø.X¤?
, est imbriqué dans la répétition-up à 3 fois l' instruction,⁸«3Ḣ¤¡
.C #, 356? +13? Octets
Requiert
using System;
un total de +13 octets pour le code ci-dessous, si je suis tenu de le compter. Sinon, plonk juste dans n'importe quelle classe et appelezL(players, starting chips);
.Exemple de sortie pour un jeu 2,2:
Version moins golfée:
la source
C # (Visual C # Interactive Compiler) ,
201199 octetsEssayez-le en ligne!
la source
Fusain , 61 octets
Essayez-le en ligne! Le lien est vers la version détaillée du code. Alternance entre la sortie des dés et des jetons restants (ni le nombre initial de jetons ni le nombre de jetons au centre ne sont inclus dans la sortie). Explication:
Commencez avec le premier joueur.
Répétez jusqu'à ce qu'il ne reste plus de jetons.
Lancez jusqu'à trois dés pour le joueur actuel. Ces dés sont étiquetés 0-5, où 0-2 représente le point, 3 est passé à gauche, 4 est au centre, 5 est à droite.
Additionnez le nombre de jetons que le joueur de droite a passé à gauche et le nombre de jetons que le joueur de gauche a passé à droite, mais soustrayez le nombre de jetons que le joueur lui-même a transmis.
Passez au joueur suivant.
Sortez le nouveau nombre de jetons détenus par les joueurs.
Il est en fait plus simple pour tout le monde de lancer leurs dés simultanément, ce qui peut être fait en 50 octets, y compris l'impression des rouleaux de dés ainsi que des jetons restants:
Essayez-le en ligne! Le lien est vers la version détaillée du code.
la source
05AB1E (hérité) ,
58504952 octetsVersion qui affiche le même état quand un joueur au tour n'a plus de jetons (
504952 octets ):Essayez-le en ligne.
Version qui saute les joueurs avec 0 jeton restant (
585760 octets ):Essayez-le en ligne.
Les deux octets +3 en utilisant la version héritée, car la nouvelle version 05AB1E a un bug bizarre. Il devrait fonctionner avec
Ws\
(push minimum sans popping; swap; discard list) remplacé parß
(pop list and push minimum) et0›
(vérifier si supérieur à 0) remplacé pard
(vérifier si non négatif / supérieur ou égal à 0) dans le nouvelle version, mais pour une raison quelconque, l'ordre de la liste est modifié après la fin¼
! .. : S (et la nouvelle version est également extrêmement lente et expire après 60 secondes avant de terminer le résultat ..>.>)La première entrée est la quantité de joueurs, la deuxième entrée la quantité de jetons par joueur.
Explication (de la deuxième version):
la source
[2, 3, 3, 3]
suivie de[2, 2, 2, 6]
..: S Je vais voir si je peux trouver la cause et la corriger. Sinon, je peux toujours le supprimer et n'utiliser que l'héritage, car il sort beaucoup plus de toute façon .. La nouvelle version est assez lente avec des boucles complexes pour une raison quelconque.>.>counter_variable
.. J'ai essayé de reproduire le problème dans un exemple plus simple, mais je ne peux pas. Cela a quelque chose à voir avec les instructions if et les cartes imbriquées à l'intérieur de la boucle infinie, mais c'est vraiment bizarre .. Quoi qu'il en soit, j'ai supprimé cette version et maintenant il ne reste que la version héritée (et plus rapide), qui fonctionne comme prévu.