language agnostic - Código Golf: agua corriente

language-agnostic code-golf

Question

El reto

El código más corto por recuento de caracteres para identificar y marcar las depresiones de agua en la representación ASCII de una tierra desde la entrada.

La entrada será una representación ASCII de un paisaje, teniendo colinas, valles y tierras planas. El programa debería simular cómo se vería el paisaje si estuviera inundado, llenando todos los valles con agua (carácter x ).

El paisaje siempre comenzará y se detendrá con el carácter _ y tendrá al menos 2 caracteres de longitud, haciendo la entrada más corta __ .

Una colina se define como un aumento, y no debe llenarse con agua:

 __
_/ /_

Un valle se define como una depresión y se llenará de agua hasta que se encuentre una llanura:

_ _
/__/

La entrada se puede suponer limpia y se compondrá solo del espacio de caracteres ( ), nueva línea ( /n ), guión bajo ( _ ) y barras inclinadas hacia adelante y hacia atrás ( / y / ). La entrada se puede ver como una línea continua y cualquier entrada que contenga entrada de línea ambigua, como _/_ o

_ _
/_/
/ /

Se considera inválido.

Con respecto a las cuevas submarinas, el nivel de agua debe mantenerse si el nivel de la cueva supera el nivel del agua.

Casos de prueba

Input:
__//__
/__
/ ___ ___________
/ / /_ /_
/_____/ /__ _/
//
Output:
__//__
/__
/ ___ ___________
/xxxxxx/ /xxxxxx/_
/xxxxx/ /xxxxx/
//

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

Input:
__ _
_ ____ ____ _____/ / /
/ / / __________/ / __/ ___ /___/
/___/ / / / /___/ /_
/________/ /___________/
Output:
__ _
_ ____ ____ _____/ /xxx/
/xxxxx/ /xxxxxxxxxxxxxxxxxx/ /xxxxxx/ ___ /xxx/
/xxx/ /xxxxxxx/ /xxx/___/xx/_
/xxxxxxxx/ /xxxxxxxxxxx/

El recuento de códigos incluye entrada / salida (es decir, programa completo).

Answer 1

Perl, 534 545 550 566 569 567 578 594 596

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

Esto maneja todos los casos de prueba que he visto. Las líneas nuevas son opcionales y solo están disponibles para el formateo.

Llámalo como eg perl water.pl test.txt .

Aquí hay otro caso de borde divertido (para mi algoritmo de todos modos) no en ninguno de los ejemplos anteriores:

__ _
/__ /
/_/

La versión detallada que pondría antes todavía falla en eso.

Answer 2

Python, 702 805 794 778 758 754 710 651

Maneja casos de prueba de DigitalRoss, así como casos de prueba grandes como pastie.org/708764 .

Ejecución de ejemplo

$ 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/

Código

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

Answer 3

Ruby, 794 759 769 752 715 692 663 655 626 616

Casos de prueba adicionales: http://pastie.org/708281 y http://pastie.org/708288 y http://pastie.org/708310

Comprimido a excepción de la sangría:

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

Answer 4

C - 741 621 600 caracteres (pero maneja los casos nuevos correctamente)

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