문자열이 주어지면 해당 문자열의 "행운"을 반환하십시오.

내가이 도전의 목적을 위해 완전히 보완 한 것처럼 문자열의 행운은 정수이며 다음과 같이 결정됩니다.

• 문자열의 기본 운은 1입니다.
• 연속되는 각 문자에 대해 "lucky"(대소 문자 구분)이라는 단어를 공유하면 행운에 2를 곱합니다. 예를 들어 문자열에 " lu mberjack"또는 "sma ck "인 경우 4를 곱합니다 (더 구체적으로, 2 ^ 연속 문자 수 공유)
  • 공유 문자는 "행운"으로 표시되는 순서와 동일해야하지만 단어의 어느 곳에서나 같은 값으로 시작할 수 있습니다 ( "luc"는 "cky"와 동일한 8 * 승수를 가짐).
  • 단어에 행운이있는 연속 문자를 공유하는 여러 항목이있는 경우 연속 된 가장 긴 문자열을 사용하십시오.
• 모든 문자의 경우 행운에서 2를 뺀 "omen"이라는 단어와 공유됩니다.
  • 순서에 상관없이 문자를 여러 번 일치시킬 수 있습니다. 예를 들어 문자열 "nnnnnomemenn"은 24 운을 잃습니다 (12 개의 일치하는 문자)

예:

luck("lucky")
>>32

2 ^ 5 (5 연속 문자) = 32

luck("firetruck")
>>6

2 ^ 3-2 (uck 에서 3 개의 연속 된 문자 , 전자 가 징조와 공유)

luck("memes")
>>-7

1-8 (기본 금액, 4 "omen"과 공유)

이것은 코드 골프이므로 가장 적은 바이트를 가진 답이 이깁니다.

함수를 작성하고 표준 입력을 사용하는 등 원하는 방식으로 입력 및 출력 할 수 있습니다.

함수의 경우 해당 언어에 적합한 데이터 유형을 가정하십시오. (예를 들어, JavaScript에서는 a가 전달되고 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 바이트 절약

자바 스크립트 (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

여기에서 테스트하십시오 .

루비, 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")

루비 : 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}

자바 스크립트-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}

루비, 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

수학, 86 바이트

암호:

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

설명:

LongestCommonSubsequence입력에 공통된 가장 긴 연속 하위 문자열을 반환합니다 "lucky". StringLength길이를 제공합니다. 입력에서 StringCount문자의 발생 횟수를 계산합니다 "omen".

파이썬 (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

온라인으로 사용해보십시오

하스켈 ( 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")

코드 골퍼 나 하스켈 프로그래머는 아니므로 이에 대한 팁을 좋아할 것입니다.

(실시 예 : g "firetruck")

파이썬 3 168 157 152 139 144 136 바이트

편집 : 내가 본 것보다 훨씬 분명한 것이 바뀌었고 약간 덜 명확했습니다.

편집 2 : stoopid (˚n˚). 프로그램에서 오류가 발생했습니다. 나는 그것을 고쳤다. 실제로는 153 :(

5 바이트를 절약 한 Leaky Nun과 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)). 하위 문자열은 현재 값보다 커야합니다. 하나의 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>';

플래그 /u:System.Text.RegularExpressions.Regex가 99 바이트 인 C # (Visual C # Interactive Compiler)

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

온라인으로 사용해보십시오!

스칼라, 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