Language agnostic 高尔夫守则：流水 挑战

按字符计数的最短代码，用于从输入中识别和标记土地ASCII表示中的洼地

输入将是景观的ASCII表示，包括丘陵、山谷和平地。程序应该模拟如果被洪水淹没，景观会是什么样子——用水填满所有山谷（character

x

）

横向视图始终以字符

\uuu

开始和停止，长度至少为2个字符，输入最短

\u

山丘被定义为凸起，不应充满水：

  __
_/  \_

山谷被定义为洼地，充满水，直到遇到平地：

_    _
 \__/

可以假定输入是干净的，并且只由字符空格（

）、换行符（

\n

）、下划线（

\u

）以及前后斜杠（

/

和

\

）组成。输入可以看作是一条连续的线，任何包含不明确的线输入的输入，如

\uu/\uu

或

_   _
 \_/
 / \

被认为是无效的

对于水下洞穴，如果洞穴水位高于水位，则应保持水位

测试用例

---

---

代码计数包括输入/输出（即完整程序）。

C-741 621 600个字符（但正确处理新案例）

$gcc water.c&./a.out0？'x'：
S、 int k；for（k=0；kw？x:w；}for（p=S，e=d[N]；pRuby，794 759 769 752 715 692 663 655 626 616
其他测试用例：
及
及

压缩，缩进除外：

def g i,j,&f
  t=[-1,0,1]
  t.each{|r|next if@w[i][j,1]=='_'&&r>0
    t.each{|c|a=i+r
      b=j+c
      if a>=0&&b>=0&&a<@r&&b<@c
        @t[a]||=[]
        if r!=0&&c!=0
          k=@w[a][j,1]
          l=@w[i][b,1]
          next if/[\/\\]/=~k+l&&((k!=l)||((r<=>0)==(c<=>0)?k!='\\': k!='/'))
        end
        e=@w[a][b,1]
        z,@t[a][b]=@t[a][b],1
        return 1if !z&&(e==' '||r>=0&&e=='_')&&yield(a,b,f)
      end}}
  nil
end
w=$stdin.readlines
@c=w.map{|e|e.size}.max-1
@w=w=w.map{|e|e.chomp.ljust@c}
z=w.map{|e|e.dup}
@r=w.size
@r.times{|r|@m=r
  @c.times{|c|e=w[r][c,1]
    z[r][c]='x'if(e==' '||e=='_')&&(@t=[]
      !g(r,c){|u,v,f|u>=@m and v==0||v==@c-1||g(u,v,&f)})&&(@t=[]
      g(r,c){|u,v,f|u==0||g(u,v,&f)})}}
puts z

def g i、j和f
t=[-1,0,1]
t、 每个{r}下一个if@w[i] [j，1]==''和&r>0
t、 每个{c | a=i+r
b=j+c
如果a>=0&&b>=0&&a=@m和v==0 | | v==c-1 | | g（u，v，f）}）和（@t=[]
g（r，c）{| u，v，f | u==0 | | g（u，v，f）}
放z
Python，702805794 778 758 754 710 651
处理DigitalRoss的测试用例，以及大型测试用例，如

示例运行
Perl，534 545 550 566 569 567 578 594 596
这个挑战的灵感来自于用户@gnibbler的想法，以及最近在月球上发现的水。嗯，我没有想到这一点，谢谢你指出——我将修改示例来展示它。是仅仅是我，还是@Abel的pastebin示例看起来有点脏？一个可以捕捉气泡的洞穴怎么样？Okay、 我现在就躲到我的非法洞穴里去。哇！看看那些空格！还有那些
'
字符文字！还有所有那些局部变量！我不知道你能把多少变量声明塞进全局变量中，但至少，你可以
#定义c char
来缩短所有这些声明，并更改字符将文本转换为原始数字。
#定义w，而
如果没有名为
w
的变量，则可能会有所帮助。此外，为什么有变量（
w1
）用一个两个字符的名字？我自己会打一点高尔夫球，但我还有期末考要做。你们怎么读？有没有工具可以快速将代码重新格式化为可读的？@DigitalRoss-在2D世界中，物理是不同的，那些通道太小，水分子无法通过…：）亚伦，回来，我们需要你！这在Pär Wieslander的超级案例以及我的新测试中也失败了。在你修好它之前，我们不知道它到底有多大！：-）@mqbt：通过“缩进”运行它是个好主意：哇，只有两个解决方案，大小差不多，一个被否决？没有评论？很难理解…是的-所有的驾车仇恨是怎么回事？我能理解不是投赞成票，而是投反对票+1只是为了抵消仇恨。这一个很好，但在更大的测试用例（如@Pär Wieslander）上由于堆栈溢出而失败，您的超级用例在1.8.7和1.9.1p243上对我都有效。（在1.9上快得多。：-）如果我在irb中运行它，那么ps（1）报告在运行期间内存增长约6MB。你有ulimit套装吗？@DigitalRoss，是的，它现在适合我了。虽然之前已获得“超过最大递归深度”，但现在无法复制。我想我一定是搞砸了什么。不适用于Wow，一个迭代解决方案，循环嵌套4深。有趣。
Input:
                                         __       ___
                                        /  \_____/
                                       / _______
                         ________     /  \     /
                   _____/        \   /__  \    \_
    ____          /               \    /__/   __/
        \_       /                 \     ____/
          \______\                 /____/

