35

एक स्ट्रिंग को देखते हुए, उस स्ट्रिंग के "भाग्य" को वापस करें।

एक स्ट्रिंग का भाग्य, जैसा कि मैंने पूरी तरह से इस चुनौती के उद्देश्य के लिए बनाया है, एक पूर्णांक है, जैसा कि निर्धारित किया गया है:

एक स्ट्रिंग के लिए आधार भाग्य 1 है।
प्रत्येक लगातार पत्र के लिए यह शब्द "भाग्यशाली" (असंवेदनशील) शब्द के साथ साझा करता है, 2. भाग्य को 2 से गुणा करें। उदाहरण के लिए, यदि आपका स्ट्रिंग " लू " या "sma ck " आप 4 से गुणा करेंगे (अधिक विशेष रूप से,) 2 ^ लगातार साझा किए गए पात्रों की संख्या।)
- साझा किए गए अक्षरों को एक ही क्रम में होना चाहिए जो "भाग्यशाली" में दिखाई देता है लेकिन समान मूल्य के लिए शब्द में कहीं भी शुरू हो सकता है ("आकर्षक" में समान 8 * गुणक "cky" है)।
- यदि शब्द में कई घटनाएँ हैं जहाँ यह भाग्यशाली के साथ लगातार वर्ण साझा करता है, तो वर्णों की सबसे लंबी लगातार स्ट्रिंग का उपयोग करें।
किसी भी पत्र के लिए यह शब्द "शगुन" के साथ साझा करता है 2 भाग्य से घटाना।
- यह किसी भी क्रम में किसी भी समय किसी भी पात्र से मेल खा सकता है। उदाहरण के लिए स्ट्रिंग "nnnnnomemenn" 24 भाग्य (12 मिलान पत्र) खो देता है

उदाहरण:

luck("lucky")
>>32

2 ^ 5 (5 लगातार अक्षर) = 32

luck("firetruck")
>>6

2 ^ 3 - 2 (से लगातार 3 पत्र uck , ई शगुन के साथ साझा)

luck("memes")
>>-7

1 - 8 (आधार राशि, 4 "शगुन" के साथ साझा)

यह कोड गोल्फ है, इसलिए सबसे कम बाइट जीतता है।

आप किसी भी तरह से इनपुट और आउटपुट कर सकते हैं - एक फ़ंक्शन लिखें, मानक इनपुट का उपयोग करें, आदि।

फ़ंक्शंस के लिए, मान लें कि जो भी डेटा प्रकार उस भाषा के लिए समझ में आता है। (उदाहरण के लिए, जावास्क्रिप्ट में, आप पास हो जाएंगे Stringऔर वापस आ जाएंगे Number)

संपादित करें: आप मान सकते हैं कि कोई भी इनपुट लोअरकेस है।

code-golf string

— charredgrass
स्रोत

8

अच्छी पहली चुनौती!

— एलेक्स ए।

2

क्या प्रोग्राम को अपरकेस इनपुट स्वीकार करना चाहिए?

— बुसुकुआन 2

2

@busukxuan अच्छा सवाल - नहीं, यह अपरकेस इनपुट स्वीकार करने की आवश्यकता नहीं है।

— सितंबर को

@ मुझे यकीन नहीं है कि आप जो पूछ रहे हैं मैं काफी समझ गया हूं। लेकिन आप बस यह मान सकते हैं कि सभी इनपुट लोअरकेस होंगे और आपको किसी अपरकेस इनपुट को पकड़ने की आवश्यकता नहीं है।

— चार्रेडग्रस

1

क्या हम किसी दिए गए इनपुट के भाग्य पर एक ऊपरी या निम्न बाध्य मान सकते हैं? यानी बिट्स / डेटा प्रकार की सबसे छोटी संख्या मैं किससे दूर हो सकता हूं, या क्या यह उतना बड़ा है जितना मेरी भाषा संभाल सकती है? यह है, यह होना int8_t str_luck(const char* str);चाहिए या यह होना चाहिए uint64_t str_luck(const char* str);?

— बिल्ली

7

05AB1E , 36 32 28 26 बाइट्स

Œv'¸éyåiyˆ}}¯é¤go¹'ƒÖ¦Ãg·-

व्याख्या

Œv         }                  # for each substring of input
  '¸éyåi  }                   # if substring is part of "lucky"
        yˆ                    # add it to global array
            ¯é¤               # get the longest such substring
               go             # raise 2 to its length
                 ¹'ƒÖ¦Ã       # remove all chars from input that isn't in "omen"
                       g·     # get length and multiply by 2
                         -    # subtract
                              # implicitly display

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

