Mahkumun ikilem egzersizinin bir turunda , iki oyuncu her biri o tur için işbirliği yapıp yapmamaya veya kaçmaya karar verir . Bir turun puanlaması:

• Oyuncu A ve Oyuncu B'nin ikisi birlikte çalışır: Her ikisi için de 1 puan
• Oyuncu A ve Oyuncu B'nin ikisi de kusurlu: ikisi için de 2 puan
• Oyuncu bir işbirliği yapar ve oyuncu B kusurları: 3 puan Oyuncu birlikte çalışan ve 0 puan Oyuncu B bozan için

Yine de strateji hakkında endişelenmenize gerek yok: programınız sadece bir oyunun skorunu tablo haline getirecek. (Mahkumun ikilemine aşina iseniz, buradaki "puanlarım", yıllarca hapishaneye karşılık gelir.)

Zorluk, oyuncuların birkaç turda seçimlerini temsil eden girdileri almak ve toplam puanlarını hesaplamaktır. Bir oyuncu seçimleri küçük harfle cve d( işbirliği ve kusur için ), diğeri ise seçimleri büyük harfle Cve D. Bu seçenekler programınıza dize olarak sağlanır.

Normalde, mahkum ikilemindeki oyuncular hareketlerini eşzamanlı ve tekrarlı olarak sunarlar. Ancak bu mücadelede oyuncular aynı anda birkaç tur için seçimlerini sunmuş olabilirler. Bir oyuncunun hamlesi sıra dışı ise, puanlama programı onu hatırlar ve rakip oyuncudan bir sonraki uygun hamle ile eşleştirir.

Örnek bir giriş dizesi:

cDCddDDCcCc

Bu girişte bulunan eşleşmeleri göstermek için, küçük ve büyük harfleri ayrı ayrı çağırıp eşleştireceğim:

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

Bunlar turlarla eşleştirilecek:

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)

Hangi puan 9(küçük harf) 6(büyük harf) üretir , bu nedenle çıktı 9,6(veya herhangi bir kesin sınırlayıcı) olmalıdır.

Bunu başka bir şekilde ifade etmek için, her bir eşleşme kendi satırında çekildi:

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

Eşleşmeyen bir tane var C, çünkü büyük harfli oyuncu küçük harfli oyuncudan daha fazla hamle gönderdi. Bu kabul edilebilir ve puanlama amacıyla tamamen göz ardı edilir.

İşte gereksinimler:

• /[cdCD]+/Bazı girdi mekanizmaları (STDIN, işlev bağımsız değişkeni, dosyadan okuma vb.) Aracılığıyla normal ifade formunun bir dizesini kabul eden bir program veya işlev yazmalısınız . (Programınız isteğe bağlı olarak sondaki yeni satırla girişi kabul edebilir.)

• Programınız veya işleviniz, oyuncuların puanlarını bir dize olarak çıkarmalı veya döndürmelidir. Çıktı biçimi, küçük harfli oyuncunun puanı ve ardından büyük harfli oyuncunun puanı ile başlamalı ve seçtiğiniz boş olmayan, sayısal olmayan sınırlayıcılarla ayrılmalıdır. (Sonunda bir satırsonu isteğe bağlıdır.)

• Bir oyuncunun diğerinden daha fazla hamlesi varsa, fazla hamleler göz ardı edilir.

• Girişteki tüm hamleler sadece bir oyuncudan geliyorsa (yani, hiç tur oynanmadı), o zaman her oyuncunun puanı olur 0.

• Bayt cinsinden en küçük gönderim kazanır.

Test senaryoları

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 bayt

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

Test odası

Açıklama:

@Gz: Küçük harfler

-zG: Büyük harfler

C,: Eşle, kalanını kes.

`: Çift listesinin dize olarak temsilini al

/L ... "cDDCdd: Her harf "cDDCdd"için yukarıdaki dize repr içinde kaç kez göründüğünü sayın.

c2: Ortaya çıkan listeyi ikiye bölün.

sM: Her yarıyı toplayın.

j: Yeni satırlara katılın ve yazdırın.

`bir tarafın hiç oynamadığı bir davayı yapmak için s yerine kullanılmalıdır.

Haskell, 139 134 bayt

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

Kullanım örneği: f "cDCddDDCcCc"-> "9,6"

15 bayt sadece çıktı biçimini doğru almak için, yani bir çift sayıyı (x,y)bir dizeye dönüştürmek "x,y".

Nasıl çalışır:

               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                    

Düzenleme: @Zgarb 5 bayt kaydetmeme yardımcı oldu. Teşekkürler!

LabVIEW, 77 Bayt

Kod, belirteçlerden tarar ve noktaların nereye gittiğine karar vermek için bu göstergeleri kullanır.

Sayma böyle gider bu

Python 3, 110

FryAmTheEggman sayesinde 5 bayt tasarruf etti.
Apsiller sayesinde 7 bayt kurtardı.
DSM sayesinde 26 Byte tasarruf sağladı.

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)

Sanırım sonunda hepsi dışarı çıktı.

Girdideki her bir karakteri tarar ve büyük veya küçük olmasına göre sıralar. Daha sonra Python'un bools'u ints'e dolaylı dönüştürmesini kötüye kullanan bazı süslü matematik yapar.

JavaScript (ES6), 124 118 bayt

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)

Canlı demo

(Okunabilirlik için hafifçe genişletildi.)

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>

User81655 sayesinde 6 bayt kaydedildi .

Par , 49 bayt

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

Karakter başına bir bayt kullanılır. Buraya bakın .

açıklama

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

Formdaki çıktılar 9 6.

CJam, 92 83 81 bayt

Bu düşündüğümden daha uzun sürdü ...

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

Burada deneyin.

Açıklama (Bunu açıklamaya cesaret edebilir miyim?: 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")