In einer Runde des Häftlingsdilemmas entscheiden jeweils zwei Spieler, ob sie in dieser Runde kooperieren oder ausfallen . Die Wertung für eine Runde lautet:

• Spieler A und Spieler B kooperieren beide: 1 Punkt für beide
• Spieler A und Spieler B haben beide Fehler: 2 Punkte für beide
• Spieler A kooperiert und Spieler B defekt : 3 Punkte für kooperierenden Spieler A und 0 Punkte für den Defekt von Spieler B

Sie brauchen sich jedoch keine Gedanken über die Strategie zu machen: Ihr Programm tabelliert lediglich die Punktzahl für ein Spiel. (Falls Sie bereits mit dem Gefangenendilemma vertraut sind, entsprechen meine "Punkte" hier "Jahren im Gefängnis".)

Ihre Herausforderung besteht darin, Eingaben zu machen, die die Entscheidungen der Spieler über mehrere Runden repräsentieren, und ihre jeweiligen Gesamtpunktzahlen zu berechnen. Ein Spieler gibt die Auswahl in Kleinbuchstaben cund d(für Zusammenarbeit und Fehler ) und der andere in Großbuchstaben Cund ein D. Diese Auswahlmöglichkeiten werden Ihrem Programm als Zeichenfolge zur Verfügung gestellt.

Normalerweise reichen Spieler im Gefangenendilemma ihre Züge gleichzeitig und iterativ ein. Bei dieser Herausforderung haben die Spieler möglicherweise ihre Auswahl für mehrere Runden gleichzeitig abgegeben. Wenn der Zug eines Spielers nicht in der richtigen Reihenfolge ist, merkt sich das Auswertungsprogramm den Zug und gleicht ihn mit dem nächsten verfügbaren Zug des gegnerischen Spielers ab.

Hier ist eine Beispiel-Eingabezeichenfolge:

cDCddDDCcCc

Um die Übereinstimmungen anzuzeigen, die in dieser Eingabe vorhanden sind, rufe ich Klein- und Großbuchstaben getrennt auf und verbinde sie:

cDCddDDCcCc
c  dd   c c => cddcc
 DC  DDC C  => DCDDCC

Diese werden in die Runden eingeteilt:

c vs D (3 pts for lowercase-player, 0 pts for uppercase-player)
d vs C (0 pts for lowercase-player, 3 pts for uppercase-player)
d vs D (2 pts for both)
c vs D (3 pts for lowercase-player, 0 pts for uppercase-player)
c vs C (1 pt for both)

Wodurch die Punktzahl 9(Kleinbuchstaben) in 6(Großbuchstaben) umgewandelt wird, sollte die Ausgabe 9,6(oder ein eindeutiges Trennzeichen) sein.

Um es noch anders auszudrücken, hier ist jede Paarung in einer eigenen Reihe gezogen:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Es gibt einen, der nicht übereinstimmt C, da der Spieler mit Großbuchstaben mehr Züge eingereicht hat als der Spieler mit Kleinbuchstaben. Das ist akzeptabel und wird für Bewertungszwecke völlig ignoriert.

Hier sind die Anforderungen:

• Sie müssen ein Programm oder eine Funktion schreiben /[cdCD]+/, die über einen Eingabemechanismus (STDIN, Funktionsargument, Auslesen aus Datei usw.) eine Zeichenfolge in Form eines regulären Ausdrucks akzeptiert . (Ihr Programm akzeptiert optional Eingaben mit einer nachgestellten Newline.)

• Ihr Programm oder Ihre Funktion muss die Punktzahlen der Spieler als Zeichenfolge ausgeben oder zurückgeben. Das Ausgabeformat muss mit der Punktzahl des Spielers in Kleinbuchstaben beginnen, gefolgt von der Punktzahl des Spielers in Großbuchstaben, getrennt durch ein nicht leeres, nicht numerisches Trennzeichen Ihrer Wahl. (Ein abschließender Zeilenumbruch ist optional.)

• Wenn ein Spieler mehr Züge als der andere hat, werden die überschüssigen Züge ignoriert.

• Wenn alle Züge in der Eingabe von ausschließlich einem Spieler stammen (dh es wurden überhaupt keine Runden gespielt), beträgt die Punktzahl jedes Spielers 0.

• Die kleinste Einsendung in Bytes gewinnt.

Testfälle

Input:  cDCddDDCcCc
Output: 9,6         -- or any delimiter; I chose commas here

Input:  cccDDD
Output: 9,0         

Input:  DDDDDDccc
Output: 9,0

Input:  cDcDcD
Output: 9,0

Input:  dcDDC
Output: 5,2

Input:  CcdCDDcd
Output: 6,6

Input:  Ddd
Output: 2,2

Input:  ccccccccccc
Output: 0,0

Pyth, 23 Bytes

jsMc2/L`C,@Gz-zG"cDDCdd

Testsuite

Erläuterung:

@Gz: Kleinbuchstaben

-zG: Großbuchstaben

C,: Koppeln, Rest abschneiden.

`: Nehmen Sie die Zeichenfolgendarstellung der Liste der Paare

/L ... "cDDCdd: "cDDCdd"Zählen Sie für jeden Buchstaben in , wie oft er in der obigen String-Repräsentation vorkommt.

c2: Zerhacken Sie die resultierende Liste in zwei Hälften.

sM: Addiere jede Hälfte.

j: An Zeilenumbrüchen teilnehmen und ausdrucken.