अदनान की बदौलत 2 बाइट बच गईं

— Emigna
स्रोत

1 शब्द के लिए संपीड़न के साथ भी किया जा सकता है ', इसलिए 26: Œv'¸éyåiyˆ}}¯é¤go¹'ƒÖ¦Ãg·-:) के लिए।

— अदनान

@ अदनान: अजीब। मैं निश्चित था कि मैंने कोशिश की थी। जाहिरा तौर पर नहीं। धन्यवाद!

— एमिगा जूल

यह शीर्ष उत्तर क्यों नहीं है?

— no --zɐɹƆ

7

जावास्क्रिप्ट (ईएस 7), 123 112 107 बाइट्स

s=>2**[5,4,3,2,1,0].find((i,_,a)=>a.some(j=>s.includes("luckyL".substr(j,i))))-2*~-s.split(/[omen]/).length

संपादित करें: सहेजे गए 11 बाइट्स @Titus को धन्यवाद देते हुए यह मानते हुए कि पत्र Lइनपुट में प्रकट नहीं होता है। सहेजे गए 5 बाइट्स @Oriol का धन्यवाद। ~~125~~ ~~114~~ 109 बाइट्स के लिए ES6 संस्करण :

f=
s=>(1<<[5,4,3,2,1,0].find((i,_,a)=>a.some(j=>s.includes("luckyL".substr(j,i)))))-2*~-s.split(/[omen]/).length
;

<input oninput=o.textContent=f(this.value)><pre id=o></pre>

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

— नील
स्रोत

replace([^])इसके बजाय आप का उपयोग क्यों करते हैं match([])? क्या आप 3 बाइट बर्बाद करते हैं या कोई कारण है?

— टाइटस

@Titus nullमैच के परिणाम से निपटने के लिए कितने बाइट्स लगते हैं ?

— नील

1

एक स्ट्रिंग के लिए चार, और ()इस मामले में एक जोड़ी ; आप के साथ बचा होगा कि सभी छह खाने match(/[omen]/)। अफ़सोस की बात है।

— टाइटस

1

@ यह निश्चित नहीं है कि आपका क्या मतलब है, लेकिन Lमूल के अंत में (जो कि मूल स्ट्रिंग में कभी नहीं दिखाई देगा) जोड़कर मुझे बाहरी मैचों के बारे में चिंता करने की ज़रूरत नहीं है और मैं वास्तव में [5,4,3,2,1,0]दोनों बार एक ही सरणी का उपयोग कर सकता हूं , 13 बाइट्स की बचत!

— नील

1

-2*s.split(/[omen]/).length+2छोटा है।

— ओरोल

6

पायथ, 27 26 28 बाइट्स

-^2le+k}#"lucky".:Q)yl@"omen

1 बाइट ने ओपी को धन्यवाद दिया :-)

स्पष्टीकरण:

                                 Implicit Q as input
                .:Q              Find all substrings of input
     +k}#"lucky"                 Filter for substring of "lucky", prepend "" in case of []
    e                            Take last element, which is longest
   l                             Get its length
 ^2                              Raise two to that
                      @"omen"Q   Filter Q for characters in "omen"
                     l           Get length; counts how many characters in "omen" there are
                    y            Double that
-                                Find the difference

इसका परीक्षण यहां करें ।

— busukxuan
स्रोत

1

मैं अजगर में विशेषज्ञ नहीं हूं, लेकिन मेरा मानना है कि आप "omen"सिर्फ "omenऔर सिर्फ पायथ को ही बदल सकते हैं

— charredgrass

@charredgrass उफ़, मेरी ग़लती :-)

— बसुकक्सुआन

1

ऐसा लगता है कि बिना तार के लिए काम करने के लिए "भाग्यशाली" के रूप में नहीं है। उदाहरण के लिए "मेम"।

— एमिग्ना जूल

1

@Emigna आह। शून्य मामला फिर .... धन्यवाद, यह तय!

— बुसकुक्सुआन

6

रूबी, 91 87 बाइट्स

String#countफिर से बारीक उपयोग पर हमला! (जब एक स्ट्रिंग पास की जाती है, तो यह फ़ंक्शन स्ट्रिंग के सभी अक्षरों के सभी आवृत्तियों को पूरे स्ट्रिंग के सभी आवृत्तियों के बजाय गिनता है।)

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

