Bir dize verildiğinde, o dizenin "şansını" döndür.

Bir dizgenin şansı, bu zorluğun amacı için tamamen yeni oluşturduğum gibi, tam olarak şöyle belirlenmiştir:

• Bir dize için temel şans 1'dir.
• Her ardışık harf için "şanslı" kelimesiyle paylaşır (duyarsız), şansı 2 ile çarpın. Örneğin, dizeniz " lu mberjack" veya "sma ck " ise 4 ile çarpın. (Daha spesifik olarak, 2 ^ paylaşılan ardışık karakter sayısı.)
  • Paylaşılan harflerin "şanslı" olarak göründüğü aynı ardışık sırada olması gerekir, ancak aynı değer için kelimenin herhangi bir yerinde başlayabilir ("luc", "cky" ile aynı 8 * çarpanına sahiptir).
  • Kelimenin ardışık karakterlerini şanslı ile paylaştığı birden çok tekrar oluşuyorsa, karakterlerin en uzun ardışık dizesini kullanın.
• HERHANGİ bir mektup için "omen" kelimesiyle paylaşır, şanstan 2 çıkar.
  • Bir karaktere, herhangi bir sırada, herhangi bir miktarda, herhangi bir miktarda eşleşebilir. Örneğin, "nnnnnomemenn" dizgisi 24 şans kaybeder (eşleşen 12 harf)

Örnek:

luck("lucky")
>>32

2 ^ 5 (5 ardışık harf) = 32

luck("firetruck")
>>6

2 ^ 3-2 (3 ardışık harfler UCK'nın , E alâmet ile ortak)

luck("memes")
>>-7

1 - 8 (temel tutar, 4 "omen" ile paylaşılan)

Bu kod golf, yani en az bayt olan cevap kazanıyor.

İstediğiniz gibi giriş ve çıkış yapabilirsiniz - bir işlev yazın, standart giriş kullanın, vb.

İşlevler için, bu dil için hangi veri türünün anlamlı olacağını varsayalım. (Örneğin, JavaScript’te, a ile gönderilir Stringve a ile döndürülür Number)

Düzenleme: Herhangi bir girişin küçük harf olduğunu varsayabilirsiniz.

05AB1E , 36 32 28 26 bayt

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

açıklama

Œ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

Çevrimiçi deneyin

Adnan sayesinde 2 bayt kaydedildi

JavaScript (ES7), 123 112 107 bayt

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

Düzenleme: Harflerin girişte görünmediği varsayılarak @Titus sayesinde 11 bayt kaydedildi L. @Oriol sayesinde 5 byte kurtarıldı. 125 114 109 bayt için ES6 sürümü :

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>

Pyth, 27 26 28 bayt

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

OP :-) sayesinde 1 byte kaydedildi

Açıklama:

                                 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

Burada test et .

Ruby, 91 87 bayt

String#count'nin titiz kullanımı tekrar grev! (Bir String geçirildiğinde, dizgenin bütün oluşumları yerine fonksiyon bağımsız değişkenindeki her harfin tüm oluşumlarını sayar.)

Çevrimiçi deneyin

->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'dan satırlara geçen ve bunları basan bir sürüm: 89 bayt ( -nbayraktan 86 +3 )

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

Yakut: 100 bayt

->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}

Javascript - 206 Bayt

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}

Ruby, 57 bayt

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

gets$.yan etki olarak 1'e ayarlar , ardından $.art arda sıralı şanslı karakterlerle eşleşen normal ifade eşleşene kadar onu artırırız.

Haskell, 99

Başka bir yaklaşım ... Ben sadece fonksiyon takma hakkında öğrendim

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

kullanım

f"lucky"
32

f"firetruck"
6

f"memes"
-7

Mathematica, 86 bayt

Kod:

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

Açıklama:

LongestCommonSubsequenceGirdide ortak olan en uzun bitişik alt dizgiyi ve "lucky". StringLengthuzunluğu verir. StringCountGirdideki karakterlerin oluşum sayısını sayar "omen".

Python (139 Bayt)

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)

TSQL, 233 bayt

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

Çevrimiçi deneyin

Haskell ( 134 132 Bayt)

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

Bir kod golfçü ya da Haskell programcısı değil, bu konuda bazı ipuçları almak isterdi.

(Örnek: g "firetruck")

Python 3, 168 157 152 139 144 136 bayt

EDIT: Gerçekten daha kolay görmem gereken bariz şeyler değişti ve bazıları biraz daha açıktı.

Düzenleme 2: stoopid (˚n˚). Program hataları attı. Düzeltdim. aslında 153 değil :(

5 bayt tasarruf için Leaky Nun ve 13 8 bayt tasarruf için jmilloy sayesinde .

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

Program, girdideki tüm olası alt dizileri çalıştırır (örneğin mümkün olmadığından, örneğin imkansız alt dizileri de hesapladığından dolayı), alt dizenin "şanslı" olup olmadığını kontrol eder, ardından 2'nin üssünün uzunluğunu ayarlar. alt dize geçerli değerden büyük olmalıdır. Muhtemelen sadece bir süre döngü kullanarak geliştirilebilir. Muhtemelen bazı iyileştirmeler kullanabilirdi; Hala bunun asılmaya başladım.

PHP programı, 139 135 108 bayt

kuantum sıçraması, ilk oluşumun daha kısa olduğu çoklu alt diziler için başarısız olur. :(

^{Aslında register_globals ile PHP <5.4 olan 7 bayt daha kaydedebilirim}

<?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);

kullanımı: php -d error_reporting=0 <filename> <string>

Bir işlev için +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);}

testler (fonksiyon üzerinde)

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>';

Bayrak /u:System.Text.RegularExpressions.Regex, 99 bayt ile C # (Visual C # Etkileşimli Derleyici)

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

Çevrimiçi deneyin!

Scala, 155 bayt

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