• Alice (A) and Bob (B) decided to have a battle.
  • Each combatant has 10 health.
  • They take turns to roll a 6 sided die for damage.
  • That damage is removed from their opponent's health.
  • In the end either Alice or Bob, will vanquish their foe.

Show me how the battle went. Outputting these codes for the actions which have taken place.


B a A    
^ Combatant
  ^ Action (attack)
    ^ Target


B r 4
^ Combatant
  ^ Action (roll)
    ^ Value

Health change

A h 6
^ Combatant
  ^ Attribute (health)
    ^ Value   


A w 
^ Combatant
  ^ Action (win)

Example output:

A a B
A r 4
B h 6
B a A
B r 6
A h 4
A a B
A r 6
B h 0        
A w

Here are the rules:

  • Write in any language.
  • A single roll of the die should have an equal chance of resulting in any one of the numbers 1, 2, 3, 4, 5, or 6.
  • Alice always starts (Bob is chivalrous, in an old-fashioned way).
  • Output an action for each turn.
  • You must report the attack, roll, damage and win actions.
  • Combatants are upper case, actions are lower case.
  • It must not consistently produce the same result.
  • There must be at least one whitespace character between an output combatant, action and value.
  • The win action takes place when the opponent has zero or less health.
  • All parts of an action must be on the same line.
  • There should be one action per line.
  • Fewest bytes wins.

Have at it!

  • 9
    \$\begingroup\$ The names Alice (A) and Bob (B) are giving me flashbacks to network security class. Actor Alice (A) sends a packet to Bob (B) with key... etc... \$\endgroup\$ Commented Mar 22, 2018 at 12:45
  • 23
    \$\begingroup\$ @MagicOctopusUrn that’s them. They’re usually trying to communicate. Sadly conflict often ensues when communication breaks down. \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 12:48
  • 7
    \$\begingroup\$ I miss the days when we were trying to figure out how to hide our secrets from Mallory... those were simpler times... \$\endgroup\$
    – Bob
    Commented Mar 22, 2018 at 13:36
  • 5
    \$\begingroup\$ @Bob Mallory is something of a distraction, really. It's Eve you need to watch out for. \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 13:37
  • 3
    \$\begingroup\$ @msh210 well, the important detail in code golf is that everyone takes the same challenge, but here’s the logic: - if you were playing Dungeons and Dragons, you’d say “I’m going to kick the goblin”, then you’d roll for effectiveness, then implement the result of the roll. A roll is meaningless if nobody knows what you’re rolling for. \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 16:52

16 Answers 16


Python 3, 131 bytes

from random import*
while X>0:p(x,"a",y);d=randint(1,6);p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X

Try it online!

-8 bytes thanks to officialaimm
-2 bytes thanks to ChooJeremy

  • 5
    \$\begingroup\$ predefining p=print will save you around 8 bytes. \$\endgroup\$
    – 0xffcourse
    Commented Mar 22, 2018 at 10:56
  • \$\begingroup\$ Since y always wins at this point (And only X attacks in the loop, which is later swapped to Y), you don't need to check if y has lost. -- ChooJeremy -- From Review \$\endgroup\$ Commented Mar 22, 2018 at 15:50
  • \$\begingroup\$ @NoOneIsHere thanks for passing the message on to me :D \$\endgroup\$
    – hyper-neutrino
    Commented Mar 22, 2018 at 17:52
  • \$\begingroup\$ randint(1,6) could be replaced with id(X+Y)//3%6+1, although the distribution is not quite uniform. \$\endgroup\$
    – Vincent
    Commented Mar 23, 2018 at 13:00
  • \$\begingroup\$ @Vincent I don't see the point in bending the rules if it doesn't even help make it shorter... \$\endgroup\$
    – hyper-neutrino
    Commented Mar 23, 2018 at 13:12

Python 3, 127 bytes

This is an improvement on @HyperNeutrino answer that wouldn't fit in a comment. See the explanation below.

while X>0:p(x,"a",y);s=s**7%~-2**67;d=s%6+1;p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X

Try it online!

An epic quest for a shorter python dice roll

TL;DR: It's possible to shave 4 bytes off the standard python dice roll by using RSA encryption.

I wanted to see if the standard python dice roll (32 bytes) could be shortened a bit:

from random import*;randint(1,6)

In particular, id(x) is quite convenient to bring some non-deterministic value into the program. My idea then was to somehow hash this value to create some actual randomness. I tried a few approaches, and one of them paid off: RSA encryption.

