वृद्धिशील सट्टेबाजी

19

कई महीने पहले मैंने एक साक्षात्कार के लिए एक प्री-स्क्रीनिंग पहेली के रूप में यह सवाल किया था। हाल ही में जब ब्लॉग सामग्री के बारे में सोचते हैं, तो यह मेरे सिर में एक समस्या को कार्यात्मक रूप से हल करने के लिए उपयोग करने के लिए एक अच्छा उदाहरण है। जैसे ही मैं अपना ब्लॉग पोस्ट लिखूंगा, मैं अपना समाधान इसके लिए पोस्ट कर दूंगा।

नोट: यह सवाल एक साल पहले स्टैकऑवरफ्लो पर पूछा गया था , और कुछ (गलत) जवाबों के बाद अस्वीकृत कर दिया गया था। मुझे लगता है कि यह एक स्पष्ट साक्षात्कार या होमवर्क प्रश्न होने के लिए नीचा दिखाया गया था। हमारे जवाबों को किसी के बारे में सोचने के लिए नहीं, किसी के लिए काफी गहरी कोडित होनी चाहिए!

एक दौड़ में, आप निम्नलिखित रणनीति का उपयोग करके शर्त लगाते हैं। जब भी आप एक शर्त हारते हैं, तो आप अगले दौर के लिए दांव का मूल्य दोगुना कर देते हैं। जब भी आप जीतते हैं, तो अगले दौर के लिए दांव एक डॉलर होगा। आप एक डॉलर की शर्त लगाकर दौर शुरू करते हैं।

उदाहरण के लिए, यदि आप 20 डॉलर से शुरू करते हैं, और आप पहले राउंड में शर्त जीतते हैं, तो अगले दो राउंड में शर्त हार जाते हैं और फिर चौथे राउंड में शर्त जीतते हैं, आप 20 + 1-1-2 से हार जाएंगे +4 = 22 डॉलर।

आपको फ़ंक्शन पूरा करने की उम्मीद है g, जिसमें दो तर्क दिए गए हैं:

  1. पहला तर्क एक पूर्णांक है aजो प्रारंभिक राशि है जो हमारे पास है जब हम सट्टेबाजी शुरू करते हैं।
  2. दूसरा तर्क एक स्ट्रिंग है r। परिणाम का ith चरित्र या तो 'W ’(जीत) या (L’ (हार) होगा, जो ith दौर के परिणाम को दर्शाता है।

आपका कार्य सभी राउंड खेले जाने के बाद आपके पास मौजूद राशि को लौटाना चाहिए।

यदि किसी बिंदु पर आपके पास शर्त के मूल्य को कवर करने के लिए आपके खाते में पर्याप्त पैसा नहीं है, तो आपको उस बिंदु पर रोकना और वापस करना होगा।

नमूना चला

1st round - Loss: 15-1 = 14
2nd round - Loss: 14-2 = 12 (Bet doubles)
3rd round - Loss: 12-4 = 8
4th round - Win: 8 + 8 = 16
5th round - Loss:16-1 = 15 (Since the previous bet was a win, this bet has a value of 1 dollar)
6th round - Loss: 15-2 = 13
7th round - Loss: 13-4 = 9
8th round - Loss: 9-8 = 1

1इस मामले में फ़ंक्शन वापस आता है

विजेता निहित फ़ंक्शन परिभाषा की कम से कम संख्या के अनुसार निर्धारित होता है। यदि वांछित है तो भाषा द्वारा सहयोग करें। मुझे पता है कि मेरा सुधार किया जा सकता है!

code-golf  function 
— TheSoftwareJedi
स्रोत
इस साइट पर सभी सवालों का एक उद्देश्य जीत मानदंड होना चाहिए । आपने उल्लेख नहीं किया कि चुनौती का विजेता क्या निर्धारित करता है।
— हावर्ड
1
इसके अलावा, आप कहते हैं कि आपके कार्य को उन सभी राउंड को वापस करना चाहिए जो आपके सभी राउंड खेले जाने के बाद होंगे। यद्यपि आप अपेक्षित आउटपुट अनुभाग में बहुत अधिक विस्तृत जानकारी दिखाते हैं । फ़ंक्शन का वांछित व्यवहार कौन सा है?
— हावर्ड
इसके अलावा, यदि आपके द्वारा उपयोग किया जा रहा प्रत्येक टैग वह है जिसे आपने केवल प्रश्न के लिए बनाया है, तो कुछ गलत है।
— जस्टिन
1
"हमारे जवाबों को देखते हुए, कोड को इतना गहरा होना चाहिए कि किसी को उनका उपयोग करने के बारे में न सोचना पड़े!", मुझे लगता है कि आप [कोड-गोल्फ] चाहते थे, इसलिए मैंने इसे इस तरह टैग किया। इसके अलावा, मैंने "उदाहरण के लिए आउटपुट" को "नमूना रन" होने के लिए बेहतर मिलान के लिए समायोजित किया जो आपको लगता है कि आप चाहते हैं।
— जस्टिन
@quincunx क्षमा करें, मैंने कभी यहां पोस्ट नहीं किया है, लेकिन दिलचस्प रूप से कई मूल प्रश्न पोस्ट किए हैं जो यहां बनाया गया था। एक तरह से, मैं उन कारणों में से एक हूं जो इस स्टैकएक्सचेंज को बनाया गया था। मैंने सोचा कि यह सब कोड गोल्फ था, और मेरे लैपटॉप की बैटरी मर रही थी इसलिए मैं खत्म करने की जल्दी में था। माफ़ करना। लम्बी रात।
— theSoftwareJedi

