• Alice (A) und Bob (B) entschieden sich für eine Schlacht.
• Jeder Kämpfer hat 10 Gesundheit.
• Sie werfen abwechselnd einen 6-seitigen Würfel, um Schaden zu verursachen.
• Dieser Schaden wird aus der Gesundheit des Gegners entfernt.
• Am Ende werden entweder Alice oder Bob ihren Gegner besiegen.

Zeig mir, wie die Schlacht gelaufen ist. Ausgabe dieser Codes für die durchgeführten Aktionen.

Attacke

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

Rollen

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

Gesundheitsveränderung

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

Sieg

A w 
^ Combatant
  ^ Action (win)

Beispielausgabe:

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

Hier sind die Regeln:

• Schreiben Sie in einer beliebigen Sprache.
• Ein einzelner Würfelwurf sollte die gleiche Chance haben, eine der Zahlen 1, 2, 3, 4, 5 oder 6 zu erhalten.
• Alice fängt immer an (Bob ist ritterlich, altmodisch).
• Geben Sie für jede Runde eine Aktion aus.
• Sie müssen den Angriff melden, würfeln, beschädigen und Aktionen gewinnen.
• Combatants sind Großbuchstaben, Actions sind Kleinbuchstaben.
• Es darf nicht immer dasselbe Ergebnis liefern.
• Zwischen einem Ausgangskämpfer, einer Aktion und einem Wert muss mindestens ein Leerzeichen stehen.
• Die Gewinnaktion findet statt, wenn der Gegner keine oder weniger Gesundheit hat.
• Alle Teile einer Aktion müssen sich in derselben Zeile befinden.
• Es sollte eine Aktion pro Zeile geben.
• Wenigste Bytes gewinnt.

Habe es drauf!

05AB1E , 49 Bytes

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

Probieren Sie es online!

Erläuterung

"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

Python 3 , 131 Bytes

x,y="AB"
from random import*
X=Y=10
p=print
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
p(y,"w")

Probieren Sie es online!

-8 Bytes dank officialaimm
-2 Bytes dank ChooJeremy

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);}

Probieren Sie es online!

De-Golf:

f(A,B,r,t,a,b){
    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
}

Python 3 , 127 Bytes

Dies ist eine Verbesserung der @ HyperNeutrino-Antwort , die nicht in einen Kommentar passt. Siehe die Erklärung unten.

x,y="AB"
s=id(0)
X=Y=10
p=print
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
p(y,"w")

Probieren Sie es online!

Eine epische Suche nach einem kürzeren Python-Würfelwurf

TL; DR: Mithilfe der RSA-Verschlüsselung können 4 Byte weniger als beim Standard-Python-Würfelwurf verarbeitet werden.

Ich wollte sehen, ob der Standard-Python-Würfelwurf ( 32 Byte ) etwas verkürzt werden kann:

from random import*;randint(1,6)

Insbesondere id(x)ist es sehr praktisch, einen nicht deterministischen Wert in das Programm einzubringen. Meine Idee war dann, diesen Wert irgendwie zu hacken, um eine tatsächliche Zufälligkeit zu erzeugen. Ich habe ein paar Ansätze ausprobiert und einer davon hat sich ausgezahlt: RSA-Verschlüsselung .

RSA - Verschlüsselung, aufgrund seiner Einfachheit, erfordert nur wenige Bytes: m**e%n. Der nächste Zufallswert kann dann erzeugt werden, indem der vorherige verschlüsselt wird. Vorausgesetzt, der (e,n)Schlüssel ist verfügbar, kann der Würfelwurf mit 22 Bytes geschrieben werden :

s=id(0);s=s**e%n;s%6+1

Das heißt, wir haben ungefähr 10 Bytes, um einen gültigen RSA-Schlüssel zu definieren. Hier habe ich Glück gehabt. Während meiner Experimente begann ich , die verwenden Mersenne - Primzahl M67 erst später zu erkennen , auf dass Mersenne einen Fehler gemacht , einschließlich M67 in seiner Liste. Es stellt sich heraus, dass es das Produkt von p=193707721und ist q=761838257287. Ich hatte meinen Modul gefunden:

n=~-2**67

Nun müssen der Exponent und der Charmichael-Totient Koprime (p-1)*(q-1) sein. Zum Glück ist die erste Primzahl, die den Summenwert von n nicht teilt, nur eine Ziffer lang: 7. Der Würfelwurf kann dann mit 28 Bytes (4 Bytes weniger als der Standardansatz) geschrieben werden:

s=id(0);s=s**7%~-2**67;s%6+1

Eine gute Sache bei M67 ist, dass der erzeugte Zufallswert 66 Bits hat, was mehr als die üblichen 64 Bits RNG ist. Die Verwendung von RSA ermöglicht es auch, durch mehrmaliges Entschlüsseln des aktuellen Werts in der Zeit zurück zu gehen. Hier sind die Verschlüsselungs- und Entschlüsselungsschlüssel:

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

Ich bin definitiv kein Experte für Statistik oder Kryptographie, daher kann ich nicht genau sagen, ob dieses RNG die Kriterien für "gute Zufälligkeit" überprüft oder nicht. Ich habe einen kleinen Benchmark geschrieben , der die Standardabweichung des Auftretens von 1 bis 6 Würfeln mit verschiedenen RNGs vergleicht. Die vorgeschlagene Lösung scheint genauso zu funktionieren wie die anderen.