RSA encryption, due to its simplicity, only requires a few bytes: m**e%n. The next random value can then be created by encrypting the previous one. Assuming the (e,n) key is available, the dice roll can be written with 22 bytes:


That means we have about 10 bytes to define a valid RSA key. Here I got lucky. During my experiments, I started to use the Mersenne prime M67 only to realize later on that Mersenne made a mistake including M67 in his list. It turns out to be the product of p=193707721 and q=761838257287. I had found my modulus:


Now, the exponent and the Charmichael totient lcm(p-1,q-1) need to be coprime. Luckily again, the first prime number that do not divide the totient of n is only one digit long: 7. The dice roll can then be written using 28 bytes (4 bytes less than the standard approach):


One good thing with M67 is that the random value generated has 66 bits, which is more than the usual 64 bits RNG. Also, the use of RSA makes it possible to go back in time by decrypting the current value multiple times. Here are the encrypting and decrypting keys:

Encryption: (7,                    147573952589676412927)
Decryption: (42163986236469842263, 147573952589676412927)

Interestingly, this seems to produce a decent RNG according to the diehard test suite:

± echo -e "import os;s=id(os)\nwhile 1:s=s**7%~-2**65+os.write(1,bytes([s%256]))" \
  | python \
  | dieharder -g 200 -a
#            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
   rng_name    |rands/second|   Seed   |
stdin_input_raw|  1.46e+05  | 208008526|
        test_name   |ntup| tsamples |psamples|  p-value |Assessment
   diehard_birthdays|   0|       100|     100|0.10415526|  PASSED  
  • 3
    \$\begingroup\$ Impressive work! :) \$\endgroup\$
    – hyper-neutrino
    Commented Mar 24, 2018 at 18:25

C (gcc), 146 141 bytes

f(A,B,r,t,a,b){for(A=B=10;r=1+clock()%6,A*B>0;t=!t)printf("%c a %c\n%c r %u\n%c h %i\n",a=65+t,b=66-t,a,r,b,t?A-=r:(B-=r));printf("%c w",a);}

Try it online!


    for(A=B=10; //Initialize HP
        r=1+clock()%6, // Get the number of processor cycles the program has consumed. This is relatively random, so I call it good enough.
        A*B>0;t=!t) // Flip t for change of turns
        printf("%c a %c\n%c r %u\n%c h %i\n", // Print the turn
            a=65+t,b=65+!t,a,r,b, // 65 is ASCII for 'A', 66 for 'B'
            t?A-=r:(B-=r)); // Deduct the damage.
    printf("%c w",a); // Print the winner
  • 2
    \$\begingroup\$ Could you save a byte by using a=65+t,b=66-t ? \$\endgroup\$
    – moopet
    Commented Mar 22, 2018 at 13:16
  • \$\begingroup\$ A*B>0 will save you a few bytes. \$\endgroup\$ Commented Mar 22, 2018 at 17:25
  • \$\begingroup\$ A*B will save even more, but I'm kind of in a hurry atm. I'll update in the evening \$\endgroup\$
    – user77406
    Commented Mar 23, 2018 at 8:21
  • \$\begingroup\$ Found a bug in dice seq {6,4,3,1,5}. b wins with health -4. See TIO I changed your dice calculator to demo this bug. \$\endgroup\$
    – GPS
    Commented Mar 23, 2018 at 12:51
  • \$\begingroup\$ @GPS Thanks, I'll patch that now. \$\endgroup\$
    – user77406
    Commented Mar 24, 2018 at 7:33

05AB1E, 49 bytes