जवाबों:

5

GolfScript, 33 अक्षर

{
1\{2$2$<!{1&{+1}{:b-b.+}if.}*;}/;
}:g;

उदाहरण ( ऑनलाइन ):

> 13 'LLLWLLLL'
6
> 4 'LWWLWLWWWL'
9
> 5 'LLLWWWLLWLWW'
2
> 2 'LW'
1

एनोटेट कोड:

1\            # prepare stack a b r
{             # for each char in r
  2$2$<!{     #   if a>=b  
    1&        #     take last bit of character (i.e. 0 for L and 1 for W)
    {         #     if W
      +       #       a <- a+b
      1       #       b <- 1
    }{        #     else
      :b-     #       a <- a-b
      b.+     #       b <- 2*b
    }if       #     end if
    .         #     create dummy value
  }*          #   end if
  ;           #   drop (i.e. either the dummy or the character)
}/            # end for
;             # discard current bet value
— हावर्ड
स्रोत
5

पायथन 2, 72 68 62 बाइट्स

def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

यह इतना की तरह कॉल करें: g(15,'LLLWLLLL')।

यह बस स्ट्रिंग के माध्यम से लूप करता है, जो हमारे पास चरित्र के आधार पर पैसे का मूल्य बदल रहा है।

यहाँ एक नमूना कार्यक्रम है जो इस फ़ंक्शन पर परीक्षण चलाता है:

import random
def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

for i in range(14):
    s=''.join(('L','W')[random.randint(0, 1)] for e in range(random.randint(10, 15)))
    print'g(%i,%s):'%(i,`s`),
    print g(i,s)

नमूना उत्पादन:

g(0,'LLWWWWWWLWWWWW'): 0
g(1,'WLLWWWWWWWW'): 1
g(2,'WWWLLLWLLW'): 2
g(3,'LLLLWLWLWWWWLL'): 0
g(4,'LWWWWLWLWWW'): 12
g(5,'WWLWWLLWWW'): 12
g(6,'LLLWWWLLLLWLLWL'): 3
g(7,'WWLLWWLWLWLWLLL'): 7
g(8,'WLLLWWWWWLLWLL'): 2
g(9,'WWWLLWLLLLLWL'): 6
g(10,'LWWWWLLLWL'): 7
g(11,'WLLLLWLWWWW'): 5
g(12,'WLLWWLWWWL'): 17
g(13,'LLLWLLWLWLWLWW'): 6

परीक्षक में थोड़े बदलाव के साथ, हम कई रनों का औसत लाभ प्राप्त कर सकते हैं:

import random
def g(a,s,n=1):
 for c in s:
    if a>=n:a,n=((a+n,1),(a-n,2*n))[c<'W']
 return a

r=[]
for i in range(5000):
    for i in range(1000):
        s=''.join(('L','W')[random.randint(0, 1)] for e in range(random.randint(10, 15)))
        r+=[i-g(i,s)]
a=0
for n in r:
    a+=n
print float(a)/len(r)

नमूना उत्पादन (काफी समय लग गया, क्योंकि हम फ़ंक्शन 5000000समय को बुला रहे हैं ):

-0.0156148

संपादित करें: आगे गोल्फ के लिए हावर्ड और डैनी को धन्यवाद।

EDIT: अब इस कार्यक्रम की जाँच करता है कि क्या शर्त लगाने के लिए पर्याप्त धन है या नहीं। यह वास्तव में बाइट्स बचाता है।