Output:
                                         __       ___
                                        /  \xxxxx/
                                       / _______
                         ________     /  \     /
                   _____/        \xxx/__  \xxxx\_
    ____          /               \xxxx/__/xxxxx/
        \xxxxxxxx/                 \xxxxxxxxx/
          \xxxxxx\                 /xxxx/

Input:
                                                      __     _
    _       ____                    ____        _____/  \   /
     \     /    \        __________/    \    __/  ___   /___\
      \___/      \       \               \   \___/  /_
                 /________\               \___________\

Output:
                                                      __     _
    _       ____                    ____        _____/  \xxx/
     \xxxxx/    \xxxxxxxxxxxxxxxxxx/    \xxxxxx/  ___   /xxx\
      \xxx/      \xxxxxxx\               \xxx\___/xx/_
                 /xxxxxxxx\               \xxxxxxxxxxx\

$ gcc water.c && ./a.out < test6.txt 
                                     __       ___    
                                    /  \xxxxx/       
                                   / _______         
                     ________     /  \     /         
               _____/        \xxx/__  \xxxx\_        
____          /               \xxxx/__/xxxxx/        
    \xxxxxxxx/                 \xxxxxxxxx/           
      \xxxxxx\                 /xxxx/                

#include<stdio.h>
char d[99][99],*p,*e,*z,*s=d,c,S=' ',D='-',O='.',U='_';n,w,x,N=99,i;
g(y){for(i=0;!i;p+=N,e+=N){i=*p==D;for(z=p;z!=e;z+=y){if(*z!=O&&*z!=
D)break;*z=*z==O?S:U;}}}f(char*n,int r){if(*n==O||*n==D){*n=r>0?'x':
S;int k;for(k=0;k<9;k++)f(n+k/3*N-N+k%3-1,r+k/3-1);}}main(){for(p=s;
gets(p);p+=N,n++){x=strlen(p)-1;w=x>w?x:w;}for(p=s,e=d[N];p<s+N;p++)
{for(i=1,z=p;z<e;z+=N)c=*z,c==0?*z=c=S:0,i?c==S?*z=O:c==U?*z=D:0:0,(
c=='/'&&z[1]!=U)||(c=='\\'&&z[-1]!=D)||c==U?i=1-i:0;}p=s;e=s+w;g(1);
p=s+w;e=s;g(-1);for(p=s;p<s+w;p++){for(z=p;*z==S;z+=N);f(z,1);}for(i
=0;i<n;i++)printf("%.*s\n",w+1,d[i]);}

def g i,j,&f
  t=[-1,0,1]
  t.each{|r|next if@w[i][j,1]=='_'&&r>0
    t.each{|c|a=i+r
      b=j+c
      if a>=0&&b>=0&&a<@r&&b<@c
        @t[a]||=[]
        if r!=0&&c!=0
          k=@w[a][j,1]
          l=@w[i][b,1]
          next if/[\/\\]/=~k+l&&((k!=l)||((r<=>0)==(c<=>0)?k!='\\': k!='/'))
        end
        e=@w[a][b,1]
        z,@t[a][b]=@t[a][b],1
        return 1if !z&&(e==' '||r>=0&&e=='_')&&yield(a,b,f)
      end}}
  nil
