Dalam putaran latihan dilema tahanan , masing-masing dua pemain memutuskan apakah akan bekerja sama atau membelot untuk putaran itu. Skor untuk satu ronde adalah:

• Player A dan Player B bekerja sama: 1 poin untuk keduanya
• Player A dan Player B keduanya cacat: 2 poin untuk keduanya
• Player A bekerja sama dan Player B cacat: 3 poin untuk bekerja sama Player A dan 0 poin untuk membelot Player B

Anda tidak perlu khawatir tentang strategi: program Anda hanya akan mentabulasi skor untuk sebuah game. (Jika Anda sudah terbiasa dengan dilema tahanan, "poin" saya di sini sesuai dengan "tahun penjara.")

Tantangan Anda adalah mengambil input yang mewakili pilihan pemain selama beberapa ronde dan menghitung skor total masing-masing. Satu pemain mengirimkan pilihan dalam huruf kecil, cdan d(untuk bekerja sama dan cacat ), dan yang lain mengirimkan pilihan dalam huruf besar, Cdan D. Pilihan ini disediakan untuk program Anda sebagai string.

Biasanya, pemain dalam dilema narapidana menyerahkan gerakan mereka secara bersamaan dan berulang. Namun, dalam tantangan ini, para pemain mungkin telah menyerahkan pilihan mereka untuk beberapa putaran sekaligus. Jika gerakan pemain di luar urutan, program penilaian akan mengingatnya dan mencocokkannya dengan gerakan berikutnya yang tersedia dari pemain lawan.

Ini contoh string input:

cDCddDDCcCc

Untuk menunjukkan kecocokan yang ada dalam input ini, saya akan memanggil huruf kecil dan besar secara terpisah, dan memasangkannya:

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

Ini akan dipasangkan ke dalam putaran:

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)

Yang menghasilkan skor 9(huruf kecil) ke 6(huruf besar), sehingga output harus 9,6(atau pembatas yang tidak ambigu).

Untuk mengekspresikannya dengan cara lain, berikut adalah masing-masing pasangan menarik pada barisnya sendiri:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Ada satu yang tak tertandingi C, karena pemain huruf besar mengirim lebih banyak gerakan daripada pemain huruf kecil. Itu bisa diterima, dan itu benar-benar diabaikan untuk tujuan penilaian.

Berikut persyaratannya:

• Anda harus menulis program atau fungsi yang menerima string dari bentuk ekspresi reguler /[cdCD]+/, melalui beberapa mekanisme input (STDIN, argumen fungsi, baca dari file, dll.). (Program Anda secara opsional dapat menerima input dengan baris baru yang tertinggal.)

• Program atau fungsi Anda harus menampilkan atau mengembalikan skor pemain sebagai string. Format output harus dimulai dengan skor pemain huruf kecil, diikuti oleh skor pemain huruf besar, dipisahkan oleh pembatas non-kosong, non-numerik pilihan Anda. (Baris baru tambahan adalah opsional.)

• Jika satu pemain memiliki lebih banyak gerakan daripada yang lain, kelebihan gerakan diabaikan.

• Jika semua gerakan dalam input hanya dari satu pemain (yaitu, tidak ada putaran yang dimainkan sama sekali), maka skor setiap pemain adalah 0.

• Pengajuan terkecil dalam byte akan menang.

Uji kasus

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 uji

Penjelasan:

@Gz: Huruf kecil

-zG: Huruf besar

C,: Pasangkan, potong sisanya.

`: Ambil representasi string dari daftar pasangan

/L ... "cDDCdd: Untuk setiap huruf dalam "cDDCdd", hitung berapa kali muncul dalam string di atas.

c2: Potong daftar yang dihasilkan menjadi dua.

sM: Tambahkan masing-masing setengahnya.

j: Gabung di baris baru dan cetak.

`Harus digunakan sebagai ganti s untuk membuat kasus di mana satu pihak tidak pernah bermain bekerja.

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

Contoh penggunaan: f "cDCddDDCcCc"-> "9,6"

15 byte hanya untuk mendapatkan format output yang benar, yaitu mengubah sepasang angka (x,y)menjadi sebuah string "x,y".

Bagaimana itu bekerja:

               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                    

Sunting: @Zgarb membantu saya menghemat 5 byte. Terima kasih!

LabVIEW, 77 Bytes

Kode memindai dari token dan menggunakan indeks tersebut untuk memutuskan ke mana titik pergi.

Hitungannya seperti ini

Python 3, 110

Disimpan 5 Bytes berkat FryAmTheEggman.
Disimpan 7 Bytes berkat apsillers.
Disimpan 26 Bytes berkat 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)

Saya pikir itu akhirnya semua golf.

Ini memindai setiap karakter dalam input dan mengurutkannya berdasarkan huruf besar atau tidak. Kemudian melakukan beberapa matematika mewah yang menyalahgunakan konversi bools ke ints implisit 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)

Demo langsung

(Diperluas sedikit agar mudah dibaca.)

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>

Disimpan 6 byte berkat pengguna81655 .

Par , 49 byte

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

Satu byte digunakan per karakter. Lihat di sini .

Penjelasan

(              ## 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 dalam bentuk 9 6.

CJam, 92 83 81 byte

Ini berakhir lebih lama daripada yang saya pikir akan ...

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

Coba di sini.

Penjelasan (Berani saya jelaskan ini?: 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")