소개

나는 마술 거울로 가득 찬 방이있다 . 그들은 다른 마술 거울을 제외한 모든 아이템을 복제 할 수있는 신비한 유물입니다. 보다 명확하게, 항목의 복제 버전이 같은 거리에서 미러의 다른쪽에 나타납니다. 그러나 복제 미러와 항목 (원본 또는 복제본) 사이에 다른쪽에 다른 매직 미러가있는 경우 복제본이 형성되지 않습니다. 원본 항목은 미러의 왼쪽이나 오른쪽에있을 수 있으며 복제본은 다른쪽에 나타납니다. 또한 복제 항목 자체는 다른 미러에 의해 복제 될 수 있습니다. 항목은 다른 항목의 복제를 차단하지 않습니다 (복제 위치에 직접있는 경우 제외).

입력

입력은 .#|빈 공간, 항목 및 마술 거울을 나타내는 문자로 구성된 문자열 입니다. 입력에 항상 하나 이상의 매직 미러가 있습니다.

산출

위의 규칙에 따라 각 매직 미러가 가능한 모든 항목을 복제 한 다른 문자열이 출력됩니다. 중복 항목이 나타나는 곳에 빈 공간이 항상 있다고 가정 할 수 있습니다 (따라서 경계를 벗어나지 않습니다).

예

입력 문자열을 고려하십시오

.#.|.....|......#
 A B     C      D

여기서 우리는 명확성을 위해 몇 가지 입장을 표시했습니다. 미러는 Bitem을 복제 A하여 오른쪽으로 끝납니다.

.#.|.#...|......#
 A B     C      D

C그런 다음 미러 는 새 항목을 복제합니다.

.#.|.#...|...#..#
 A B     C      D

미러 C가 방해가되어 A미러 B가 항목을 복제 할 수 없습니다 . 또한 D미러 B가 반대편에 있기 때문에 item을 복제 할 수 없습니다 . 마찬가지로, 미러 B는 방해가 D되므로 미러 C는 항목 이나 그 옆에있는 복제본을 복제 할 수 없으므로 올바른 출력입니다.

다른 예를 들어, 입력을 고려하십시오

.##..#...|#..##...|..##....#.
 AB  C   DE  FG   H  IJ    K

미러 D복제 할 수 A및 B오른쪽에, 그리고 E및 G(가) 왼쪽으로.
C하고 F있는 이미 서로 복제합니다. 끈은

.##.##..#|#..##.##|..##....#.
 AB  C   DE  FG   H  IJ    K

미러 H복제 할 수 있습니다 E, F그리고의 중복 A과 B오른쪽 및 I왼쪽으로.
G하고 J있는 이미 서로의 복제, 그리고 거울 D의 방법입니다 K. 이제 우리는

.##.##..#|#..#####|#####..##.
 AB  C   DE  FG   H  IJ    K

마지막으로, 미러 D는 I왼쪽에 복제본을 복제 할 수 있습니다 . 우리는 결국

.#####..#|#..#####|#####..##.
 AB  C   DE  FG   H  IJ    K

규칙과 득점

전체 프로그램이나 함수를 작성할 수 있습니다. 가장 낮은 바이트 수가 이깁니다. 정규식 엔진을 사용하지 않는 제출물은 정규식 엔진을 사용하지 않는 제출물과 경쟁하며 (정규식 없음) 으로 표시 될 수 있습니다 .

테스트 사례

"|" -> "|"
"..|.." -> "..|.."
".#.|..." -> ".#.|.#."
"..#|.#." -> ".##|##."
".#..|....|.." -> ".#..|..#.|.#"
".|..|.#....." -> "#|#.|.#....."
"...|.#...|....#" -> ".##|##...|...##"
"......#|......." -> "......#|#......"
".#.|.....|......#" -> ".#.|.#...|...#..#"
".......|...#.##|...." -> "##.#...|...#.##|##.#"
"...#..||.......#..#...#" -> "...#..||.......#..#...#"
".##|.#....||#||......#|.#" -> ".##|##....||#||.....##|##"
".##..#...|#..##...|..##....#." -> ".#####..#|#..#####|#####..##."
".#|...||...|#...|..##...|#...." -> ".#|#..||.##|##..|..##..#|#..##"
"....#.|...#.|..|.|.....|..#......" -> "..#.#.|.#.#.|.#|#|#.#..|..#.#...."
"..|....|.....#.|.....|...|.#.|..|.|...#......" -> ".#|#...|...#.#.|.#.#.|.#.|.#.|.#|#|#..#......"

