In un round dell'esercizio del dilemma del prigioniero , due giocatori decidono ciascuno se cooperare o difendersi per quel round. Il punteggio per un round è:

• Il giocatore A e il giocatore B cooperano entrambi: 1 punto per entrambi
• Il giocatore A e il giocatore B hanno entrambi un difetto: 2 punti per entrambi
• Il giocatore A collabora e i difetti del giocatore B: 3 punti per la cooperazione del giocatore A e 0 punti per la defezione del giocatore B

Non devi preoccuparti della strategia, però: il tuo programma semplicemente tabulerà il punteggio per una partita. (Nel caso in cui tu abbia già familiarità con il dilemma del prigioniero, i miei "punti" qui corrispondono a "anni di prigione").

La tua sfida è quella di prendere input che rappresentano le scelte dei giocatori in diversi round e calcolare i rispettivi punteggi totali. Un giocatore invia le scelte in minuscolo ce d(per cooperare e per difetto ) e l'altro invia le scelte in maiuscolo Ce D. Queste scelte sono fornite al tuo programma come una stringa.

Normalmente, i giocatori nel dilemma del prigioniero presentano le loro mosse simultaneamente e iterativamente. In questa sfida, tuttavia, i giocatori potrebbero aver presentato le proprie scelte per diversi round contemporaneamente. Se la mossa di un giocatore è fuori sequenza, il programma di punteggio lo ricorda e lo abbina alla successiva mossa disponibile del giocatore avversario.

Ecco una stringa di input di esempio:

cDCddDDCcCc

Per mostrare le corrispondenze esistenti in questo input, chiamerò separatamente le lettere minuscole e maiuscole e le accoppierò:

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

Questi saranno associati ai round:

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)

Che produce il punteggio 9(minuscolo) a 6(maiuscolo), quindi l'output dovrebbe essere 9,6(o qualsiasi delimitatore non ambiguo).

Per esprimerlo in un altro modo, ecco ogni accoppiamento estratto sulla propria riga:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Ne esiste uno senza pari C, perché il giocatore in maiuscolo ha inviato più mosse del giocatore in minuscolo. Questo è accettabile ed è totalmente ignorato ai fini del punteggio.

Ecco i requisiti:

• È necessario scrivere un programma o una funzione che accetta una stringa del modulo di espressione regolare /[cdCD]+/ , tramite alcuni meccanismi di input (STDIN, argomento della funzione, lettura da file, ecc.). (Il tuo programma può facoltativamente accettare input con una nuova riga finale).

• Il tuo programma o funzione deve generare o restituire i punteggi dei giocatori come una stringa. Il formato di output deve iniziare con il punteggio del giocatore in minuscolo, seguito dal punteggio del giocatore in maiuscolo, separato da qualsiasi delimitatore non vuoto, non numerico di tua scelta. (Una nuova riga finale è facoltativa.)

• Se un giocatore ha più mosse dell'altro, le mosse in eccesso vengono ignorate.

• Se tutte le mosse nell'input provengono esclusivamente da un giocatore (cioè non sono stati giocati affatto round), allora il punteggio di ciascun giocatore è 0.

• Vince il più piccolo invio in byte.

Casi 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 byte

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

Suite di test

Spiegazione:

@Gz: Lettere minuscole

-zG: Lettere maiuscole

C,: Accoppia, tronca il resto.

`: Accetta la rappresentazione in formato stringa dell'elenco di coppie

/L ... "cDDCdd: Per ogni lettera in "cDDCdd", conta quante volte appare nella precedente stringa repr.

c2: Taglia a metà l'elenco risultante.

sM: Aggiungi ogni metà.

j: Unisciti a newline e stampa.

`deve essere usato al posto di s per far funzionare il caso in cui una parte non gioca mai.

Haskell, 139 134 byte

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

Esempio di utilizzo: f "cDCddDDCcCc"-> "9,6"

15 byte solo per ottenere il formato di output corretto, ovvero trasformare una coppia di numeri (x,y)in una stringa"x,y" .

Come funziona:

               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                    

Modifica: @Zgarb mi ha aiutato a salvare 5 byte. Grazie!

LabVIEW, 77 byte

Il codice esegue la scansione dai token e utilizza tali indicazioni per decidere dove vanno i punti.

Conteggio va come questo

Python 3, 110

5 byte salvati grazie a FryAmTheEggman.
Risparmio di 7 byte grazie a apsillers.
Risparmiato 26 byte grazie 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)

Penso che sia finalmente tutto finito.

Esegue la scansione di ogni carattere nell'input e lo ordina in base al fatto che sia maiuscolo o meno. Fa quindi un po 'di fantasia matematica che abusa della conversione implicita di bool in in Python.

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)

Dimostrazione dal vivo

(Ampliato leggermente per leggibilità.)

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 byte salvati grazie a user81655 .

Par , 49 byte

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

Viene utilizzato un byte per carattere. Vedi qui .

Spiegazione

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

Output nel modulo 9 6.

CJam, 92 83 81 byte

Questo è finito più a lungo di quanto pensassi ...

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

Provalo qui.

Spiegazione (Oserei spiegarlo?: 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")