Dada una cadena, devuelve la "suerte" de esa cadena.

La suerte de una cadena, como acabo de inventar con el propósito de este desafío, es un número entero, determinado de esta manera:

• La suerte base para una cadena es 1.
• Para cada letra consecutiva que comparte con la palabra "suerte" (no distingue entre mayúsculas y minúsculas), multiplique la suerte por 2. Por ejemplo, si su cadena era " lu mberjack" o "sma ck ", multiplicaría por 4. (Más específicamente, 2 ^ número de caracteres consecutivos compartidos)
  • Las letras compartidas deben estar en el mismo orden consecutivo que aparece en "suerte", pero pueden comenzar en cualquier parte de la palabra por el mismo valor ("luc" tiene el mismo multiplicador 8 * que "cky").
  • Si la palabra tiene múltiples ocurrencias donde comparte caracteres consecutivos con lucky, use la cadena consecutiva más larga de los caracteres.
• Para CUALQUIER letra que comparta con la palabra "presagio", reste 2 de la suerte.
  • Puede coincidir con un personaje cualquier cantidad de veces, en cualquier orden. Por ejemplo, la cadena "nnnnnomemenn" pierde 24 suerte (12 letras coincidentes)

Ejemplo:

luck("lucky")
>>32

2 ^ 5 (5 letras consecutivas) = ​​32

luck("firetruck")
>>6

2 ^ 3 - 2 (3 letras consecutivas de uck , e compartidas con presagio)

luck("memes")
>>-7

1 - 8 (cantidad base, 4 compartidos con "presagio")

Este es el código de golf, por lo que gana la respuesta con la menor cantidad de bytes.

Puede ingresar y emitir de la forma que desee: escriba una función, use la entrada estándar, etc.

Para las funciones, suponga que cualquier tipo de datos tendría sentido para ese idioma. (Por ejemplo, en JavaScript, se le pasará ay Stringdevolverá a Number)

Editar: puede suponer que cualquier entrada es minúscula.

05AB1E , 36 32 28 26 bytes

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

Explicación

Œ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

Pruébalo en línea

Guardado 2 bytes gracias a Adnan

JavaScript (ES7), 123 112 107 bytes

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

Editar: Guardado 11 bytes gracias a @Titus al suponer que la letra Lno aparece en la entrada. Guardado 5 bytes gracias a @Oriol. Versión ES6 para 125 114 109 bytes:

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 bytes

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

1 byte guardado gracias a OP :-)

Explicación:

                                 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

Pruébalo aquí .

Ruby, 91 87 bytes

String#count¡El uso finnicky ataca de nuevo! (Cuando se pasa una Cadena, cuenta todas las apariciones de cada letra en el argumento de la función en lugar de todas las apariciones de toda la cadena).

Pruébalo en línea

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

Una versión que toma líneas de STDIN y las imprime: 89 bytes (86 +3 de la -nbandera)

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

Rubí: 100 bytes.

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

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 bytes

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

getsse establece $.en 1 como efecto secundario, luego lo incrementamos hasta que la expresión regular que coincide con $.caracteres afortunados consecutivos ya no coincide.

Haskell, 99

Otro enfoque ... Acabo de aprender sobre el alias de funciones

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

Uso

f"lucky"
32

f"firetruck"
6

f"memes"
-7

Mathematica, 86 bytes

Código:

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

Explicación:

LongestCommonSubsequencedevuelve la subcadena contigua más larga común a la entrada y "lucky". StringLengthda su longitud. StringCountcuenta el número de ocurrencias de los caracteres de "omen"en la entrada.

Python (139 bytes)

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 bytes

Golfizado:

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

Sin golf:

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

Pruébalo en línea

Haskell ( 134 132 Bytes)

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

No es un jugador de código ni un programador de Haskell, por lo que me encantaría algunos consejos sobre este.

(Ejemplo: g "firetruck")

Python 3, 168 157 152 139 144 136 bytes

EDITAR: Las cosas realmente obvias que debería haber visto más fáciles han cambiado, y algunas un poco menos obvias.

Edición 2: stoopid (˚n˚). El programa arrojó errores. Lo arreglé. en realidad no 153 :(

Gracias a Leaky Nun por guardar 5 bytes, y a jmilloy por guardar 13 8 bytes.

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

El programa se ejecuta a través de todas las posibles subcadenas de entrada (posiblemente posible, porque también calcula subcadenas imposibles, 8 a 7, por ejemplo), comprueba si la subcadena está en "suerte", luego establece el exponente de 2 a la longitud de la subcadena debe ser mayor que el valor actual. Posiblemente podría mejorarse usando solo un bucle while. Posiblemente podría usar alguna mejora; Todavía me estoy acostumbrando a esto.

Programa PHP, 139 135 108 bytes

el salto cuántico falla para múltiples subcadenas donde la primera ocurrencia es más corta. :(

^{De hecho, podría guardar otros 7 bytes en PHP <5.4 con register_globals en}

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

uso: php -d error_reporting=0 <filename> <string>

+5 para una función:

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

pruebas (en la función)

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 # (compilador interactivo de Visual C #) con indicador /u:System.Text.RegularExpressions.Regex, 99 bytes

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

Pruébalo en línea!

Scala, 155 bytes

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