답변

+`([#.])(([#.])*\|(?>(?<-3>[#.])*))(?!\1)[#.]
#$2#

([#.])            # Match and capture a non-mirror cell.
(                 # This will match and capture everything up to its corresponding
                  # cell so that we can write it back in the substitution.
  ([#.])*         #   Match zero or more non-mirror cells and push each one onto
                  #   group 3. This counts the distance from our first match to
                  #   the mirror.
  \|              #   Match the mirror.
  (?>             #   Atomic group to prevent backtracking.
    (?<-3>[#.])*  #     Match non-mirror while popping from group 3.
  )               #   There are three reasons why the previous repetition
                  #   might stop:
                  #   - Group 3 was exhausted. That's good, the next position
                  #     corresponds to the first character we matched.
                  #   - We've reached the end of the string. That's fine,
                  #     the last part of the regex will cause the match to fail.
                  #   - We've hit another mirror. That's also fine, because
                  #     the last part of the regex will still fail.
)
(?!\1)            # Make sure that the next character isn't the same as the first
                  # one. We're looking for .|# or #|., not for #|# or .|.
[#.]              # Match the last non-mirror character.

s/([.#])(\||[^|](?2)[^|])(?!\1)[^|]/#$2#/&&redo

perl -plE 's/([.#])(\||[^|](?2)[^|])(?!\1)[^|]/#$2#/&&redo' <<< ".##..#...|#..##...|..##....#."

r=reverse
s=span(<'|')
m=zipWith min
g a|(b,l:c)<-s a,(d,e)<-s c=b++l:g(m(r b++[l,l..])d++e)|0<1=a
f x=m(g x)$r.g.r$x

for($t=$argv[1];$t!=$s;)$t=preg_replace("%([.#])(\||[.#](?2)[.#])(?!\g1)[.#]%","#$2#",$s=$t);echo$t;

void t(char*a){int x=0;for(int i=0;a[i];i++)if(a[i]=='|'){for(int j=x;a[j]&&j<=i*2-x;j++){if((a[j]==35)&&(a[2*i-j]==46)){a[2*i-j]=35;i=-1;}if((i-j)&&(a[j]=='|'))break;}x=i+1;}}

void t(char*a)
{
    int x=0;
    for(int i=0;a[i];i++)
        if(a[i]=='|')
        {
            for(int j=x;a[j]&&j<=i*2-x;j++)
            {
                if((a[j]=='#')&&(a[2*i-j]=='.'))
                {
                    a[2*i-j]='#';
                    i=-1;
                    break;
                }
                if((i!=j)&&(a[j]=='|'))
                    break;
            }
            x=i+1;
        }
}

s=>s.replace(/#/g,(c,i)=>(g(i,-1),g(i,1)),g=(i,d,j=h(i,d))=>j-h(j=j+j-i,-d)|s[j]!='.'||(s=s.slice(0,j)+'#'+s.slice(j+1),g(j,d)),h=(i,d)=>s[i+=d]=='|'?i:s[i]?h(i,d):-1)&&s

function mirror(s) {
    for (var i = 0; i < s.length; i++) {
        // Reflect each # in both directions
        if (s[i] == '#') s = reflect(reflect(s, i, true), i, false);
    }
    return s;
}
function reflect(s, i, d) {
    // Find a mirror
    var j = d ? s.indexOf('|', i) : s.lastIndexOf('|', i);
    if (j < 0) return s;
    // Check that the destination is empty
    var k = j + (j - i);
    if (s[k] != '.') return s;
    // Check for an intervening mirror
    var l = d ? s.lastIndexOf('|', k) : s.indexOf('|', k);
    if (l != j) return s;
    // Magically duplicate the #
    s = s.slice(0, k) + '#' + s.slice(k + 1);
    // Recursively apply to the new #
    return reflect(s, k, d);
}