->s{2**(z=0..5).max_by{|j|z.map{|i|s[b="lucky"[i,j]]?b.size: 0}.max}-2*s.count("omen")}

एक संस्करण जो STDIN से लाइनों में ले जाता है और उन्हें प्रिंट करता है: 89 बाइट्स ( -nध्वज से 86 +3 )

p 2**(z=0..5).max_by{|j|z.map{|i|$_[b="lucky"[i,j]]?b.size: 0}.max}-2*$_.count("omen")

— मूल्य स्याही
स्रोत

1

._। कि String#countअजीब है। इसका उपयोग करने के लिए +1 (ab)। यह getsभी एक समारोह के बजाय उपयोग करने के लिए छोटा है ?

— डाउनगेट

1

@Downgoat अगर मुझे आउटपुट के लिए getsभी है puts, तो इस मामले में नहीं।

— वैल्यू इंक

4

रूबी: 100 बाइट्स

->s{2**(m=0;4.times{|j|1.upto(5){|i|m=[i,m].max if s.match"lucky"[j,i]}};m)-s.scan(/[omen]/).size*2}

— एडिसन
स्रोत

/[omen]/रेगेक्स के रूप में इसे नीचे गोल्फ में आज़माएं - यह किसी भी वर्ण से मेल खाएगा और |एकल पात्रों के लिए चिनिंग एस की तुलना में व्यावहारिक उपयोग में बेहतर है ।

— चार

3

जावास्क्रिप्ट - 206 बाइट्स

r=>{var a="lucky";r:for(var e=5;e>0;e--)for(var n=0;6>n+e;n++){var o=a.substring(n,e+n);if(r.includes(o))break r}for(var t=0,e=0;e<r.length;e++)('omen'.indexOf(r[e])+1)&&t++;return Math.pow(2,o.length)-2*t}

— क्रिस्टोफर बर्गडॉर्फ
स्रोत

1

आप इस स्थिति को बदल सकते हैं: s[k]=='o'||s[k]=='m'||s[k]=='e'||s[k]=='n'इस तरह दिखने के लिए:"oman".split("").includes(s[k])

— Addison

1

PPCG में आपका स्वागत है! बाइट्स को संरक्षित करने के लिए व्हॉट्सएप को हटाकर आप इसे नीचे गोल्फ कर सकते हैं। इसके अलावा, (s[k]=='o'||s[k]=='m'||s[k]=='e'||s[k]=='n')आप के बजाय उपयोग कर सकते हैं ('omen'.indexOf(s[k])+1)(यह मानते हुए जावास्क्रिप्ट है)

— charredgrass

सुझावों के लिए धन्यवाद! यह 237 से नीचे चला गया, हालांकि यह रूबी भीड़ की तरह मुझे हरा दिया है।

— क्रिस्टोफर बर्गडॉर्फ

एक और छोटी बात: आप इसे केवल एक अनाम फ़ंक्शन बनाने के function luck(r)लिए शॉर्टहैंड कर सकते हैं , r=>बस यही इस चुनौती के लिए आवश्यक है। इसके अलावा, मैंने चुनौती को संपादित किया ताकि आपको मामले के बारे में चिंता न हो ताकि आप हटा सकेंr=r.toLowerCase();

— charredgrass

इसके बजाय substringआप का उपयोग कर सकते हैं sliceमुझे विश्वास है (यह परीक्षण, हालांकि, मुझे यकीन नहीं है)

— डाउनगोट

3

रूबी, 57 बाइट्स

