아케이드 버전의 게임에서 Pac-Man은 pac-dots를 먹습니다. 그러나이 도전에서 그는 영숫자 문자와 문자열의 구두점에 배고프다.

당신의 임무는 Pac-Man에 문자열을 공급하고, 그것을 먹을 수 있는지 여부를 평가하고, Pac-Man의 위치와 함께 문자열을 반환하는 함수를 만드는 것입니다.

Pac-Man ( <)은 왼쪽에서 오른쪽으로 문자를 먹으며 각 문자마다 밑줄이나 공백을 남겨두고 첫 번째 위치 -1에서 마지막 위치 +1에 도달하는 것이 목표입니다.

1. <Pac
2. _<ac
3. __<c
4. ___<

그러나 팩맨 (Pac-Man)의 천적 인 유령은 "고스트 (GHOST)"(대소 문자 구분 안함)라는 글자 중 하나를 만나면 그를 막을 것입니다. 함수는 캐릭터를 만나면 팩맨의 위치와 함께 문자열을 반환해야 ghost합니다.

1. <No!
2. _<o!

유령을 물리 칠 수있는 유일한 것은 파워 펠릿입니다. Pac-Man이 유령에게 오기 전에 "PELLET"(대소 문자 구분 안 함)이라는 글자에 도달하면 유령을 먹고 계속 움직이며 그 펠릿이 다 사용됩니다. 파워 펠렛은 쌓을 수 있습니다 (즉, ppgg두 유령 모두 먹게됩니다). T의 가 (같은 다른 문자로 취급 무시 될 수 있도록 문자, 유령과 펠렛 등 모두 존재합니다 a).

1. <Pop
2. _<op
3. __<p
4. ___<

더 명확하게하기 위해 문자열 "Pac-Man이 여기에서졌습니다"에서 다음 작업이 수행됩니다.

P <P, +1 Pellet (1 pellet)
a <a
c <c
- <-
M <M
a <a
n <n
  <[space]
l <l, +1 Pellet (2 pellets)
o <o, -1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
e <e, +1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
  <[space]
h <h, ghost wins, returns
e
r
e

예

Input: Pacman wins!
Output: ____________<