end
w=$stdin.readlines
@c=w.map{|e|e.size}.max-1
@w=w=w.map{|e|e.chomp.ljust@c}
z=w.map{|e|e.dup}
@r=w.size
@r.times{|r|@m=r
  @c.times{|c|e=w[r][c,1]
    z[r][c]='x'if(e==' '||e=='_')&&(@t=[]
      !g(r,c){|u,v,f|u>=@m and v==0||v==@c-1||g(u,v,&f)})&&(@t=[]
      g(r,c){|u,v,f|u==0||g(u,v,&f)})}}
puts z

$ python runningwater.py < test4.txt                   
                                           ____________________________
                                          /           
                                   _      \        __
                                  / \xxxxx/       /  \
                  ___       _____/  /xxx/        /    \
____________     /   \xxxxx/   ____/xxx/ __     /xxxxxx\ 
            \xxx/    /xxxxx\__ \xxxxxx/ /xx\___/xxxxxxx/
                 ___/xxxxxxxxx\____    /xxxxxxxxxxxxxx/
                /xxxxx/      \xxxxx\__/x/    \xxxxxxx/
               /xxxxx/        \xxxxxxxx/      \xxxxx/
               \xxxxx\    _________            \xxx/
                  \xxx\  /xxxxxxxxx\           /xx/
                     \x\ \x\   /\ \x\         /xx/
    __________        \x\ \x\_/x/ /x/        /xx/
   /xxxxxxxxxx\        \x\ \xxx/ /x/        /xx/
  /xxxxxxxxxxxx\        \x\ \x/ /x/        /xx/
  \xxxxxxxxxxxxx\        \x\   /x/        /xx/
         \xxxxxxx\        \x\_/x/        /xx/
     ____/xxx/ \xx\        \xxx/        /xx/
     \xxxxxx/   \xx\___________________/xx/
      \xx/       \xxxxxxxxxxxxxxxxxxxxxxx/

import sys
q=sys.stdin.readlines()
e=enumerate
s=type
k=int
o=[]
t=[0]*max(map(len,q))
n=1
L=[]
l={}
for p,d in e(q):
 w=a=0;o+=[[]]
 for i,c in e(d):
  T=t[i];C=[[c,T]];D=d[i+1:];b=0;o[-1]+=C;L+=C
  if c in'_ ':
   if('/'in D or '\\'in D)*(T%2-1)*w*p:
    for j in range(max(i-1,0),min(i+2,len(o[p-1]))):R=o[p-1][j][0];b=R*(k==s(R))or b
    for x in L:x[0]=b*(x[0]==a)or x[0]
    a=C[0][0]=b or a or n
  elif c in'\\/':w=1;a=0;n+=1
  D=d[i-1]+c;t[i-1]+=(D=='/_');t[i]+=(c in'_/\\')+(D=='_\\')
for i,a in e(o):
 for c,r in a:
  if(r==0)*(s(c)==k):l[c]=1
 for j,(c,r)in e(a):
  if(c in l)-1:a[j]=q[i][j],0
 print''.join((k==s(x))*'x'or x for x,r in a),

sub i{$a=1;$a^=substr(x.$l[$_],$_[0],3)=~/^(.[_y]|.\/[^_]|[^_]\\)/for 0..$r-1;
$a}sub f{$c=$e-$s;$_=$l[$r];$f=s/(.{$s})(.{0,$c})/$1<$2>/;(/[ _x]>/&i$e-1and$f=
/>[ _xy]*[\\\/]/,$e=$+[0]-2)or/[ _]*>/,$e=$-[0]-1;(/<[ _x]/&i$s and$f&=
/[\\\/][ _xy]*</,$s=$-[0])or/<[ _]*/,$s=$+[0]-1;$f&$s<$e&&substr($l[$r],$s,$e-$s
)=~s!([\\/][ _xy]*)([\\/][ _]*)!($t=$1)=~y/ _/xy/,$t.$2!eg,$r--&&&f}$q=@l=<>;
while($q--){i$-[0]+1and substr($l[$r--],$-[1],length$1)=~y/_y/x/,$s=$-[0],$e=
$+[0],$q&&f while$l[$r=$q]=~m~\\/|[\\/]([_y]+)[\\/]~g}y/y/x/,print for@l

__      _
  \__  /
    /_/