En una ronda del ejercicio de dilema del prisionero , dos jugadores deciden si cooperar o desertar para esa ronda. La puntuación para una ronda es:

• El jugador A y el jugador B cooperan: 1 punto por ambos
• El jugador A y el jugador B tienen ambos defectos: 2 puntos por ambos
• El jugador A coopera y el jugador B presenta defectos: 3 puntos por cooperar con el jugador A y 0 puntos por desertar del jugador B

Sin embargo, no debe preocuparse por la estrategia: su programa simplemente tabulará el puntaje de un juego. (En caso de que ya esté familiarizado con el dilema del prisionero, mis "puntos" aquí corresponden a "años en prisión").

Su desafío es tomar aportes que representen las elecciones de los jugadores en varias rondas y calcular sus puntajes totales respectivos. Un jugador envía las opciones en minúsculas cy d(para cooperar y desertar ), y el otro envía las opciones en mayúsculas Cy D. Estas opciones se proporcionan a su programa como una cadena.

Normalmente, los jugadores en el dilema del prisionero presentan sus movimientos de forma simultánea e iterativa. En este desafío, sin embargo, los jugadores pueden haber presentado sus elecciones para varias rondas a la vez. Si el movimiento de un jugador está fuera de secuencia, el programa de puntuación lo recuerda y lo compara con el siguiente movimiento disponible del jugador contrario.

Aquí hay una cadena de entrada de muestra:

cDCddDDCcCc

Para mostrar las coincidencias que existen en esta entrada, llamaré las minúsculas y mayúsculas por separado, y las emparejaré:

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

Estos se combinarán en las rondas:

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)

Lo que produce la puntuación 9(minúscula) a 6(mayúscula), por lo que la salida debe ser 9,6(o cualquier delimitador inequívoco).

Para expresarlo de otra manera, aquí está cada emparejamiento extraído en su propia fila:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Hay uno sin igual C, porque el jugador en mayúscula envió más movimientos que el jugador en minúscula. Eso es aceptable, y se ignora por completo para fines de puntuación.

Aquí están los requisitos:

• Debe escribir un programa o función que acepte una cadena de la forma de expresión regular /[cdCD]+/, a través de algún mecanismo de entrada (STDIN, argumento de función, lectura del archivo, etc.). (Su programa puede opcionalmente aceptar entradas con una nueva línea final).

• Su programa o función debe generar o devolver los puntajes de los jugadores como una cadena. El formato de salida debe comenzar con el puntaje del jugador en minúscula, seguido del puntaje del jugador en mayúscula, separado por cualquier delimitador no vacío y no numérico de su elección. (Una nueva línea final es opcional).

• Si un jugador tiene más movimientos que el otro, se ignoran los movimientos en exceso.

• Si todos los movimientos en la entrada provienen exclusivamente de un jugador (es decir, no se han jugado rondas en absoluto), entonces la puntuación de cada jugador es 0.

• La presentación más pequeña en bytes gana.

Casos de prueba

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

Banco de pruebas

Explicación:

@Gz: Letras minusculas

-zG: Letras mayúsculas

C,: Emparejar, truncar el resto.

`: Tome la representación de cadena de la lista de pares

/L ... "cDDCdd: Para cada letra "cDDCdd", cuente cuántas veces aparece en la cadena anterior repr.

c2: Corta la lista resultante por la mitad.

sM: Sume cada mitad.

j: Únete a las nuevas líneas e imprime.

`debe usarse en lugar de s para que el caso en el que una de las partes nunca juegue funcione.

Haskell, 139134 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

Ejemplo de uso: f "cDCddDDCcCc"-> "9,6"

15 bytes solo para obtener el formato de salida correcto, es decir, convertir un par de números (x,y)en una cadena "x,y".

Cómo funciona:

               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                    

Editar: @Zgarb me ayudó a ahorrar 5 bytes. ¡Gracias!

LabVIEW, 77 Bytes

El código escanea desde los tokens y usa esas indicaciones para decidir dónde van los puntos.

Conteo va como este

Pitón 3, 110

Guardado 5 Bytes gracias a FryAmTheEggman.
Guardado 7 Bytes gracias a los apsillers.
Guardado 26 Bytes gracias a DSM.

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)

Creo que finalmente todo se ha desarrollado.

Escanea a través de cada carácter en la entrada y lo ordena en función de mayúsculas o no. Luego hace algunas matemáticas elegantes que abusan de la conversión implícita de Python de bools a ints.

JavaScript (ES6), 124 118 bytes

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)

Demo en vivo

(Ampliado ligeramente para facilitar la lectura).

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>

Guardado 6 bytes gracias a user81655 .

Par , 49 bytes

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

Se usa un byte por carácter. Vea aquí .

Explicación

(              ## 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

Salidas en el formulario 9 6.

CJam, 92 83 81 bytes

Esto terminó más tiempo de lo que pensé que sería ...

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

Pruébalo aquí.

Explicación (¿Me atrevo a explicar esto?: 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")