JavaScript (ES6), 122 Byte

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)}`

Probieren Sie es online!

Java (JDK 10) , 180 Byte

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

Probieren Sie es online!

Credits

• -8 Bytes dank Kevin Cruijssen

Perl 5 , 93 88 87 Bytes

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

Probieren Sie es 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]
t<1?p([x,?w]):f[y,x,t,m]}

^{Dank Asone Tuhid 1 Byte gespeichert .}

Probieren Sie es online!

Java 8, 230 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=a>h|A*B<1?x^1: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?104:A*B<1?119:97);}

Hinweis: Es gibt bereits eine viel kürzere Java Antwort, so sicher macht seine upvote ! Ich benutze jedoch einen völlig anderen Ansatz, also dachte ich, dass es sich auch lohnt, ihn zu posten.

Erläuterung:

Probieren Sie es online aus.

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
     System.out.printf(  //   Print
      "%c %3$c %c,%n",   //    The three parts with spaces, and a new-line
      (x=                //    First part:
         a>h             //     If the previous action is 'r',
         |A*B<1?         //     or there is a winner:
           x^1           //      Change A→B or B→A
         :               //     Else:
          x)             //      A/B remains unchanged
       +65,              //     Add 65 to convert 0/1 to 65/66 (unicode values of A/B)
      (y=                //    Third part:
         (a<98?          //     If the previous action was 'a'
           t=r+=Math.random()*6-r+1
                         //      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'

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")
f(A,B,r){for(A=B=10;A*B;R(B,A))R(A,B);}

Probieren Sie es online!

Batch, 174 Bytes

@set/aA=B=10
@set c=A
@set d=B
:g
@set/ar=%random%%%6+1,h=%d%-=r
@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

Erläuterung: %Variablenverweise werden beim Parsen ersetzt. Dies hat zwei nützliche Vorteile:

• %d%-=rsubtrahiert rvon der Variablen mit dem Namen d(dh indirekte Referenz)
• set c=%d%&set d=%c% ist einfach ein 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";

Führen Sie es hier im Browser aus!

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

Führen Sie es hier im Browser aus!

So sieht die PHP 5.6-Lösung mit Formatierungen und Kommentaren aus:

<?php
// 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";

Bash, 178 Bytes

A=10 B=10 e=echo
a(){ $e $1 a $2;d=$((RANDOM%6+1));$e $1 r $d;eval $2=$((${!2}-$d));$e $2 h ${!2};[ ${!2} -gt 0 ];}
while a A B && a B A;do cd;done;[ $A -gt 0 ]&&$e A w||$e B w

F #, 238 235 Bytes

Ich dachte, es geht mir gut, aber Sie haben mich alle weit übertroffen!

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
 j
while A*B>0 do
 B<-x B"A""B"
 if B>0 then A<-x A"B""A"

Probieren Sie es online!

Vielen Dank an Rogem für den tollen Rat, A * B> 0 anstelle von A> 0 && B> 0 zu verwenden (nimmt 3 Bytes ab).

Vielen Dank auch an officialaimm, dessen Hinweis auf die Vordefinition von printf in der Python-Antwort mir geholfen hat, auch ein paar Bytes zu sparen.

Haskell , 204 Bytes

Bei meinem Versuch mit Haskell konnte ich es leider nicht wettbewerbsfähiger machen

import System.Random
main=getStdGen>>= \g->putStr$q(randomRs(1,6)g)10(10::Int)"A ""B "
(!)=(++)
l="\n"
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

Probieren Sie es online!

Erklärungen:

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

Julia 0,6 , 175 Bytes

p=println()
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"))

Probieren Sie es online!

Lange, ungolfierte Version:

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

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

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

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

        attacker = 3 - attacker
    end

    winner = findmax(healths)[2]
    println("$(players[winner]) w")
end

VBA, 222 185 179 Bytes

Diese rekursive Lösung beinhaltet 3 Subs

1. g ist der Spielstart , der die erste Runde startet
2. t wird für jede Runde aufgerufen . Es wird eine Rekursion verwendet.
3. p ist kürzer als Debug.Print, wenn mehr als 3 Mal verwendet (nur 4 in dieser Lösung) Bearbeiten: Nun, da ich gelernt habe, dass dies Debug.?eine akzeptable Alternative zu ist Debug.Print, Debug.?xist kürzer als das Aufrufen eines Sub zum Drucken.

Sub g()
t "A",10,"B",10
End Sub
Sub t(i,j,x,h)
d=Int(Rnd()*6)+1
Debug.?i &" a "&x
Debug.?i &" r "&d
h=h-d
If h<1Then
Debug.?i &" w"
Else
Debug.?x &" h "&h
t x,h,i,j
End If
End Sub

Das war eine lustige Herausforderung. Wenn Sie einen Online-Dolmetscher wie TIO für VB6 / VBScript / VBA kennen, hinterlassen Sie bitte einen Kommentar. Dann kann ich einen Link zu einer funktionierenden Lösung posten.

Wenn Sie diesen Code testen möchten und Microsoft Excel, Word, Access oder Outlook installiert haben (nur Windows), drücken Sie Alt + F11, um die VBA-IDE zu öffnen. Fügen Sie ein neues Codemodul ein (Alt + I, M) und deaktivieren Sie Option Explicit. Fügen Sie dann den Code ein und drücken Sie F5, um ihn auszuführen. Die Ergebnisse sollten im Direktfenster angezeigt werden (drücken Sie Strg + G, wenn Sie es nicht sehen).

Edit 1: Leerzeichen entfernt, das der VBA-Editor automatisch wieder hinzufügt. Reduziert um 37 Byte
Edit 2: Sub p () * entfernt, um 6 Byte nach dem Lernen zu sparen, Debug.?ist eine akzeptable Alternative zu Debug.Print. Das Aufrufen eines Sub zum Behandeln Debug.?speichert nur Bytes nach mehr als sechs Aufrufen.