Dans un tour de dilemme du prisonnier , deux joueurs décident chacun de coopérer ou de faire défaut pour ce tour. Le score pour une manche est:

• Le joueur A et le joueur B coopèrent: 1 point pour les deux
• Le joueur A et le joueur B ont tous deux un défaut: 2 points pour les deux
• Le joueur A coopère et le joueur B fait défaut: 3 points pour le joueur coopérant A et 0 point pour le joueur B défectueux

Cependant, vous n'avez pas à vous soucier de la stratégie: votre programme ne fera que tabuler le score d'un match. (Si vous connaissez déjà le dilemme du prisonnier, mes "points" correspondent ici à "des années de prison.")

Votre défi est de prendre des informations qui représentent les choix des joueurs sur plusieurs tours et de calculer leurs scores totaux respectifs. Un joueur soumet des choix en minuscules cet d(pour coopérer et faire défaut ), et l'autre soumet des choix en majuscules, Cet D. Ces choix sont fournis à votre programme sous forme de chaîne.

Normalement, les joueurs dans le dilemme du prisonnier soumettent leurs coups simultanément et de manière itérative. Dans ce défi, cependant, les joueurs peuvent avoir soumis leurs choix pour plusieurs tours à la fois. Si le coup d'un joueur est hors séquence, le programme de pointage s'en souvient et le fait correspondre avec le prochain coup disponible du joueur adverse.

Voici un exemple de chaîne d'entrée:

cDCddDDCcCc

Pour afficher les correspondances qui existent dans cette entrée, je vais appeler séparément les minuscules et les majuscules et les associer:

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

Ceux-ci seront jumelés dans les tours:

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)

Qui produit le score 9(en minuscules) à 6(en majuscules), donc la sortie doit être 9,6(ou tout délimiteur sans ambiguïté).

Pour l'exprimer d'une autre manière, voici chaque paire tirée sur sa propre rangée:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Il y en a un inégalé C, car le joueur majuscule a soumis plus de coups que le joueur minuscule. C'est acceptable et il est totalement ignoré à des fins de notation.

Voici les prérequis:

• Vous devez écrire un programme ou une fonction qui accepte une chaîne de la forme d'expression régulière /[cdCD]+/, via un mécanisme d'entrée (STDIN, argument de fonction, lecture à partir d'un fichier, etc.). (Votre programme peut éventuellement accepter une entrée avec une nouvelle ligne de fin.)

• Votre programme ou fonction doit produire ou renvoyer les scores des joueurs sous forme de chaîne. Le format de sortie doit commencer par le score du joueur en minuscules, suivi du score du joueur en majuscules, séparé par tout délimiteur non vide et non numérique de votre choix. (Une nouvelle ligne de fin est facultative.)

• Si un joueur a plus de coups que l'autre, les coups excédentaires sont ignorés.

• Si tous les coups dans l'entrée proviennent d'un seul joueur (c'est-à-dire qu'aucun tour n'a été joué du tout), alors le score de chaque joueur est 0.

• La plus petite soumission en octets gagne.

Cas de test

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 octets

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

Suite de tests

Explication:

@Gz: Minuscules

-zG: Lettres capitales

C,: Jumeler, tronquer le reste.

`: Prendre la représentation sous forme de chaîne de la liste des paires

/L ... "cDDCdd: Pour chaque lettre "cDDCdd", comptez combien de fois elle apparaît dans la chaîne ci-dessus repr.

c2: Coupez la liste résultante en deux.

sM: Additionnez chaque moitié.

j: Rejoignez les nouvelles lignes et imprimez.

`doit être utilisé à la place de s pour faire en sorte qu'une partie ne joue jamais.

Haskell, 139 134 octets

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

Exemple d'utilisation: f "cDCddDDCcCc"-> "9,6"

15 octets juste pour obtenir le bon format de sortie, c'est-à-dire transformer une paire de nombres (x,y)en une chaîne "x,y".

Comment ça fonctionne:

               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 m'a aidé à économiser 5 octets. Merci!

LabVIEW, 77 octets

Le code scanne à partir des jetons et utilise ces indices pour décider où vont les points.

Le décompte va comme ça

Python 3, 110

5 octets enregistrés grâce à FryAmTheEggman.
Économisé 7 octets grâce aux apsillers.
Économie de 26 octets grâce à 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)

Je pense que tout est finalement joué.

Il parcourt chaque caractère de l'entrée et le trie selon qu'il est en majuscules ou non. Il fait ensuite quelques calculs fantaisistes qui abusent de la conversion implicite de Python de bools en ints.

JavaScript (ES6), 124 118 octets

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)

Démo en direct

(Développé légèrement pour plus de lisibilité.)

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 octets enregistrés grâce à user81655 .

Par , 49 octets

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

Un octet est utilisé par caractère. Voyez ici .

Explication

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

Sorties dans le formulaire 9 6.

CJam, 92 83 81 octets

Cela a fini plus longtemps que je ne le pensais ...

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

Essayez-le ici.

Explication (Oserais-je expliquer cela?: 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")