죄수의 딜레마 운동 라운드 에서 두 명의 선수가 각각 협조 할지 결정 또는 결함 이 라운드. 라운드 점수는 다음과 같습니다.

• 플레이어 A와 B 선수 모두 협력 : 모두 1 포인트
• 플레이어 A와 플레이어 B 모두 결함 : 둘 다에 대해 2 점
• 플레이어 A가 협력하고 플레이어 B 결함 : 플레이어 A와 협력하기위한 3 점 및 0 점 플레이어 B를위한 이탈

그러나 전략에 대해 걱정할 필요는 없습니다. 프로그램은 단순히 게임의 점수를 표로 만들뿐입니다. (당신이 이미 죄수의 딜레마에 친숙한 경우, 여기의 "점"은 "감옥의 해"에 해당합니다.)

당신의 도전은 여러 라운드에서 플레이어의 선택을 나타내는 입력을 취하고 각각의 총 점수를 계산하는 것입니다. 한 선수 소문자을 제출 선택, c및 d(대한 협력 및 결함 ), 대문자의 다른을 제출 선택, C및D . 이러한 선택은 프로그램에 문자열로 제공됩니다.

일반적으로 죄수의 딜레마에있는 플레이어는 자신의 움직임을 동시에 반복적으로 제출합니다. 그러나이 도전에서 플레이어는 한 번에 여러 라운드에 대한 선택을 제출했을 수 있습니다. 플레이어의 움직임이 순서에 맞지 않으면, 스코어링 프로그램은이를 기억하고 상대 플레이어의 다음 가능한 움직임과 일치시킵니다.

샘플 입력 문자열은 다음과 같습니다.

cDCddDDCcCc

이 입력에 존재하는 일치 항목을 표시하기 위해 소문자와 대문자를 개별적으로 호출하고 쌍을 이루겠습니다.

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

이들은 라운드로 쌍을 이룰 것입니다 :

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)

점수 9(소문자) ~ 6(대문자)를 생성하므로 출력은 9,6(또는 명확한 구분 기호) 이어야합니다 .

또 다른 방식으로 표현하기 위해 다음은 각 행을 자체 행으로 가져옵니다.

cDCddDDCcCc
cD
  Cd
    dD
      D c
       C  c

C대문자 플레이어가 소문자 플레이어보다 더 많은 움직임을 제출했기 때문에 일치하지 않는 것이 하나 있습니다 . 이는 허용되며 점수를 매기기 위해 완전히 무시됩니다.

요구 사항은 다음과 같습니다.

• /[cdCD]+/일부 입력 메커니즘 (STDIN, 함수 인수, 파일에서 읽기 등)을 통해 정규 표현식 형식의 문자열을 허용하는 프로그램 또는 함수를 작성해야합니다 . (귀하의 프로그램은 선택적으로 후행 줄 바꿈으로 입력을 받아 들일 수 있습니다.)

• 프로그램이나 함수는 플레이어의 점수를 문자열로 출력하거나 반환해야합니다. 출력 형식은 소문자 플레이어의 점수로 시작한 다음 대문자 플레이어의 점수로 시작해야하며 비어 있지 않은 숫자가 아닌 구분 기호로 구분됩니다. 후행 줄 바꿈은 선택 사항입니다.

• 한 선수가 다른 선수보다 더 많은 움직임을 가지면 초과 움직임은 무시됩니다.

• 입력의 모든 움직임이 독점적으로 한 명의 플레이어에서 온 경우 (즉, 라운드가 전혀 재생되지 않은 경우) 각 플레이어의 점수는 0입니다.

• 바이트 단위의 가장 작은 제출물이 이깁니다.

테스트 사례

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 바이트

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

테스트 스위트

설명:

@Gz: 소문자

-zG: 대문자

C,: 나머지를 쌍으로 자릅니다.

`: 쌍 목록의 문자열 표현을 가져옵니다.

/L ... "cDDCdd: 각 문자 "cDDCdd" 에 대해 위의 문자열 repr에 몇 번 나타나는지 계산하십시오.

c2: 결과 목록을 반으로 자릅니다.

sM: 반을 더합니다.

j: 줄 바꿈에 참여하고 인쇄하십시오.

한 당사자가 결코 일을하지 않는 경우를 만들기 위해 s 대신`를 사용해야합니다.

하스켈, 139134 바이트

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

사용 예 : f "cDCddDDCcCc"-> "9,6"

15 바이트는 출력 형식을 올바르게 얻기 위해, 즉 한 쌍의 숫자 (x,y)를 문자열로 바꾸는 것 "x,y"입니다.

작동 방식 :

               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                    

편집 : @ Zgarb는 5 바이트를 절약하는 데 도움이되었습니다. 감사!

LabVIEW, 77 바이트

이 코드는 토큰에서 스캔하고 해당 인덱스를 사용하여 포인트가 어디로 가는지 결정합니다.

계수는 같이가는 이

파이썬 3, 110

FryAmTheEggman 덕분에 5 바이트를 절약했습니다.
apsiller 덕분에 7 바이트를 절약했습니다.
DSM 덕분에 26 바이트를 절약했습니다.

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)

나는 그것이 모두 골프를 쳤다고 생각한다.

입력의 각 문자를 스캔하여 대문자인지 여부에 따라 정렬합니다. 그런 다음 파이썬의 부울을 int로 암시 적으로 변환하는 것을 악용하는 멋진 수학을 수행합니다.

자바 스크립트 (ES6) 124 118 바이트

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)

라이브 데모

(가독성을 위해 약간 확장되었습니다.)

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 덕분에 6 바이트를 절약했습니다 .

Par , 49 바이트

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

문자 당 1 바이트가 사용됩니다. 여기를 참조하십시오 .

설명

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

형식으로 출력합니다 9 6.

CJam, 92 83 81 바이트

이것은 내가 생각했던 것보다 길어졌습니다 ...

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

여기에서 시도하십시오.

설명 (나는 이것을 설명합니까? : 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")