"BaABr0Aha"S3ô»D„AB‡[6LΩ©Tǝ¤H®-©16ǝ=®0‹#s]н…ÿ w?

Try it online!


"BaABr0Aha"                                        # push the initial state of B
           S                                       # split to list of characters
            3ô                                     # divide into 3 parts
              »                                    # join each part on space and all on nl
               D„AB‡                              # make a copy with A and B inverted
                     [                             # start a loop
                      6LΩ©                         # pick a random number in [1 ... 6]
                          Tǝ                       # insert at position 10 of the string
                            ¤H                     # get the last char of the string and
                                                   # convert from hex
                              ®-©                  # subtract the random number
                                 16ǝ=              # insert at position 16 and print
                                     ®0‹#          # if the hp is less than 0, break
                                         s         # swap the other string to the stack top
                                          ]        # end loop
                                           н…ÿ w?  # print the winner

Perl 5, 93 88 87 bytes

$A=$B=10;$_=B;${$_^=v3}-=$%=1+rand 6,say"$_ a $'
$_ r $%
$' h $$_"until//>$$_;say"$_ w"

Try it online!


JavaScript (ES6), 122 bytes

f=(h=[10,10,p=0])=>`${x='AB'[p]} a ${y='BA'[p]}
${x} r ${d=Math.random()*6+1|0}
${y} h ${H=h[p^=1]-=d}
${H<1?x+' w':f(h)}`

Try it online!


Java (JDK 10), 180 bytes

v->{var r="";int p=0,H[]={10,10},h=0;for(;H[0]*H[1]>0;)r+=r.format("%3$c a %4$c%n%3$c r %d%n%4$c h %d%n",h+=Math.random()*6-h+1,H[p]-=h,p+65,(p^=1)+65);return r+(char)(66-p)+" w";}

Try it online!



Ruby, 122 120 96 92 91 bytes

f=->x=?A,y=?B,m=10,n=m{p [x,?a,y],[x,?r,r=1+rand(6)],[y,?h,t=n-r]

Saved 1 byte thanks to Asone Tuhid.

Try it online!

  • 1
    \$\begingroup\$ It's like I don't even know how to Ruby any more ;) \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 10:41
  • \$\begingroup\$ I'm afraid your alternative doesn't work, "All parts of an action must be on the same line." Although, might it be possible to make the same optimisation with a tab character? \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 11:21
  • \$\begingroup\$ @AJFaraday Would it be acceptable to output lines in the format ["A", "a", "B"]? If so, I have this 96-byte solution. \$\endgroup\$ Commented Mar 22, 2018 at 12:09
  • \$\begingroup\$ If they’re output one per line. That should do. \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 12:16
  • \$\begingroup\$ -1 byte if you replace ?(p [x,?w]): with ?p([x,?w]): \$\endgroup\$ Commented Mar 22, 2018 at 13:01

C (gcc), 142 bytes

#define R(c,t)r=rand()%6+1,c&&printf(#c" a "#t"\n"#c" r %d\n"#t" h %d\n",r,t-=t<r?t:r),t||puts(#c" w")

Try it online!

  • \$\begingroup\$ Just one problem, this didn't end in a win. \$\endgroup\$
    – AJFaraday
    Commented Mar 22, 2018 at 14:52
  • \$\begingroup\$ @AJFaraday Oh yes, fixed. \$\endgroup\$
    – nwellnhof
    Commented Mar 22, 2018 at 15:01

Java 8, 230 229 228 bytes

v->{for(int h=104,a=h,x=0,y=1,A=10,B=A,r=0,t=0,T;a<119;System.out.printf("%c %3$c %c%n",x+65,y=(a<98?t=r+=Math.random()*6-r+1:a>h?(T=x<1?A-=t:(B-=t))<0?0:T:A*B<1?-16:(x^1)+17)+48,a=a<98?114:a>h?h:A*B<1?119:97))x^=a>h|A*B<1?1:0;}

-2 bytes thanks to @ceilingcat.

Note: there is already a much shorter Java answer, so make sure to upvote his! I use a completely different approach however, so figured it was worth posting as well.


Try it online.

v->{                     // Method with empty unused parameter and no return-type
  for(int h=104,         //  Temp integer with unicode for 'h' to save bytes
          a=h,           //  Second part (Action)
          x=0,           //  First part
          y=1,           //  Third part
          A=10,          //  Score player A, starting at 10
          B=A,           //  Score player B, starting at 10
          r=0,           //  Random dice-roll
          t=0,           //  Previous dice-roll
          T;             //  Temp integer
      a<119              //  Loop until there is a winner:
      ;                  //    After every iteration:
       System.out.printf(//     Print:
        "%c %3$c %c,%n", //      The three parts with spaces, and a new-line
                         //      First part:
        x+65,            //       Add 65 to `x` to convert 0/1 to 65/66 
                         //       (unicode values of A/B)
        (y=              //      Third part (after set-up):
           (a<98?        //       If the previous action was 'a'
                         //        Roll the dice, and save it in `t`
            :a>h?        //       Else-if the previous action was 'r':
             (T=x<1?     //        If the first part changed to player A:
              A-=t       //         Subtract the previous dice-roll from A
             :           //        Else:
              (B-=t))    //         Subtract the previous dice-roll from B
             <0?         //        If this score is below 0:
              0          //         Use 0
             :           //        Else:
              T          //         Use this score
           :             //       Else (the previous action was 'h'):
            A*B<1?       //        Is there a winner:
             -16         //         Change the third part to a space
            :            //        Else:
             (x^1)+17)   //         Change the third part to the other player
         +48,            //       Add 48 to convert it to unicode
         a=              //      Second part:
           a<98?         //       If the previous action was 'a': 
            114          //        Change it to 'r'
           :a>h?         //       Else-if the previous action was 'r':
            h            //        Change it to 'h'
           :             //       Else (the previous action was 'h'):
            A*B<1?       //        If either score is 0:
             119         //         Use 'w'
            :            //        Else:
             97))        //         Use 'a'
    x^=                  //   First part set-up:
       a>h               //    If the previous action is 'r',
       |A*B<1?           //    or there is a winner:
         1               //     Change A→B or B→A
       :                 //    Else:
         0;}             //     A/B remains unchanged

Batch, 174 bytes

@set c=A
@set d=B
@echo %c% a %d%
@echo %c% r %r%
@echo %d% h %h%
@if %h% gtr 0 set c=%d%&set d=%c%&goto g
@echo %c% w

Explanation: % variable references are substituted at parse time. This has two useful benefits:

  • %d%-=r subtracts r from the variable named by d (i.e. indirect reference)
  • set c=%d%&set d=%c% is simply a straight swap.

PHP 7.1: 159 bytes

<?php $A=$B=10;$t='AB';while($A>0&&$B>0){$a=$t[0];$b=$t[1];$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";

Run it in the browser here!

PHP 5.6: 156 bytes

<?php $A=$B=10;$t='AB';while($A>0&&$B>0){list($a,$b)=$t;$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";

Run it in the browser here!

Here's what the PHP 5.6 solution looks like with formatting and comments:

// Initialize both HP counters
$A = $B = 10;

// Set the turn order as a string (which 5.6 allows to be unpacked into a list)
$t = 'AB';

// Run this loop as long as both players have HP
while ($A > 0 && $B > 0) {
    // Unpack the turn string into $a and $b variables; on the first run, $a = 'A'
    // and $b = 'B'. This is no longer possible in PHP 7.0, so the PHP 7.0
    // solution needed to use an array instead.
    list($a, $b) = $t;

    // Set damage to a random number between 1 and 6
    $d = rand(1, 6);

    // Subtract the damage from the referenced value $b. On the first turn, this
    // is 'B', so this ends up subtracting $d from $B. Next turn, $b will be 'A',
    // so it'll subtract $d from $A
    $$b -= $d;

    // Echo the string (interpolated values)
    echo "$a a $b\n$a r $d\n$b h {$$b}\n";

    // Reverse the turn order string ('AB' becomes 'BA', which will affect the
    // call to list in the first line of the while-loop)
    $t = strrev($t);

// Someone's run out of HP; figure out whom by figuring out who still has HP
echo ($A > 0 ? 'A' : 'B') . " w\n";

F#, 238 235 bytes

I thought I was doing well, but you've all far outclassed me!

let p=printfn
let mutable A=10
let mutable B=A
let x h a d=
 p"%s a %s"a d
 let i=(new System.Random()).Next(1,7)
 let j=h-i
 p"%s r %i"a i
 p"%s h %i"d j
 if j<=0 then p"%s w"a
while A*B>0 do
 B<-x B"A""B"
 if B>0 then A<-x A"B""A"

Try it online!

Thanks to Rogem for the brilliant advice to use A*B>0 instead of A>0&&B>0 (takes off 3 bytes).

Thank you also to officialaimm, whose hint about predefining printf in the Python answer helped me shave a few bytes off too.

  • 1
    \$\begingroup\$ An advice that I got from @OlivierGregoire: A*B>0 will save you a couple more. \$\endgroup\$
    – user77406
    Commented Mar 24, 2018 at 8:25
  • \$\begingroup\$ That is absolutely brilliant. Love it. Thank you very much! \$\endgroup\$ Commented Mar 24, 2018 at 12:02

Haskell, 204 bytes

My attempt with Haskell, I wasn't able to get it more competitive unfortunately

import System.Random
main=getStdGen>>= \g->putStr$q(randomRs(1,6)g)10(10::Int)"A ""B "
q(x:z)a b p o=p!"a "!o!l!p!"r "!show x!l!o!"h "!show n!l!if n<1then p!"w"else q z n a o p where n=b-x

Try it online!


import System.Random  --import random module
main=                        --main function, program entry point
 getStdGen                   -- get the global random number generator
   >>= \g->                  --using the random generator g
       putStr $ q            --print the result of function q, passing in ..
          (randomRs (1,6) g) --an infinite list of random numbers, 1 to 6 generated by g
           10 (10::Int)      --the starting health of both players, 
                             --type annotation sadly seems to be required
           "A " "B "         --The names of the players,
                             --with an extra space for formatting
(!)=(++) --define the operator ! for list (String) concatenation, 
         -- we do this a lot so we save a bit by having a one byte operator
l="\n"   -- define l as the newline character

q      --define function q                         
 (x:z) --our list of random numbers, split into the next number (x) and the rest (z)
 a     -- the health of the active player
 b     -- the health of the player getting attacked
 p     -- the name of the active player
 o     -- the name of the player getting attacked
  p!"a "!o!l --create the attack action string with a newline
 !p!"r "!show x!l -- append the roll action
 !o!"h "!show n!l -- append the health remaining
 !           -- append the result of the following if
  if n<1     -- if the player being attacked has been defeated
  then p!"w" -- append the win string for the active player
  else q z n a o p  --otherwise append the result of calling q again with 
                    --rest of the random numbers, and the active players swapped
  where n=b-x -- define the attacked player's new health n
              -- their current health b - the random roll x
  • \$\begingroup\$ You could have a look at our Tips for golfing in Haskell. E.g. where m=b-x can be put into a guard: |m<-b-x=. \$\endgroup\$
    – Laikoni
    Commented Mar 25, 2018 at 1:57
  • \$\begingroup\$ You can lose the lambda and one set of parentheses by rearranging some parameters: main=putStr=<<q"A "10"B "10.randomRs(1,6::Int)<$>getStdGen. You can also use a list and concat it to get rid of redefining (++). The last where doesn't seem to be beneficial to just using b-x everywhere. \$\endgroup\$
    – Angs
    Commented Mar 29, 2018 at 21:29

Julia 0.6, 175 bytes

f(l="AB",h=[10,10],a=1)=(while min(h...)>0;d=3-a;p(l[a]," a ",l[d]);r=rand(1:6);h[d]-=r;p(l[a]," r ",r);p(l[d]," h ",max(h[d],0));a=d;end;p(l[findmax(h)[2]]," w"))

Try it online!

Long, ungolfed version:

function status(player, health)
    println("$player h $(max(0,health))")

function roll(player)
    x = rand(1:6)
    println("$player r $x")

function play()
    players = ["A","B"]
    healths = [10, 10]
    attacker = 1

    while min(healths...) > 0
        println("$(players[attacker]) a $(players[3-attacker])")
        status(players[3-attacker], healths[3-attacker])

        attacker = 3 - attacker

    winner = findmax(healths)[2]
    println("$(players[winner]) w")
  • \$\begingroup\$ There doesn’t seem to be any output in your TIO link. \$\endgroup\$
    – AJFaraday
    Commented Mar 29, 2018 at 19:20
  • \$\begingroup\$ Yeah I don't know why tio doesn't like it. It works fine on my machine. I'll look into it if I have time. \$\endgroup\$
    – niczky12
    Commented Mar 30, 2018 at 8:23

VBA, 222 185 179 Bytes

This recursive solution involves 3 subs

  1. g is the game start that kicks off the first turn
  2. t is called for each turn. It uses recursion.
  3. p is shorter than Debug.Print when used more than 3 times (only 4 in this solution) Edit: Now that I learned that Debug.? is an acceptable alternative to Debug.Print, Debug.?x is shorter than calling a Sub to print.
Sub g()
t "A",10,"B",10
End Sub
Sub t(i,j,x,h)
Debug.?i &" a "&x
Debug.?i &" r "&d
If h<1Then
Debug.?i &" w"
Debug.?x &" h "&h
t x,h,i,j
End If
End Sub

This was a fun challenge. If you know of an online interpreter like TIO for VB6/VBScript/VBA please leave a comment. Then I can post a link to a working solution.

If you want to test this code and have Microsoft Excel, Word, Access, or Outlook installed (Windows only), press Alt+F11 to open the VBA IDE. Insert a new code module (Alt+I,M) and clear out Option Explicit. Then paste in the code and press F5 to run it. The results should appear in the Immediate Window (press Ctrl+G if you don't see it).

Edit 1: Removed whitespace that the VBA editor will automatically add back in. Reduced by 37 bytes
Edit 2: Removed Sub p()* to save 6 bytes after learning Debug.? is an acceptable alternative to Debug.Print. Calling a Sub to handle Debug.? only saves bytes after more than six calls.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.