Em uma rodada do dilema do prisioneiro , dois jogadores decidem cooperar ou desertar para essa rodada. A pontuação para uma rodada é:

• O jogador A e o jogador B cooperam: 1 ponto para ambos
• Jogador A e Jogador B ambos com defeito: 2 pontos para ambos
• O jogador A coopera e o jogador B falha: 3 pontos por cooperar no jogador A e 0 pontos por deserção do jogador B

Você não precisa se preocupar com estratégia: seu programa será apenas tabular a pontuação de um jogo. (Caso você já esteja familiarizado com o dilema do prisioneiro, meus "pontos" aqui correspondem a "anos de prisão".)

Seu desafio é receber informações que representem as escolhas dos jogadores em várias rodadas e calcular suas respectivas pontuações totais. Um jogador envia opções em minúsculas ce d(para cooperar e defeito ), e o outro envia opções em maiúsculas Ce D. Essas opções são fornecidas ao seu programa como uma string.

Normalmente, jogadores no dilema do prisioneiro enviam seus movimentos simultaneamente e de forma iterativa. Nesse desafio, no entanto, os jogadores podem ter enviado suas escolhas para várias rodadas ao mesmo tempo. Se o movimento de um jogador estiver fora de sequência, o programa de pontuação o lembra e o combina com o próximo movimento disponível do jogador adversário.

Aqui está um exemplo de string de entrada:

cDCddDDCcCc

Para mostrar as correspondências existentes nesta entrada, chamarei as minúsculas e as maiúsculas separadamente e as emparelhe:

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

Estes serão emparelhados nas rodadas:

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)

O que produz a pontuação 9 (minúscula) para 6(maiúscula), a saída deve ser 9,6(ou qualquer delimitador inequívoco).

Para expressá-lo de outra maneira, eis cada emparelhamento extraído em sua própria linha:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Há um incomparável C, porque o jogador em maiúsculas enviou mais movimentos que o jogador em minúsculas. Isso é aceitável e é totalmente ignorado para fins de pontuação.

Aqui estão os requisitos:

• Você deve escrever um programa ou função que aceite uma sequência do formulário de expressão regular /[cdCD]+/ , por meio de algum mecanismo de entrada (STDIN, argumento de função, leitura de arquivo etc.). (Seu programa pode opcionalmente aceitar entrada com uma nova linha à direita.)

• Seu programa ou função deve gerar ou retornar as pontuações dos jogadores como uma string. O formato de saída deve começar com a pontuação do jogador em minúsculas, seguida pela pontuação do jogador em maiúsculas, separada por qualquer delimitador não vazio e não numérico de sua escolha. (Uma nova linha à direita é opcional.)

• Se um jogador tiver mais jogadas que o outro, as jogadas em excesso serão ignoradas.

• Se todos os movimentos na entrada são exclusivamente de um jogador (ou seja, nenhuma rodada foi jogada), então a pontuação de cada jogador é 0.

• O menor envio em bytes vence.

Casos de teste

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

Pitão, 23 bytes

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

Suíte de teste

Explicação:

@Gz: Letras minúsculas

-zG: Letras maiúsculas

C,: Emparelhar, truncar o restante.

`: Pegue a representação em cadeia da lista de pares

/L ... "cDDCdd: Para cada letra "cDDCdd", conte quantas vezes ela aparece na sequência acima repr.

c2: Pique a lista resultante ao meio.

sM: Adicione cada metade.

j: Junte-se às novas linhas e imprima.

`deve ser usado em vez de s para fazer com que o caso de uma parte nunca funcione.

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

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

15 bytes apenas para obter o formato de saída correto, ou seja, transformar um par de números (x,y)em uma string "x,y".

Como 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                    

Edit: @Zgarb me ajudou a economizar 5 bytes. Obrigado!

LabVIEW, 77 bytes

O código varre os tokens e usa essas indicações para decidir para onde os pontos vão.

Contagem vai como este

Python 3, 110

Guardado 5 bytes graças a FryAmTheEggman.
Economizou 7 bytes graças a apsillers.
Economizou 26 bytes graças ao 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)

Eu acho que finalmente está tudo pronto.

Ele examina cada caractere na entrada e classifica-o com base em maiúsculas ou não. Em seguida, faz algumas matemáticas sofisticadas que abusam da conversão implícita de bools em ints do Python.

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)

Demonstração ao vivo

(Expandido ligeiramente para facilitar a leitura.)

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>

Economizou 6 bytes graças a user81655 .

Par , 49 bytes

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

Um byte é usado por caractere. Veja aqui .

Explicação

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

Saídas no formulário 9 6.

CJam, 92 83 81 bytes

Isso acabou mais do que eu pensava ...

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

Experimente aqui.

Explicação (ouso explicar isso?: 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")