给定一个字符串，返回该字符串的“运气”。

正如我为完成此挑战而完全弥补的那样，字符串的运气是一个整数，其确定如下：

• 字符串的基本运气是1。
• 对于每个与“ lucky”（不区分大小写）单词共享的连续字母，将运气乘以2。例如，如果您的字符串是“ lu mberjack”或“ sma ck ”，则应乘以4。（更具体地说， 2 ^共享的连续字符数。）
  • 共享字母必须以出现在“ lucky”中的相同连续顺序排列，但可以在单词中的任何位置以相同的值开头（“ luc”的倍数与“ cky”的倍数相同）为8。
  • 如果单词多次出现并幸运地共享连续字符，请使用最长的连续字符串。
• 对于任何字母，它与单词“ omen”共享，则从运气中减去2。
  • 它可以以任意顺序，任意次数匹配一个字符。例如，字符串“ nnnnnomemenn”失去了24个运气（12个匹配的字母）

例：

luck("lucky")
>>32

2 ^ 5（连续5个字母）= 32

luck("firetruck")
>>6

2 ^ 3-2（来自uck的 3个连续字母，与omen共享e）

luck("memes")
>>-7

1-8（基本金额，与“预兆”共享4个）

这是代码高尔夫球，因此字节最少的答案会获胜。

您可以使用任何方式输入和输出-编写函数，使用标准输入等。

对于函数，假定对该语言有意义的任何数据类型。（例如，在JavaScript中，将传递a String并返回Number）

编辑：您可以假设任何输入都是小写。

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

在线尝试

感谢Adnan，节省了2个字节

的JavaScript（ES7），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

编辑：假设字母L未出现在输入中，因此@Titus节省了11个字节。@Oriol节省了5个字节。ES6版本125个 114 109字节：

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字节

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

由于OP :-)节省了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

在这里测试。

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

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

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

Ruby，57个字节

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

gets设置$.为1作为副作用，然后我们将其递增，直到匹配$.连续的幸运字符的正则表达式不再匹配为止。

哈斯克尔（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

Mathematica，86个字节

码：

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

说明：

LongestCommonSubsequence返回输入和共同的最长连续子字符串"lucky"。StringLength给出其长度。StringCount计算"omen"输入中的字符出现的次数。

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

TSQL，233个字节

打高尔夫球：

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

取消高尔夫：

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

在线尝试

Haskell（134132字节）

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

既不是代码高尔夫球手，也不是Haskell程序员，所以不喜欢此技巧。

（实施例：g "firetruck"）

Python 3中，168个 157 152 139 144 136字节

编辑：我应该已经看到的很明显的事情已经改变了，有些不太明显。

编辑2：stoopid（˚n˚）。程序抛出错误。我把它修好了。实际上不是153 :(

感谢Leaky Nun保存5个字节，并感谢jmilloy保存13 8个字节。

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），检查子字符串是否为“ lucky”，然后将2的指数设置为子字符串应大于当前值。仅使用一个while循环可能会得到改善。可以使用一些改进；我仍然明白这一点。

PHP程序，139个 135 108字节

对于第一次出现时间较短的多个子串，量子跃迁失败。:(

^{实际上，我可以使用register_globals在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>';

带标志的C＃（Visual 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

在线尝试！

Scala，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