15

कैदी की दुविधा अभ्यास के एक दौर में , दो खिलाड़ी यह तय करते हैं कि उस दौर के लिए सहयोग करना है या दोष । एक दौर के लिए स्कोरिंग है:

प्लेयर ए और प्लेयर बी दोनों सहयोग करते हैं: दोनों के लिए 1 अंक
प्लेयर ए और प्लेयर बी दोनों दोष: दोनों के लिए 2 अंक
प्लेयर A कोऑपरेट करता है और प्लेयर B को दोष देता है: प्लेयर A को सहयोग करने के लिए 3 अंक और प्लेयर B को ख़राब करने के लिए 0 अंक

आपको रणनीति के बारे में चिंता करने की आवश्यकता नहीं है, हालांकि: आपका कार्यक्रम केवल गेम के लिए स्कोर को सारणीबद्ध करेगा। (यदि आप पहले से ही कैदी की दुविधा से परिचित हैं, तो मेरे "बिंदु" यहां "जेल में वर्षों" के अनुरूप हैं।)

आपकी चुनौती इनपुट लेने की है जो कई राउंड में खिलाड़ियों की पसंद का प्रतिनिधित्व करती है और उनके संबंधित कुल अंकों की गणना करती है। एक खिलाड़ी लोअरकेस में विकल्प प्रस्तुत करता है, 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

code-golf

— apsillers
स्रोत

न तो वे सामान्य रूप से सहयोग के लिए 2 अंक प्राप्त करते हैं और यदि दोनों दोष हो तो 1 अंक खो देते हैं?

— यूमेल

1

@Eumel मैंने केवल विकिपीडिया परिचय के चश्मे की नकल की, जो मूल लेखकों द्वारा सुझाए गए सूत्रीकरण का उपयोग करता प्रतीत होता है। यह भी ध्यान दें कि यहां बिंदु "खराब" हैं क्योंकि वे जेल में वर्षों के अनुरूप हैं। विजेता सबसे कम अंकों वाला खिलाड़ी है ।

— अप्सिलर्स

है (0,0)या [0,0]उत्पादन के लिए ठीक है?

— एक्सनोर

3

पायथ, 23 बाइट्स

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

परीक्षण सूट

स्पष्टीकरण:

@Gz: छोटे अक्षर

-zG: बड़ी वर्तनी के अक्षर

C,: जोड़ी, शेष को छोटा करें।

`: जोड़े की सूची का स्ट्रिंग प्रतिनिधित्व लें

/L ... "cDDCdd: प्रत्येक अक्षर के लिए "cDDCdd", यह गणना करें कि उपरोक्त स्ट्रिंग रीप्र में कितने समय में दिखाई देता है।

c2: परिणामी सूची को आधे में काटें।

sM: प्रत्येक आधा जोड़ें।

j: Newlines और प्रिंट पर शामिल हों।

`का उपयोग मामले की जगह करने के लिए किया जाना चाहिए जहाँ एक पक्ष कभी काम नहीं करता है।

— isaacg
स्रोत

5

हास्केल, 139 134 बाइट्स

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 बाइट बचाने में मदद की। धन्यवाद!

— nimi
स्रोत

4

लैब व्यू, 77 बाइट्स

कोड टोकन से स्कैन करता है और उन बिंदुओं को तय करने के लिए उन संकेतों का उपयोग करता है जहां बिंदु जाते हैं।

गिनती इस तरह से होती है

— Eumel
स्रोत

3

अजगर 3, 110

सहेजे गए 5 बाइट्स FryAmTheEggman की बदौलत।
सहेजे गए 7 बाइट्स अप्सिलर्स के लिए धन्यवाद।
सहेजे गए 26 बाइट्स 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)

मुझे लगता है कि यह अंत में सभी बाहर गोल्फ है।

यह इनपुट में प्रत्येक वर्ण के माध्यम से स्कैन करता है और इसे अपरकेस या नहीं होने के आधार पर क्रमबद्ध करता है। यह तब कुछ फैंसी गणित करता है जो पायथन को चूतड़ के अंडों के अंतर्निहित रूपांतरण का दुरुपयोग करता है।

— मॉर्गन थ्रैप
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

सहेजा गया 6 बाइट्स user81655 के लिए धन्यवाद ।

— intrepidcoder
स्रोत

मेरे पास मूल रूप से सरणी समझ थी, लेकिन एक अलग विधि का उपयोग करके समाप्त हो गई। धन्यवाद।

— intrepidcoder

1

Par , 49 बाइट्स

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

प्रति चरित्र एक बाइट का उपयोग किया जाता है। यहाँ देखें ।

व्याख्या

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

— Ypnypn
स्रोत

किसी ऐसे व्यक्ति के रूप में जिसने कभी Par का उपयोग नहीं किया है (या सुना है), मुझे आपका स्पष्टीकरण पढ़ने में खुशी मिली। धन्यवाद!

— अप्सिलर्स

1

सीजेम, 92 83 81 बाइट्स

यह जितना मैंने सोचा था कि इससे अधिक समय तक समाप्त हो गया ...

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

इसे यहाँ आज़माएँ।

स्पष्टीकरण (हिम्मत मैं यह समझाता हूं ?: ओ):

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")

— geokavel
स्रोत

एक अतुल्यकालिक कैदी की दुविधा का गेम स्कोर करें