b=gets.count'omen'
$.+=1while/[lucky]{#$.}/
p 2**$./2-2*b

gets$.एक साइड इफेक्ट के रूप में 1 पर सेट होता है, तब तक हम इसे बढ़ाते हैं जब तक कि नियमित अभिव्यक्ति $.लगातार भाग्यशाली पात्रों से मेल नहीं खाती है।

— histocrat
स्रोत

3

हास्केल, 99

एक और दृष्टिकोण ... मैं सिर्फ समारोह अलियासिंग के बारे में सीखा

import Data.List
s=subsequences
i=intersect
l=length
f n=2^(l$last$i(s"lucky")$s n)-2*l(i n$"omen")

प्रयोग

f"lucky"
32

f"firetruck"
6

f"memes"
-7

— Zylviij
स्रोत

2

गणितज्ञ, 86 बाइट्स

कोड:

2^StringLength@LongestCommonSubsequence[#,"lucky"]-2StringCount[#,{"o","m","e","n"}]&

स्पष्टीकरण:

LongestCommonSubsequenceइनपुट के लिए सबसे लंबे समय तक सन्निहित प्रतिस्थापन देता है और "lucky"। StringLengthअपनी लंबाई देता है। इनपुट में StringCountवर्णों की घटनाओं की संख्या को गिना जाता है "omen"।

2

पायथन (139 बाइट्स)

import itertools as t
s=input()
print 2**max([j-i for i,j in t.combinations(range(6),2)if'lucky'[i:j]in s]+[0])-2*sum(_ in'omen'for _ in s)

— jmilloy
स्रोत

आप एक बाइट का उपयोग करके बचा सकते हैंfrom intertools import*

— wnnmaw

1

TSQL, 233 बाइट्स

golfed:

DECLARE @t varchar(99)='oluck'

,@z INT=0,@a INT=0,@ INT=1,@c INT=0WHILE @a<LEN(@t)SELECT
@a+=IIF(@=1,1,0),@z=IIF('LUCKY'LIKE'%'+x+'%'and @>@z,@,@z),@c+=IIF(x
IN('O','M','E','N'),2,0),@=IIF(@+@a-1=LEN(@t),1,@+1)FROM(SELECT
SUBSTRING(@t,@a,@)x)x PRINT POWER(2,@z)-@c

Ungolfed:

DECLARE @t varchar(99)='oluck'

,@z INT=0
,@a INT=0
,@  INT=1
,@c INT=0
WHILE @a<LEN(@t)
  SELECT
    @a+=IIF(@=1,1,0),
    @z=IIF('LUCKY'LIKE'%'+x+'%'and @>@z,@,@z),
    @c+=IIF(x IN('O','M','E','N'),2,0),
    @=IIF(@+@a-1=LEN(@t),1,@+1)
    FROM(SELECT SUBSTRING(@t,@a,@)x)x
PRINT POWER(2,@z)-@c

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

— t-clausen.dk
स्रोत

1

हास्केल ( 134 132 बाइट्स)

import Data.List
c[]=[]
c s@(_:x)=inits s++c x
l=length
g q=2^(maximum$map(\z->l q-l(q\\z))$c"lucky")-2*(l$intersect q"omen")

कोड गोल्फर नहीं और न ही हास्केल प्रोग्रामर, इसलिए इस पर कुछ सुझाव पसंद करेंगे।

(उदाहरण: g "firetruck" )

— ForemanBob
स्रोत

मैं कोई हास्केल विशेषज्ञ नहीं हूं, लेकिन एल्गोरिथ्म को थोड़ा बदलकर और उपयोग किए गए फ़ंक्शन पर फ़ंक्शन उपनाम का उपयोग करके कुछ बायस को बंद करने में कामयाब रहा।

— ज़ेलविज

1

पायथन 3, 168 157 152 139 144 136 बाइट्स

संपादित करें: वास्तव में स्पष्ट चीजें जो मुझे देखनी चाहिए थीं, उन्हें बदल दिया गया है, और कुछ कम स्पष्ट हैं।

2 संपादित करें: मूर्ख (idn˚)। कार्यक्रम में त्रुटियाँ थीं। मैंने इसे ठीक किया। वास्तव में नहीं 153 :(

5 बाइट्स बचाने के लिए लीक नून और 13 8 बाइट्स बचाने के लिए jmilloy का धन्यवाद ।

s=input()
p=q=k=len(s)
m=0
while-~p:
 while-~q:m=(m,q-p)[(s[p:q]in"lucky")*q-p>m];q-=1
 p-=1;q=k
print(2**m-2*sum(i in"omen"for i in s))

कार्यक्रम इनपुट में संभवतः सभी संभावित सबस्ट्रिंग के माध्यम से चलता है (संभवतः संभव है, क्योंकि यह असंभव सब्सट्रेट के साथ-साथ, 8 से 7, उदाहरण के लिए) की गणना करता है, जांचता है कि क्या सबस्ट्रिंग "भाग्यशाली" में है, तो 2 की लंबाई के घातांक को सेट करता है: सबस्ट्रिंग वर्तमान मूल्य से अधिक होना चाहिए। संभवतः लूप करते समय केवल एक का उपयोग करके सुधार किया जा सकता है। संभवतः कुछ सुधार का उपयोग कर सकता है; मैं अभी भी इसे लटका रहा हूँ।

— विनाशकारी नींबू
स्रोत

while p+1बन जाता हैwhile-~p

— लीकी नून

कब से b=s[p:q], सही len(b)होना चाहिए q-p?

— लीक नून

मैंने आपको इनपुट और प्रिंट का तरीका चुराया लेकिन बाकी बहुत अलग था, धन्यवाद! मुझे लगता है कि यदि आप print(2**m-2*sum(i in"omen" for i in s))अपनी पिछली तीन पंक्तियों के लिए करते हैं तो आप 148 की तरह बेहतर कर पाएंगे?

— १०:४५ पर जूलोय जूल

ओह, और आप while-~q:n=q-p;m=n if(s[p:q]in"lucky")*n>m else m;q-=1143 के लिए अगर खंड में s [p: q] को स्थानांतरित कर सकते हैं ?

— १६:५० पर जूलोय जूल

sum(map(s.count,"omen"))एक बाइट बचाता है, यह 135

— काले उल्लू काई

1

PHP प्रोग्राम, 139 135 108 बाइट्स

क्वांटम छलांग कई पदार्थों के लिए विफल हो जाती है जहां पहली घटना कम होती है। :(

^{वास्तव में मैं PHP <5.4 में रजिस्टर_ग्लोबल्स के साथ एक और 7 बाइट्स बचा सकता था}

<?for($s=$argv[1];$i<5;$i++)for($j=6;--$j;)$r=max($r,strstr($s,substr('lucky*',$i,$j))?2**$j:1);echo$r-2*preg_match_all('/[omen]/',$s);

उपयोग: php -d error_reporting=0 <filename> <string>

एक समारोह के लिए +5:

function f($s){for(;$i<5;$i++)for($j=6;--$j;)$r=max($r,strstr($s,substr('lucky*',$i,$j))?2**$j:1);return$r-2*preg_match_all('/[omen]/',$s);}

परीक्षण (समारोह पर)

echo '<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';
foreach([
    'lumberjack'=>0,        'smack'=>2,
    'nnnnnomemenn'=>-23,    'lucky'=>32,
    'omen'=>-7,             'firetruck'=>6,
    'memes'=>-7,            'determine the “luck” of a string'=>0,
    'amazing'=>-3,          'wicked'=>2,
    'chucky'=>16,           'uckyuke'=>14,
    'ugly'=>2,              'lucy'=>8,
    'lukelucky'=>30
] as $x=>$e){
    $y=f($x);
    echo"$h<tr><td>",$x,'</td><td>',$y,'</td><td>',$e,'</td><td>',$e==$y?'Y':'N',"</td></tr>";
}echo '</table>';

— टाइटस
स्रोत

1

ध्वज के साथ C # (दृश्य C # इंटरएक्टिव संकलक)`/u:System.Text.RegularExpressions.Regex` , 99 बाइट्स

n=>(1<<Matches(n,"l?u?c?k?y?").OrderBy(x=>x.Value).Last().Length)-n.Count(x=>"omen".Any(c=>c==x))*2

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

— अज्ञान का अवतार
स्रोत

0

स्काला, 155 बाइट्स

def f(w:String)=(1::List.fill((for(a<-1 to 5;s<-"lucky".sliding(a))yield if(w.contains(s)) a else 0).max){2}).product-2*w.filter("omen".contains(_)).length

— melach
स्रोत

एक स्ट्रिंग के "लक" का निर्धारण करें

05AB1E , 36 32 28 26 बाइट्स

जावास्क्रिप्ट (ईएस 7), 123 112 107 बाइट्स

पायथ, 27 26 28 बाइट्स

रूबी, 91 87 बाइट्स

रूबी: 100 बाइट्स

जावास्क्रिप्ट - 206 बाइट्स

रूबी, 57 बाइट्स

हास्केल, 99

प्रयोग

गणितज्ञ, 86 बाइट्स

पायथन (139 बाइट्स)

TSQL, 233 बाइट्स

हास्केल ( 134 132 बाइट्स)

पायथन 3, 168 157 152 139 144 136 बाइट्स

PHP प्रोग्राम, 139 135 108 बाइट्स

ध्वज के साथ C # (दृश्य C # इंटरएक्टिव संकलक)/u:System.Text.RegularExpressions.Regex , 99 बाइट्स

स्काला, 155 बाइट्स

ध्वज के साथ C # (दृश्य C # इंटरएक्टिव संकलक)`/u:System.Text.RegularExpressions.Regex` , 99 बाइट्स