`muss anstelle von s verwendet werden, um den Fall zu schaffen, dass eine Partei niemals Arbeit spielt.

Haskell, 139.134 Bytes

g=filter
(n!m)(a,b)=(a+n,b+m)
f s=init$tail$show$foldr id(0,0)$zipWith(#)(g(>'a')s)$g(<'E')s
'c'# 'C'=1!1
'c'#_=3!0
_# 'D'=2!2
_#_=0!3

Anwendungsbeispiel: f "cDCddDDCcCc"-> "9,6"

15 Bytes, um das Ausgabeformat richtig zu machen, dh ein Zahlenpaar (x,y)in eine Zeichenfolge zu verwandeln "x,y".

Wie es funktioniert:

               g(>'a')s        -- extract all lowercase letters
                     g(<'E')s  -- extract all uppercase letters
         zipWith(#)            -- combine both lists element wise with function #
                               -- # calls ! depending on the combination of c/d/C/D
                               -- ! takes 2 numbers a and b and returns a function
                               -- that takes a pair (x,y) and returns (x+a,y+b)
                               -- now we have a list of such functions
    foldr id(0,0)              -- apply those functions starting with (0,0)
init$tail$show                 -- format output                    

Edit: @Zgarb hat mir geholfen, 5 Bytes zu sparen. Vielen Dank!

LabVIEW, 77 Bytes

Der Code scannt von Token und verwendet diese Angaben, um zu entscheiden, wohin die Punkte gehen.

Zählen geht so

Python 3, 110

5 Bytes gespart dank FryAmTheEggman.
7 Bytes dank apsillers gespart.
26 Bytes dank DSM eingespart.

x=[[],[]]
a=b=0
for m in input():x[m<'E']+=m
for w,p in zip(*x):d=p>'C';c=w<'d';b+=d*2+c;a+=3-d-2*c
print(b,a)

Ich denke, es ist endlich alles erledigt.

Es durchsucht jedes Zeichen in der Eingabe und sortiert es nach Großbuchstaben oder Nicht-Großbuchstaben. Dann macht es eine ausgefallene Rechnung, die Pythons implizite Umwandlung von Bools in Ints missbraucht.

JavaScript (ES6), 124 118 Byte

s=>(A=B=i=0,U=(r=x=>s.replace(/c|d/g,x))``,r(l=>U[i]&&(U[i++]<'D'?l<'d'?++A&++B:B+=3:l<'d'?A+=3:(A+=2,B+=2))),A+','+B)

Live-Demo

(Aus Gründen der Lesbarkeit leicht erweitert.)

var f=function (s) {
    A=B=i=0;
    U=(r=function(x){return s.replace(/c|d/g,x)})("");
    r(l=>U[i]&&(U[i++]<'D'?l<'d'?++A&++B:B+=3:l<'d'?A+=3:(A+=2,B+=2)));
    return A+','+B;
}

var input = ["cDCddDDCcCc","cccDDD","DDDDDDccc","cDcDcD","dcDDC","CcdCDDcd","Ddd","ccccccccccc"];
var output = ["9,6","9,0","9,0","9,0","5,2","6,6","2,2","0,0"];
var passed = true;

for (var index=0;index<input.length;index++) {
    if (f(input[index]) !== output[index]) passed = false;
}

document.getElementById("result").textContent = 
  passed ? "All tests passed." : "Some tests failed.";

<div id="result"></div>

6 Bytes dank user81655 gespart .

Par , 49 Bytes

(lW▼·L)w▼·U))t˅y])[h7%Z2*↓″4>5*-]z2↔-″0<4*+╞)t.Σ¡

Pro Zeichen wird ein Byte verwendet. Sehen Sie hier .

Erläuterung

(              ## Construct array
 l             ## Read line
 W             ## Assign to w
 ▼·L)          ## Filter by immutable under lower-case
 w             ## Get w
 ▼·U)          ## Filter by immutable under upper-case
)              ## 
t              ## Transpose and truncate
˅y])           ## If empty, empty 2-D matrix
[              ## Map
 h             ## Decimal to hex
 7%            ## Modulo 7
 Z             ## Assign to z
 2*↓″4>5*-     ## Score of lower case
 ]             ## Put in array
 z2↔-″0<4*+    ## Score of upper case
 ╞             ## Add to array
)              ## 
t              ## Transpose and truncate
.Σ             ## Map - sum
¡              ## Empty array onto stack

Ausgaben im Formular 9 6.

CJam, 92 83 81 Bytes

Dies endete länger als ich gedacht hatte ...

0]K*X3tC30tG22tZ11t:L;0'a]q+{'D>}:B$_{B}%1#/z{,1>},{2<[:i:#K%L=]sY0e[{si}%}%:.+S*

Probieren Sie es hier aus.

Erklärung (Darf ich das erklären?: O):

0]K*C3tX30tG22tZ11t:L;    e# Creates this array [0,30,0,11,0,0,0,0,0,0,0,0,3,0,0,0,22,0,0,0]
0'a]q+                    e# Creates an array that looks like [0, 'a', input string]
{'D>}:B$                  e# Sorts the array by if the int representation of each element is greater than the int value of the character 'D' (e.g. [0,C,D,a,c,d])
_{B}%1#/                  e# Finds the index of the first value in the array that is > 'D' and splits the array at that index.
z{,1>},{                  e# Zip the two sub arrays and filter for only sub arrays with more than one element. (e.g [[0,a],[C,c],[D,d]])
{2<[:i:#K%L=]s            e# For each sub array, take the first two elements, convert each to an it, calculate n=(x[0]^x[1]) mod 20, and get the nth element in the very first array, and convert it to a string
Y0e[                      e# Pad the string with 0 so it is length 2. (e.g. [["00"],["22"],["11"]])
{si}%}%:.+                e# get the numerical representation of each digit and dot sum all of them (e.g [[0,0],[2,2],[1,1] => [3,3])
S*                        e# Join with a space (e.g "3 3")