Input: Pacman loses wah-wah :(
Output: _______________<h-wah :(

Input: PELLET PELLET GHOST
Output: ___________________<

Input: Hello World!
Output: <Hello World!

Input: <_!@12<_<_<
Output: ___________<

이것은 바이트 단위로 가장 낮은 점수입니다.

젤리, 34 33 바이트

Œl“ʋʋ“ṁḍ»ċ€Ð€IF+\‘0ṭi0ð’”_×;”<;ṫ@

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

마침내 젤리를 이해하기 시작했습니다. 조금 무섭습니다.

망막 , 55 38 바이트

i`^(([elp])|[^ghos]|(?<-2>.))*
$.&$*_<

온라인으로 사용해보십시오! 첫 번째 줄은 한 번에 여러 테스트 사례를 실행할 수 있습니다.

설명

문제는 본질적으로 닫는 괄호가없는 가장 긴 접두사를 찾는 것입니다. 우리가 하나를 사용 수 있다는 점을 제외하고 e, l또는 p대신에 (와 중 g, h, o또는 s대신에 ).

따라서이 솔루션은 거의 균형 그룹의 교과서 예입니다. 이 코드는 균형 그룹에 대한 SO 답변에서 읽을 수있는 표준 예제와 본질적으로 동일하므로 작동 방식에 대해 자세히 설명하지 않습니다 .

따라서 전체 프로그램은 단일 정규식 대체입니다. 는 i대소 무감각을 활성화합니다. 그런 다음 우리는 펠렛과 일치 [elp]하고 깊이 카운터를 늘리 2거나 ( 그룹의 캡처 스택 형태로 ) 유령이 아닌 것과 [ghos]일치하거나 유령과 일치하고 .스택에서 튀어 나와 깊이 카운터를 줄입니다. 2. 물론, 이것은 원칙적으로 펠릿을 [^ghos]섹션 과 일치 시키거나 유령이 아닌 섹션 과 일치시킬 수 .있지만, 탐욕스러운 매칭과 정규식이 역 추적되는 방식 덕분에 이러한 가능성은 정규식 엔진에 의해 시도되지 않습니다.

그런 다음 대체는 두 개의 Retina 특정 기능을 사용 $*합니다. 왼쪽 토큰에 지정된 수만큼 문자를 오른쪽으로 반복합니다. 그 토큰은 $.&전체 경기의 길이입니다. 이것은 우리가 일치하는 각 문자를로 대체한다는 것을 의미합니다 _. 그리고 <밑줄에 a 를 덧붙 입니다. 먹지 않은 입력 부분은 단순히 대체의 영향을받지 않습니다.

파이썬 2 114 113 108 바이트

s=raw_input()
p=i=0
for c in s:
 p+=(c in'plePLE')-(c in'ghosGHOS')
 if p<0:break
 i+=1
print'_'*i+'<'+s[i:]

파이썬 2, 89 바이트

때때로 파이썬을 기능적 언어로 만들 겠다는 완고한 결심은 그 장점이 있습니다.

def f(s,l=1):l+=(s[:1]in'plePLE')-(s[:1]in'ghosGHOS');return s*l and'_'+f(s[1:],l)or'<'+s

(약간) 언 골프 :

def f(s, l=1):
    l += (s[:1] in 'plePLE') - (s[:1] in 'ghosGHOS')
    return (s * l) and ('_' + f(s[1:], l)) or ('<' + s)

재귀를 사용하여 결과 문자열을 작성합니다. l( "생명"에 대한) 업데이트 는 펠렛 ( True - False == 1)에 1을 False - True == -1추가하고 유령 ( )에 1을 빼고 다른 문자에 0을 더합니다. s파이썬의 슬라이싱과 '' in any_str == True펠릿과 고스트가 취소되므로 사실은 빈 문자열 인 경우 0을 추가합니다 .

return 문은 1 바이트를 저장하는 test and b or a대신 사용합니다 a if test else b. 스트링의 말단 또는 크맨 간결 하나로서 표현 펠릿 떨어지면 재귀 기본 케이스가 발생 s*p같다하는 ''(따라서 거짓으로 평가) 할 때 하나 s == ''또는 p == 0.

C #을 269 256 232 212 211 바이트

처음 여기에 게시 했으므로 아마도 이것이 아마도 더 오래 될 것입니다 (아마도 C #에 있기 때문에). 내가 그것을 줄일 수있는 곳의 모든 팁은 좋을 것입니다!

나를 도와 주신 모든 의견에 감사드립니다!

골프 버전

static void p(string x){int p=0,i=0;string t='<'+x;var s=t.ToCharArray();for(;++i<s.Length;){if("PELpel".Contains(s[i]))p++;if("GHOSghos".Contains(s[i])&&--p<0)break;s[i]='<';if(i>0)s[i-1]='_';}Console.Write(s);}

언 골프 버전

static void p(string x) {
 int p = 0, i = 0;
 string t = '<' + x;
 var s = t.ToCharArray();
 for (; ++i < s.Length;) {
  if ("PELpel".Contains(s[i])) p++;
  if ("GHOSghos".Contains(s[i]) && --p < 0) break;
  s[i] = '<';
  if (i > 0) s[i - 1] = '_';
 }
 Console.Write(s);
}

Pyth, 53 48 44 바이트

!!@-> }트릭 을 위해 @ Pietu1998 덕분에 4 바이트 (Pyth를 아는 사람들 만 이해할 수 있음)

++ * Jf <@ + sM._m-!! @ d "PELpel"!! @ d "GHOSghos"Q_1T00 \ _ \ <> QJ 
++ * Jf <@ + sM._m-!! @ d "PEL" !! @ d "GHOS"rQ1_1T00 \ _ \ <> QJ
++ * Jf <@ + sM._m-} d "PEL"} d "GHOS"rz1_1T00 \ _ \ <> zJ

테스트 스위트.

MATL , 37 36 35 바이트

tkt'ghos'mw'pel'm-Ys1=Y>&)g95*60bhh

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

설명

tkt      % Input string implicitly. Duplicate, convert to lower case, duplicate
'ghos'm  % True for "ghost" characters
w'pel'm  % Swap to bring lowercase copy to top. True for "pellet" characters
-Ys      % Subtract, cumulative sum. Pac-Man can reach until the first "1"
1=       % True for entries that equal 1
Y>       % Cumulative maximum. This gives false until the first true is found, and
         % true from there on
&)       % Split original string in two parts, given by the zeros and ones respectively
g95*     % Convert the first part into ones and multiply by 95. This gives a numerical
         % array containing number 95 (ASCII for '_')
60       % Push 60 (ASCII for '<')
b        % Bubble up second part of original string
hh       % Concatenate the three strings/arrays, automatically converting to char

JavaScript (ES6), 98 바이트

s=>s.replace(/./g,c=>p<0?c:(p+=/[elp]/i.test(c)-/[ghos]/i.test(c))<0?"<"+c:"_",p=0)+"<".slice(p<0)

설명 : p현재 펠릿 수를 유지합니다. 음수이면 문자를 반환하고 계속 진행하여 나머지 문자열은 그대로 유지합니다. 그렇지 않으면 현재 문자를 검사하고 그 문자 p가 음수가되면 <문자를 삽입하고 그렇지 않으면 현재 문자를로 바꿉니다 _. 마지막으로 p음수가되지 않으면 <문자열에 접미사 a 를 붙 입니다.

Pyth, 47 46 44 바이트

++*\_Kh+f!h=+Z-}Jr@zT0"pel"}J"ghos"Uzlz\<>zK

온라인으로 사용해보십시오. 테스트 스위트.

Leaky Nun과는 상당히 다른 접근법이며, 이것이 더 골프화 될 수 있다고 확신합니다.

루아, 198 190 184 185 163 바이트

알았어, 이건 길다. 매우 긴. 루아는 문자열을 다루는 도구가 있지만 공간이 많이 필요한 조건부에서도 마찬가지입니다.

편집 : 9 바이트를 절약 해 주셔서 감사합니다 @LeakyNun :) 버그를 수정하기 위해 바이트를 잃어 버렸습니다.

편집 2 : @LeakyNun에 의해 발견 된 163 바이트 솔루션

i=0p=0n=...for c in n:gmatch"."do
p=p+(c:find"[ghosGHOS]"and-1or c:find"[pelPEL]"and 1or 0)if p<0then
break else i=i+1 end end print(('_'):rep(i)..'<'..n:sub(i+1))

올드 185

p=0z=(...):gsub(".",function(c)p=p+(c:find"[ghosGHOS]"and-1or
c:find"[pelPEL]"and 1or 0)s=p<0 and 1or s
return s and c or'_'end)_,i,s=z:find"(_+)"print((s or'')..'<'..z:sub(1+(i or 0)))

언 골프

i=0                        -- number of characters eaten
p=0                        -- pellet counter
n=...                      -- shorthand for the argument
for c in n:gmatch"."       -- iterate over each characters in the input
do
  p=p+(c:find"[ghosGHOS]"  -- if the current char is a GHOST
        and-1              -- decrement the pellet counter
      or c:find"[pelPEL]"  -- if it's a PELLET
        and 1              -- increment it
      or 0)                -- else, leave it alone
  if p<0                   -- if we try to eat a ghost without pellet
  then 
    break                  -- stop iterating
  else
    i=i+1                  -- else, increment our score
  end
end

print(('_'):rep(i)         -- print i*'_'
  ..'<'                    -- appended with Pacman
  ..n:sub(i+1))            -- appended with the remaining characters if we died

파이썬 3 176 157 150 149 134 133 124 바이트

f문자열을 인수로 사용하는 명명 된 함수를 정의하십시오.

def f(s):
 n=i=0
 for c in s:
  if c in"GgHhOoSs":
   if n:n-=1
   else:break
  n+=c in"PpEeLl";i+=1
 return"_"*i+"<"+s[i:]

아마 더 많은 골프를 칠 수 있습니다

의견을 말한 모든 분들께 감사드립니다 : D

파이썬 3, 114110 바이트

내 첫 번째 코드 골프.

4 바이트를 절약 한 Green Eggs 박사와 Iron Man에게 감사합니다.

l,x=1,0
f,y,s="ghosGHOS","pelPEL",input()
while s[x:]*l:l+=(s[x]in y)-(s[x]in f);x+=l>0
print("_"*x+"<"+s[x:])

논리 AND를 곱하기 위해 부울 값을 1과 0으로 평가합니다. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1)입니다. 이것이 좋은 첫 시도 가기를 바랍니다.

파워 쉘, 185

{$l=1;$o="";for($i=0;($i -lt $_.Length) -or (($o+="<") -and 0); $i++){if ($_[$i] -match '[pel]'){$l++}if($_[$i] -match '[ghos]'){$l--}if(!$l){$o+="<"+$_.substring($i);break}$o+="_"}$o}

언 골프 드 :

("Pacman wins!",
"Pacman loses wah-wah :(",
"PELLET PELLET GHOST",
"Hello World!"
) | 
% {
    $l=1;$o="";
    for($i = 0; ($i -lt $_.Length) -or (($o+="<") -and 0); $i++) {
        if ($_[$i] -match '[pel]') { $l++ }
        if ($_[$i] -match '[ghos]') { $l--}
        if (!$l) { $o+="<"+$_.substring($i); break }        
        $o += "_"
    }
    $o
}

Python3, (211) 184 바이트

인수 's'는 문자열입니다

def f(s):
    p=c=0
    for i in s:
        if i in "gGhHoOsS":
            if p<1:break
            else:p-=1
        if i in "pPeElL":p+=1
        c+=1
    return"_"*c + "<" + s[c:]

이것이 첫 번째 코드 골프 시도이므로 골프 팁을 주셔서 감사합니다.

댓글 주셔서 감사합니다 :)

하스켈, 119 113 바이트

6 바이트 적은 Daniel Wagner에게 감사드립니다.

p=(0!)
n!(c:s)|elem c"ghosGHOS"=if n<1then '<':c:s else(n-1)&s|elem c"elpELP"=(n+1)&s|0<1=n&s
_!_="<"
n&s='_':n!s

로 호출하십시오 p "Hello World!".

이것은 1thenGHC (7.10)에서 올바르게 해석되는 가장 중요한 경우이지만 대부분의 구문 형광펜을 던집니다. 따라서 컴파일러에서도 다르게 해석 될 수 있습니다.

언 골프 드 :

pacman string = go 0 string

-- | In the golfed version: (!)
go _   []                   = "<"                            -- won
go pellets (char:string)
 | char `elem` "ghosGHOS"
 = if pellets < 1        then '<':char:string                -- lost
                         else nextStep (pellets - 1) string  -- ghost
 | char `elem` "elpELP"
 =                            nextStep (pellets + 1) string  -- pellet
 | otherwise
 =                            nextStep  pellets      string  -- anything else

-- | In the golfed version: (&)
nextStep pellets string = '_':(go pellets string)

C, 237 바이트

#include<stdio.h>
#include<string.h>
main(p,i,j){char s[99];fgets(s,99,stdin);for(p=i=0;s[i];++i){if(strchr("GHOSghos",s[i])){if(p)p--;else break;}else if(strchr("PELpel",s[i]))p++;}j=i-(s[i]==0);while(j--)printf("_");printf("<%s",s+i);}

C ++, 315 373 327 바이트

(참고 : 여전히 골프)

#include <iostream>
#include <string>
using namespace std;
int main(){string input;getline(cin, input);
if(input.find("Pac-Man loses")!=string::npos||input.find("Pacman loses")!=string::npos)
    cout<<"<"<<input.substr(15,input.length()-1);
else{for(unsigned i=0;i<=input.length();++i)
    cout << "_";
cout<<"<";
}return 0;
}

루비 (119 바이트)

q=i=0;a=$**" ";a.split(//).each{|c|q+=((c+?p=~/[ple]/i)^1)-((c+?g=~/[ghos]/i)^1);q<0?break : i+=1};p ?_*i+?<+a[i..-1]

내가 이것에 익숙하지 않아서 누락 된 것들이있을 것입니다 ...

루비는 내 친구입니다 :)

Perl, 54 (52 + 2) 바이트

s/([pel](?1)*[ghos]|[^ghos
])*/'_'x(length$&).'<'/ei

요구는 -p명령 줄 옵션에 지정합니다.

설명:

이 -p옵션을 사용하면 명령문이 읽기-수정-인쇄 루프로 랩핑되며, 각 루프 반복 중에 $_라인 분리 문자를 포함한 입력 라인이 포함됩니다.

정규식은 Retina 답변과 거의 동일합니다.

검색 패턴을 ([pel](?1)*[ghos]|[^ghos ])*"허용 가능"이라고합니다. 그런 다음 재귀 적으로 다음과 같이 정의 할 수 있습니다.

다음과 같은 경우 문자열이 "허용됩니다".

• 그것은에 문자 PELLET이외 T의 문자 뒤에 허용 문자열 뒤에, GHOST제외 T.
• 개행 문자가 아닌 GHOST것을 제외하고 는 문자 T가 아닙니다.
• 허용되는 문자열의 개수 (0 포함)를 연결 한 것입니다.

이 정의는 유령보다 많은 펠릿을 허용합니다. PEL캐릭터는 펠렛 문자 또는 비 고스트 문자로 일치 될 수 있습니다.

빈 문자열은 허용되는 것으로 간주되므로 정규식은 위치 0에서 일치하며 가장 긴 허용 가능한 하위 문자열이 일치합니다.

그런 다음 허용 가능한 가장 긴 하위 문자열은 길이가 같은 밑줄과 일치하고 그 뒤에옵니다 <.