Geben Sie bei einer gegebenen Zeichenfolge das "Glück" dieser Zeichenfolge zurück.

Das Glück einer Saite ist eine ganze Zahl, die sich wie folgt zusammensetzt:

• Das Grundglück für eine Saite ist 1.
• Für jeden aufeinanderfolgenden Buchstaben es Aktien mit dem Wort „Glück“ (Groß- und Kleinschreibung), multiplizieren Sie das Glück von 2. Zum Beispiel, wenn die Zeichenfolge ist „ lu mberjack“ oder „sma ck “ Du würdest multiplizieren 4. (Genauer gesagt, 2 ^ Anzahl aufeinanderfolgender Zeichen.)
  • Die geteilten Buchstaben müssen in der gleichen Reihenfolge sein, in der sie als "Glück" angezeigt werden, können jedoch an einer beliebigen Stelle im Wort mit demselben Wert beginnen ("luc" hat den gleichen 8 * -Multiplikator wie "cky").
  • Wenn das Wort mehrfach vorkommt und aufeinanderfolgende Zeichen mit glücklichen teilt, verwenden Sie die längste aufeinanderfolgende Zeichenfolge.
• Für JEDEN Brief, den es mit dem Wort "Omen" teilt, subtrahiere 2 vom Glück.
  • Es kann beliebig oft in beliebiger Reihenfolge mit einem Zeichen übereinstimmen. Zum Beispiel verliert die Zeichenfolge "nnnnnomemenn" 24 Glück (12 übereinstimmende Buchstaben)

Beispiel:

luck("lucky")
>>32

2 ^ 5 (5 aufeinanderfolgende Buchstaben) = 32

luck("firetruck")
>>6

2 ^ 3 - 2 (3 aufeinanderfolgende Briefe von uck , e geteilt mit omen)

luck("memes")
>>-7

1 - 8 (Grundbetrag, 4 geteilt mit "Omen")

Dies ist Codegolf, daher gewinnt die Antwort mit den wenigsten Bytes.

Sie können nach Belieben eingeben und ausgeben - schreiben Sie eine Funktion, verwenden Sie die Standardeingabe usw.

Nehmen Sie für Funktionen an, welcher Datentyp für diese Sprache Sinn macht. (In JavaScript wird beispielsweise a übergeben Stringund a zurückgegeben. Number)

Bearbeiten: Sie können davon ausgehen, dass die Eingabe in Kleinbuchstaben erfolgt.

05AB1E , 36 32 28 26 Bytes

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

Erläuterung

Œ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

Probieren Sie es online aus

2 Bytes gespart dank Adnan

JavaScript (ES7), 123 112 107 Byte

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

Bearbeiten: 11 Bytes dank @Titus gespeichert, indem angenommen wird, dass der Buchstabe Lnicht in der Eingabe erscheint. 5 Bytes gespart dank @Oriol. ES6-Version für 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 gespart dank OP :-)

Erläuterung:

                                 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

Teste es hier .

Ruby, 91 87 Bytes

String#count's finnicky Nutzung schlägt wieder zu! (Wenn eine Zeichenfolge übergeben wird, werden alle Vorkommen jedes Buchstabens im Funktionsargument anstelle aller Vorkommen der gesamten Zeichenfolge gezählt.)

Probieren Sie es online aus

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

Eine Version, die Zeilen aus STDIN aufnimmt und ausgibt: 89 Byte (86 +3 vom -nFlag)

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

Ruby: 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

getssetzt $.als Nebeneffekt 1, dann erhöhen wir es, bis der reguläre Ausdruck, der $.aufeinanderfolgenden Glückszeichen entspricht, nicht mehr übereinstimmt.

Haskell, 99

Ein anderer Ansatz ... Ich habe gerade etwas über Function Aliasing gelernt

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

Verwendung

f"lucky"
32

f"firetruck"
6

f"memes"
-7

Mathematica, 86 Bytes

Code:

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

Erläuterung:

LongestCommonSubsequencegibt die längste zusammenhängende Teilzeichenfolge zurück, die der Eingabe und gemeinsam ist "lucky". StringLengthgibt seine Länge. StringCountzählt die Anzahl der Vorkommen der Zeichen "omen"in der Eingabe.

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

Golf gespielt:

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

Probieren Sie es online aus

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

Weder ein Codegolfer noch ein Haskell-Programmierer, also würde ich gerne ein paar Tipps dazu geben.

(Beispiel: g "firetruck")

Python 3, 168 157 152 139 144 136 Bytes

EDIT: Wirklich offensichtliche Dinge, die ich hätte leichter sehen sollen, wurden geändert und einige sind etwas weniger offensichtlich.

Edit 2: doof (˚n˚). Das Programm warf Fehler. Ich habe es repariert. nicht wirklich 153 :(

Vielen Dank an Leaky Nun für das Speichern von 5 Bytes und an jmilloy für das Speichern von 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))

Das Programm durchläuft alle möglichen Teilzeichenfolgen in der Eingabe (möglicherweise, weil es auch unmögliche Teilzeichenfolgen berechnet, z. B. 8 bis 7), prüft, ob die Teilzeichenfolge "glücklich" ist, und setzt dann den Exponenten von 2 auf die Länge von Die Teilzeichenfolge sollte größer als der aktuelle Wert sein. Könnte evtl. mit nur einer while-Schleife verbessert werden. Könnte möglicherweise eine Verbesserung gebrauchen; Ich bekomme immer noch den Dreh raus.

PHP-Programm, 139 135 108 Bytes

Quantensprung schlägt bei mehreren Teilzeichenfolgen fehl, bei denen das erste Auftreten kürzer ist. :(

^{Eigentlich könnte ich weitere 7 Bytes in PHP <5.4 mit register_globals speichern}

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

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

+5 für eine Funktion:

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

Tests (auf die Funktion)

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 # Interactive Compiler) mit Flag /u:System.Text.RegularExpressions.Regex, 99 Byte

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

Probieren Sie es online!

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