— जस्टिन
स्रोत
कुछ मामूली बचत: आप के c=='L'साथ बदल सकते हैं c<'W'=। आप यह भी लिख सकते हैं b,n=((n,1),(-n,2*n))[c<'W']कि तब आपको और अधिक वर्ण ( if a<-b:break, a+=b) बचाता है ।
— हावर्ड
@ हावर्ड हम्म। मैंने b,n=चाल की कोशिश की ( [बाहर पर s के साथ ), लेकिन अजगर ने शिकायत की। चलो फिर से कोशिश करें।
— जस्टिन
अजीब, यहाँ एक नज़र है ।
— हॉवर्ड
1
if n<=aजब तक आपके पास नहीं होगा तब तक आप कुछ चर नहीं बचा पाएंगे break?
— डेनी
1
@Quincinx: नहीं, <का मतलब है इससे कम। स्ट्रिंग्स को शाब्दिक रूप से आदेश दिया जाता है, इसलिए 'L' <'W' सही है, जो 1 के रूप में व्याख्या की गई है, जबकि 'W' <'W' गलत है, जो कि 0.
— isaacg
4

आर, 95 वर्ण

g=function(a,r){n=1;for(i in 1:nchar(r)){s=substr(r,i,i);if(s=='L'){a=a-n;n=n*2}else{a=a+n;n=1};if(n>a)break};a}

इंडेंट:

g=function(a,r){
    n=1
    for(i in 1:nchar(r)){
        s=substr(r,i,i)
        if(s=='L'){
            a=a-n
            n=n*2
            }else{
                a=a+n
                n=1
                }
        if(n>a)break
        }
    a
    }

उपयोग:

> g(15,'LLWLLLL')
[1] 1
> g(20,'WLLW')
[1] 22
> g(13,'LLWLLLLWWLWWWLWLWW')
[1] 7
— plannapus
स्रोत
3

जे - ६३ ५५ चार

अब गलत नहीं होने के अतिरिक्त बोनस के साथ! यह भी पहले जैसा ही है।

((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L')

पैसे की शुरुआती राशि को बाएं तर्क के रूप में लेता है और दाईं ओर जीत / हानि की लकीर।

स्पष्टीकरण: कार्यक्रम समान रूप से दो कार्यों की संरचना की तरह कुछ में विभाजित करता है, दोनों नीचे विस्तृत हैं। पहले बाजी के मूल्यों में जीत / हानि की लकीर को बदल देता है, इसी संकेत के साथ, और फिर दूसरा वास्तव में प्रारंभिक धन दिए गए उत्तर का पता लगाता है और इसने जीत / हानि लकीर को बदल दिया।

;@('W'<@(2^i.@#);.1@,}:)*_1^=&'L'   NB. win/loss as sole argument
                         _1^=&'L'   NB. -1 for every L, +1 for W
      <@(      );.1                 NB. split vector into streaks:
   'W'              ,}:             NB.  cut on wins, shift right by 1
         2^i.@#                     NB. for each, make doubling run
;@(                    )*           NB. unsplit, multiply by signs

(+/\@,(0{<#[)_,~|@])   NB. money on left, above result on right
                |@]    NB. absolute value of bets 
             _,~       NB. append infinity to end
 +/\@,                 NB. partial sums with initial money
      (  <  )          NB. 1 whenever money in account < bet
          #[           NB. select those money values corresp. to 1s
       0{              NB. take first such item

ध्यान दें कि हम आंशिक रकम लेने से पहले पैसे को दांव पर लगाते हैं, लेकिन हम शर्त मानों की सूची के अंत में अनंत दांव लगाते हैं। यह वह है जो अगली शर्त के खाते के मूल्य को बदल देता है, और अनंत का उपयोग करके हमें हमेशा अंतिम तत्व को कैच-ऑल के रूप में रखने की अनुमति देता है।

उपयोग:

   15 ((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L') 'LLLWLLLL'
1
   NB. naming for convenience
   f =: ((+/\@,(0{<#[)_,~|@]);@('W'<@(2^i.@#);.1@,}:)*_1^=&'L')
   20 f 'WLLW'
22
   2 f 'LW'
1
   13 f 'LLWLLLLWWLWWWLWLWW'
7
   12 13 14 15 28 29 30 31 (f"0 _) 'LLWLLLLWWLWWWLWLWW'  NB. for each left argument
6 7 0 1 14 15 39 40
— algorithmshark
स्रोत
2
मैंने आपके कोड का परीक्षण किया और यह परीक्षण मामले के लिए 3 भी लौटाता है 2 LW। दुर्भाग्य से पहले नुकसान के बाद आपके पास दूसरे रन के लिए शर्त लगाने के लिए पर्याप्त पैसा नहीं है।
— हावर्ड
इसके साथ 14 f 'LLWLLLLWWLWWWLWLWW', हमें यह क्रम मिलता है: 14, 13, 11, 15, 14, 12, 8, 0,..इस समय 0, हमारे पास बोली लगाने के लिए पर्याप्त धन नहीं है, इसलिए कार्यक्रम को आउटपुट देना चाहिए 0।
— जस्टिन
क्या यह कोड अभी सही है? मुझे एक विजेता को नामित करने की आवश्यकता है और जे कंपाइलर (न ही अनुभव शुरू करने का समय) है।
— theSoftwareJedi
@ TheSoftwareJedi हाँ, यह सही है। अब वास्तव में J दुभाषिया का एक ऑनलाइन जावास्क्रिप्ट संस्करण है, जिसे आप tryj.tk पर आज़मा सकते हैं ।
— एल्गोरिथमशार्क
अब दुविधा, गोल्फ की गिनती करता है ?!
— TheSoftwareJedi
3

जावास्क्रिप्ट (ECMAScript 6 ड्राफ्ट) - 62 51 50 वर्ण (फ़ंक्शन बॉडी में)

function g(a,r,t=0,b=1)
a>=b&&(c=r[t])?g((c=c>'L')?a+b:a-b,r,t+1,c||2*b):a

gदो तर्कों के साथ एक पुनरावर्ती कार्य को परिभाषित करता है :

  • a- आपके पास वर्तमान धनराशि; तथा
  • r - जीत / हार की स्ट्रिंग।

और दो वैकल्पिक तर्क:

  • t- सट्टेबाजी के वर्तमान दौर का सूचकांक (शुरू में 0)
  • b- वर्तमान दांव के लिए धन की राशि (फिर से शुरू में 1)।

Ungolfed:

function g(a,r,t=0,b=1){      // declare a function g with arguments a,r,t,b where
                              // t defaults to 0 and b defaults to 1
c = r[t];                     // get the character in the win/loss string for the current
                              // round.
if (   a>=b                   // check if we have enough money
    && c )                    // and if the string has not ended
{
  if ( c > 'L' )              // check if we've won the round
  {
    return g(a+b,r,t+1,1);    // if so call g again adding the winnings and resetting the
                              // cost.
  } else {
    return g(a-b,r,t+1,2*b);  // otherwise, subtract from the total money and double the
                              // cost.
  }
} else {
  return a;                   // If we've run out of money or got to the end then return
                              // the current total.
}}

जावास्क्रिप्ट (ECMAScript 6) - 61 58 54 वर्ण (फ़ंक्शन बॉडी में)

function g(a,r)
(b=1,[b=b>a?b:x>'L'?(a+=b,1):(a-=b,b*2)for(x of r)],a)

स्पष्टीकरण:

(b=1,                        // Initialise the cost to 1
 [                           // for each character x of r using array comprehension
     b=
       b>a?b                 // if we have run out of money do b=b
       :x>'L'?(a+=b,1)       // else if we've won collect the winnings and reset b=1
             :(a-=b,2*b)     // else subtract the cost from the total money and double
                             // the cost for next round.
  for(x of r)]               // Repeat for each character
                             // array.
,a)                          // Finally, return a.

टेस्ट

console.log(g(0,'LLLLLWWLWWLW')) // 0
console.log(g(1,'WWWLLLWWWWLLWW')) //1
console.log(g(2,'LLWLWWWWWWWL')) //1
console.log(g(3,'WWWWWWWLLLWL')) //3
console.log(g(4,'LWWLWLWWWL')) //9
console.log(g(5,'LLLWWWLLWLWW')) //2
console.log(g(6,'LWLLLLWWLWWW')) //0
console.log(g(7,'WWLWWLLLWLWLW')) //4
console.log(g(8,'WWLWWLLWLWL')) //13
console.log(g(9,'WWWLLLWLLWLWWW')) //5
console.log(g(10,'WLWLLWWWWWWWL')) //18
console.log(g(11,'WLWLWLWLLLWLLW')) //17
console.log(g(12,'WWLWWWLLWL')) //17
console.log(g(13,'WWWWLWLWWW')) //21
console.log(g(15,'LLLW')) //16
console.log(g(15,'LLLL')) //0
console.log(g(14,'LLLL')) //7
console.log(g(2,'LW')) //1
console.log(g(2,'LL')) //1
console.log(g(2,'WLL')) //0
— MT0
स्रोत
आप 3 बाइट्स बदलते बचा सकते हैं b=1,r.split('').map(करने के लिए[b=1].map.call(r,
— nderscore
धन्यवाद, मैं स्ट्रिंग को सीधे उस तरह से हेरफेर करने पर विचार नहीं करेगा।
— MT0
सरणी (b=1,[b=b>a?b:x>'L'?(a+=b,1):(a-=b,b*2)for(x of r)],a)
— बोध
-1 बाइट:a>=b&&(c=r[t])?g((c=c>'L')?a+b:a-b,r,t+1,c||2*b):a
— अंडरस्कोर
1

पायथन, 74 बाइट्स

def g(a,r,b=1):
 for l in r:
  if l>"L":a+=b;b=1
  else:a-=b;b*=2
 return a

मैंने फ़ंक्शन जी को परिभाषित किया है जो आपके पास (शुरू में आपके पास जितना पैसा है) और आर (जो कि दांव के परिणाम हैं) यह पहली शर्त की राशि को 1 पर शुरू करता है। फिर दांव के प्रत्येक परिणाम के लिए, यदि यह है एक जीत (आर में "डब्ल्यू") आप पैसा हासिल करते हैं और शर्त 1 पर वापस आ जाती है। आप दांव की राशि खो देते हैं, और अगले दांव के लिए राशि दोगुनी हो जाती है। अंत में यह आपके पास मौजूद पैसे लौटाता है। आप इसे इस तरह से उपयोग कर सकते हैं:

print g(20,"WLLW") # 22
print g(15,"LLLWLLLL") # 1

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

— Guestar
स्रोत
यह मूल रूप से codegolf.stackexchange.com/a/26238/9498 का डुप्लिकेट है ।
— जस्टिन
1

सी, 107 वर्ण

f(int a,char*r,int n){return*r&&n<a?*r<77?f(a-n,r+1,n*2):f(a+n,r+1,1):a;}g(int a, char*r){return f(a,r,1);}

मैं यहां एक पुनरावर्ती फ़ंक्शन का उपयोग कर रहा हूं, क्योंकि अधिकांश समय कार्यान्वयन कम होता है। लेकिन मुझे यकीन नहीं है कि अगर यह मामला है, क्योंकि मुझे एक अतिरिक्त आवरण समारोह बनाने की आवश्यकता है, इसलिए मेरा कार्य वास्तव में केवल कुछ तर्क देता है। फ़ंक्शन में तीसरा तर्क fवर्तमान शर्त (संचायक) के लिए आवश्यक है।

रैपर फ़ंक्शन के बिना यह समाधान केवल 73 वर्ण लंबा होगा, लेकिन आपको उचित परिणाम प्राप्त करने के लिए मूल्य 1 (जन्मजात शर्त) के साथ एक अतिरिक्त पैरामीटर पास करना होगा।

ungolfed:

f(int a,char*r,int n){
    return *r&&n<a
                ?*r<77
                    ?f(a-n,r+1,n*2)
                    :f(a+n,r+1,1)
                :a;
}
g(int a,char*r){
    return f(a,r,1);
}
— MarcDefiant
स्रोत
1

जावास्क्रिप्ट, 63

function g(a,s){x=1;for(i in s)if(x<=a)s[i]>'L'?(a+=x,x=1):(a-=x,x*=2);return a}

नमूना चलता है:

console.log(g(15, 'LLLWLLLL'));  //1
console.log(g(20, 'WLLW'));  //22
console.log(g(13, 'LLWLLLLWWLWWWLWLWW')); //7

जेएसफल्ड डब्ल्यू / लॉगिंग

Ungolfed:

function g(a,s){
  x=1;                //bet starts at 1
  for(i in s)         //loop through win/lose string
    if(x<=a)          //check if we still have money to bet
      s[i]>'L'?
        (a+=x,x=1):   //win: add the bet amount to your total, and reset bet to 1
        (a-=x,x*=2);  //lose: subtract the bet amount from your total, and double your bet
  return a            //return your money
}
— डैनी
स्रोत
1

जावास्क्रिप्ट ( ईएस 5 ) 69 64 60 बाइट्स फ़ंक्शन के भीतर

function g(a,r){b=1;for(i in r)b=b>a?b:r[i]>'L'?(a+=b,1):(a-=b,b*2);return a}

भिन्नता: ( एक ही लंबाई )

function g(a,r,b){for(i in r)b=b?b>a?b:r[i]>'L'?(a+=b,1):(a-=b,b*2):1;return a}

परीक्षण के मामले: ( प्लेनैपस के समाधान से लिया गया )

g(15,'LLWLLLL'); // 1
g(20,'WLLW'); // 22
g(13,'LLWLLLLWWLWWWLWLWW'); // 7
— nderscore
स्रोत
g(20,'WLLW')मेरे फायरफॉक्स कंसोल में 25 रिटर्न देता है - for...inलूप स्ट्रिंग में तीन अतिरिक्त गुणों को उठाता है और साथ ही उन पर पुनरावृत्त करता है।
— MT0
@ MT0 एक ही बात मेरे फ़ायरफ़ॉक्स कंसोल में होती है। हालाँकि अगर मैं एक नई निजी ब्राउज़िंग विंडो खोलता हूँ जो मुझे 22मेरे कंसोल में मिलती है। शायद यह सोचकर कि आपके पास सांत्वना खुले होने पर कुछ साइट Stringप्रोटोटाइप को संशोधित करती है । मुझे पता है कि स्टेक्सएक्सचेंज इसे संशोधित करता है और तीन अतिरिक्त फ़ंक्शन जोड़ता है।
— डैनी
किसी कारण से, यह एक नए टैब के साथ नहीं होता है: i.imgur.com/BgSUSIe.png
— nderscore
1

हास्केल, 62

g a=fst.foldl(\(t,b)l->if l=='W'then(t+b,1)else(t-b,2*t))(a,1)

या दोनों तर्कों के साथ नाम (65 वर्ण):

g a r=fst$foldl(\(t,b)l->if l=='W'then(t+b,1)else(t-b,2*t))(a,1)r

ध्यान दें कि g a r = 1 + a + the number of Ws in r + the number of trailing Ls in r(69):

g a r=a+1+l(filter(=='W')r)-2^l(takeWhile(/='W')(reverse r))
l=length
— ज़ाक़
स्रोत
यह केवल एक आंशिक समाधान है। जब खिलाड़ी पैसे से भागता है तो यह मामले को कवर नहीं करता है।
— पेट्र पुडलक
इस समस्या के बहुत सारे समाधान हैं जो दांव लगाने वाले को नकारात्मक में रहने की अनुमति देते हैं। समस्या ने कभी नहीं कहा कि आपको यह जांचना था कि क्या यह मामला था।
— ज़ैक
@zaq वास्तव में, प्रश्न स्पष्ट रूप से कहा गया था कि मामला था।
— TheSoftwareJedi
1

पायथन 2 - 65 बाइट्स

अब सबसे अच्छा पायथन समाधान द्वारा पीटा जाता है, लेकिन मैं इसे साझा नहीं कर सकता:

def g(r,a,b=1):
    if r>"">a>=b:a=g(r[1:],*[(a+b,1),(a-b,b*2)][r[0]<"W"])
    return a

कुछ अन्य पायथन समाधानों के रूप में, मैं घोषित करने के लिए फ़ंक्शन तर्कों का उपयोग करता हूं b फ़ंक्शन परिभाषा के बाहर , लेकिन जैसा कि फ़ंक्शन पुनरावर्ती है, यह वास्तव में यहां गोल्फिंग के अलावा कुछ उद्देश्य प्रदान करता है।

मुझे फ़ंक्शन तर्कों को फ़ंक्शन तर्क में अनपैक करने के लिए फ़ंक्शन तर्क के क्रम को बदलने की भी आवश्यकता थी ।

मामले में आप आश्चर्य करते हैं, के r>"">a>=bलिए कम है r and a>=b।

— Wrzlprmft
स्रोत
1

रूबी, 76 64 (फंक्शन बॉडी में) बाइट्स

EDIT: 3 बाइट्स हटाकर जवाब में सुधार:

n=1;r.each_char{|c|;c>'L'?(a+=n;n=1):(a-=n;n*=2);break if n>a};a


फंक का उपयोग करना (82 बाइट्स): 

def g(a,r);n=1;r.each_char{|c|;c>'L'?(a,n=a+n,1):(a,n=a-n,n*2);break if n>a};a;end

लैम्ब्डा (76 बाइट्स) का उपयोग करना:

g=->a,r{n=1;r.each_char{|c|;c>'L'?(a,n=a+n,1):(a,n=a-n,n*2);break if n>a};a}

दौड़ :

p g.call(15, 'LLLWLLLL') # 1
p g.call(20, 'WLLW') # 22
p g.call(13, 'LLWLLLLWWLWWWLWLWW') # 7
— onionpsy
स्रोत
1

विधि के अंदर C #, 74 वर्ण

इस साइट पर मेरा पहला प्रयास ...

int b=1;foreach(var c in r)if(b<=a){a+=c>'L'?b:-b;b=c>'L'?1:b*2;}return a;

या, अधिक पठनीय:

int bet = 1;
foreach (var chr in r)
{                       // these brackets are left out in short version
   if (bet <= a)
   {
       a += chr > 'L' ? bet : -bet;
       bet = chr > 'L' ? 1 : bet * 2;
   }
}
return a;

बहुत भोली, बहुत सारी तरकीबें नहीं ... मुख्य रूप से चारित्रिक होने का फायदा उठाते हुए और स्ट्रिंग को ऊर्जावान होने के नाते। जब खिलाड़ी पैसे से बाहर निकलता है तो बाहरी लूपिंग द्वारा कुछ पात्रों को सहेजना।

— JimmiTh
स्रोत
1

गोल्फस्क्रिप्ट, 51 41 36 35 बाइट्स

आंतरिक कार्य

1\{@2$-@2*@(1&{@@+1@}*.3$3$<!*}do;;

यह मानता है कि हम एक सकारात्मक राशि के साथ शुरू करते हैं और जीत-हार स्ट्रिंग गैर-खाली होगी, ताकि कम से कम एक शर्त का प्रदर्शन किया जा सके।

उदाहरण

{
  # Push initial bet amount.
  1\
  # STACK: Money Bet Outcomes
  {
    # Subtract bet amount from money.
    @2$-
    # STACK: Bet Outcomes Money
    # Double bet amount.
    @2*
    # STACK: Outcomes Money Bet
    # Remove first character from win-loss string and check if its ASCII code is odd.
    @(1&
    # STACK: Money Bet Outcomes Boolean
    # If it is, we've won, so add the doubled bet amount to the money and push 1 as the
    # new bet amont.
    {@@+1@}*
    # STACK: Money Bet Outcomes
    # Duplicate win-loss string, bet amonut and money.
    .3$3$
    # STACK: Money Bet Outcomes Outcomes Bet Money
    # If the next bet amount is less than our money and the win-loss string is not empty,
    # repeat the loop.
    <!*
    # STACK: Money Bet Outcomes Boolean
  }do
  # STACK: Money Bet Outcomes
  ;;
  # STACK: Money
}:f                                      # Define function.

];                                       # Clear stack.

20 'WLLW'               f
2  'LW'                 f
13 'LLWLLLLWWLWWWLWLWW' f
14 'LLWLLLLWWLWWWLWLWW' f

]p                                       # Print results as array.

देता है

[22 1 7 0]

इसे ऑनलाइन आज़माएं।

— डेनिस
स्रोत
1

सी #, 123

return q.Aggregate(new{b=1,c=w,x=1},(l,o)=>l.x<0?l:o=='W'?new{b=1,c=l.c+l.b,x=1}:new{b=l.b*2,c=l.c-l.b,x=l.c-l.b-l.b*2}).c;

.NET फेल्ड

एक ब्लॉग पोस्ट की व्याख्या

— TheSoftwareJedi
स्रोत
कोड के साथ केवल उन दो लिंक को पोस्ट करने के बजाय, स्पष्टीकरण यहां लाएं।
— जस्टिन
मैं आदमी से प्यार करता हूँ, और AM में संपादित करूँगा। यह जल्दबाज़ी थी और खत्म होने का समय था। मैं एसओ पर थोड़ी देर में सक्रिय नहीं हुआ, मेरे साथ सहन करें क्योंकि मैं स्वीकार करता हूं कि यह अभी शैशवावस्था में नहीं है। :)
— TheSoftwareJedi
आपके .NET Fiddle के अनुसार, आप अपने तर्कों को पीछे की ओर ले जा रहे हैं। क्या यह अनुमति है?
— जस्टिन
मैंने प्रश्न में समाधान के लिए फ़ंक्शन की परिभाषा को अप्रासंगिक बना दिया है। फिडेल जवाब का हिस्सा नहीं है, बस इसे निष्पादित करने का एक तरीका है।
— theSoftwareJedi
0

रूबी, 84 वर्ण

def g(a,r,n=1)
return a if !r[0]||n>a
s=r[1..-1]
r[0]<?M?g(a-n,s,n*2):g(a+n,s,1)
end

सी में मेरे अन्य उत्तर के रूप में समान दृष्टिकोण, लेकिन मैं कोड-गोल्फिंग के लिए रूबी की कोशिश करना चाहता था। C संस्करण का लाभ यह है कि मुझे एक आवरण फ़ंक्शन बनाने की आवश्यकता नहीं है, मैं बस मापदंडों के लिए डिफ़ॉल्ट मानों का उपयोग कर सकता हूं।

— मार्कडेफिएंट
स्रोत
0

के, 76६

g:{x+/-1_last'{(,1_*x),(("LW"!/:((2*;{1});(-:;::)))@\:**x)@\:x 1}\[(y;1;0)]}

।

k)g[15;"LLLWLLLL"]
1
k)g[20;"WLLW"]
22
k)g[50;"WLLLWLWLWLWLW"]
56
— tmartin
स्रोत
0

अजगर, 86

def y(a,s):
 for l in s.split('W'):
    a+=1;k=2**len(l)
    if k>a:return int(bin(a)[3:],2)
 return a-k

मुझे पता है कि यह सबसे छोटे समाधान के पास कहीं नहीं है, लेकिन मैं एक अलग दृष्टिकोण प्रदर्शित करना चाहता था, जो कि व्यक्तिगत दांव के बजाय नुकसान की लकीरों पर निर्भर करता है। int(bin(a)[3:],2)aहटाए गए द्विआधारी प्रतिनिधित्व से सबसे महत्वपूर्ण बिट के साथ पूर्णांक देता है, जो कि 2 की बढ़ती शक्तियों को खोने के बाद व्यक्ति के पास कितनी राशि होगी, जब तक कि वह अब शर्त नहीं लगा सकता, क्योंकि वर्तमान में उसके या उसके मुकाबले 1 अधिक है पैसे की वास्तविक राशि। यह संस्करण मानता है कि प्रारंभिक पूंजी सकारात्मक है।

— isaacg
स्रोत
0

सी - 64 ५ ९ (इनसाइड फंक्शन)

फिर भी एक और सी जवाब। यह इस तथ्य का लाभ उठाता है कि चर का मूल्य स्टैक पर रहता है। इसलिए यह कुछ कंपाइलरों के साथ मेरी असफलता है, लेकिन जहाँ भी मैंने परीक्षण किया, यह ठीक से काम नहीं कर पाया। इसके अलावा, मैंने %2एक चरित्र को बचाने के लिए टिया से लिया । माफ़ करना!

f(int s,char*r){
    int a=1;
    for(;*r&&(*r++%2?s+=a,a=1:s<a?0:(s-=a,a*=2)););
    a=s;
}
— Allbeert
स्रोत
0

बैच - 212

@echo off&setlocal enabledelayedexpansion&set r=%2&set a=%1&set c=1&powershell "&{'%2'.length-1}">f&set/pl=<f
for /l %%a in (0,1,%l%)do if "!r:~%%a,1!"=="L" (set/aa-=!c!&set/ac*=2) else set/aa+=!c!&set c=1
echo %a%

एक्सप्लोरेशन - 

H:\uprof>bet.bat 15 LLLWLLLL
1
— unclemeat
स्रोत
0

जाप , 38 बाइट्स

V¬r@Z=WX<Z?X:Y¶'L?W=ZÑX-Z:(W=1X+Z}UW=1

कोशिश करो

शायद कुछ गोल्फ की जरूरत है :) लेकिन यह सही परिणाम प्राप्त करने के लिए लगता है।

नोट यह एक पूर्ण प्रोग्राम है जो कि प्रीपेेंडिंग द्वारा फ़ंक्शन में बदलने के लिए तुच्छ हैUV{ । फ़ंक्शन के अंदर बाइट की गिनती समान होगी।

ट्रांसपोंड जेएस समझाया:

// V: input string of W's and L's
V
  // split V into an array of characters
  .q()
  // reduce
  .r(function(X, Y, Z) {
    return
      // W contains the current bet,
      // save it to a temp variable Z
      Z = W,
      // do we have enough to bet?
      X < Z
        // not enough to bet, return the previous amount
        ? X
         // we can bet, did we lose this round
         : Y === "L"
           // we lost, increment bet and decrease holdings
           ? (W = Z * 2, X - Z)
           // we won, reset bet and increase holdings
           : (W = 1, X + Z)
   },
   // U: initial holdings
   U,
   // initialize bet to 1
   W = 1
 )
— दाना
स्रोत
— झबरा
इस प्रश्न की एक अजीब आवश्यकता है कि आपको "फ़ंक्शन" लिखना होगा। मुझे संभवतः अपने उत्तर को किसी फ़ंक्शन में अनुवाद करना चाहिए, लेकिन मैं सोच रहा हूं कि कुछ अतिरिक्त बाइट्स की आवश्यकता है। यह शायद ठीक होगा हालांकि: petershaggynoble.github.io/Japt-Interpreter/…
— dana
0

पॉवरशेल , 68 81 बाइट्स

param($n,$s)$w=1;$s|% t*y|%{if($n-ge$w){$n+=(-$w,$w)[$_%2];$w/=(.5,$w)[$_%2]}};$n

इसे ऑनलाइन आज़माएं!

इस चुनौती को कुछ बहुत ही अजीब असाइनमेंट की जरूरत है जिसका अर्थ है कि मैं एक बड़े अपडेट को एक साथ चेन नहीं कर सकता। यह इस तथ्य का उपयोग करता है कि एएससीआईआई में 'डब्ल्यू' 87 है और 'एल' 76 है तो 2 द्वारा मोडिंग करना आपको आसान सच्चे / झूठे मूल्यों तक पहुंच प्रदान करता है।|% t*yमानक हैचाराअरे शॉर्टकट और विभाजन का उपयोग करते हुए दांव को अद्यतन करना सबसे सस्ता तरीका है जो मुझे मिल सकता है (इसे या तो एक आधे पर नुकसान से विभाजित करता है (इसे दोगुना करता है), या इसे एक जीत पर खुद से विभाजित करता है (इसे 1 पर सेट करता है) )।

प्लस कई बाइट्स क्योंकि मैं बाधा याद किया। पैच नीचे गोल्फिंग पर काम करेंगे

— Veskah
स्रोत
0

05AB1E , 19 बाइट्स

vDX@iy'WQiX+1UëXxU-

@ हावर्ड के गोल्फस्क्रिप्ट उत्तर का पोर्ट , इसलिए उसे भी बनाए रखना सुनिश्चित करें!

ध्यान दें कि 05AB1E का कोई कार्य नहीं है, इसलिए यह एक पूर्ण कार्यक्रम है।
स्ट्रिंग इनपुट पहले लेता है, और पूर्णांक इनपुट दूसरा (एसटीडीआईएन में सीमांकित नया)।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

v               # Loop over each character `y` of the (implicit) input-string:
 D              #  Duplicate the current integer
                #  (which is the implicit input-integer in the first iteration)
  X@i           #  If the integer is larger than or equal to variable `X`:
                #  (NOTE: variable `X` is 1 by default)
     y'WQi     '#   If the current character `y` is a 'W':
          X+    #    Increase the integer by `X`
          1U    #    And reset variable `X` to 1
         ë      #   Else (the current character `y` is an 'L' instead):
          X  -  #    Decrease the integer by `X`
           xU   #    And set variable `X` to double its current value
                # (the integer at the top of the stack is implicitly output after the loop)
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.