Tengo un montón de varillas hexagonales pegadas en una extraña escultura. Las varillas son de 1 a 99 centímetros (cm) de largo y 1 cm cuadrado en el área de la sección transversal. Todas las varillas están pegadas en una cara hexagonal al menos a otra varilla. Las varillas están todas alineadas en su borde inferior.

Después de algunas fuertes lluvias, la escultura está llena de agua. ¿Cuánta agua contiene?

Entrada

Su programa debe leer (a través de stdin o un archivo) una serie de líneas que consisten en pares de espacios y pares de dígitos que especifican la longitud de las barras en este formato:

  aa  bb
cc  dd  ee
  ff  gg

Cada barra (como dd aquí) está pegada a un máximo de 6 barras circundantes como se muestra en los ejemplos. Las barras faltantes son agujeros y no acumulan agua. Por ejemplo, la entrada

  04  04
04  01  03
  04  04

representaría la siguiente escultura:

La barra central es de altura 1(no encontré un buen ángulo donde esa barra también sea visible). Ahora la columna sobre esa barra podría contener 2 cm de agua, antes de que se desbordara sobre la 3barra de la derecha. Como ninguna de las otras barras puede contener agua sobre ellas, la respuesta sería 2. Aquí hay dos ejemplos más complejos:

Example 2:
55  34  45  66
  33  21  27
23  12  01  77
  36  31  74
answer = 35 (  2 on top of 21 
             +11 on top of 12
             +22 on top of 01, before everything overflows over 23)

Example 3:
        35  36  77  22                      23  32  54  24
      33  07  02  04  21                  54  07  07  07  76
    20  04  07  07  01  20              54  11  81  81  07  76
  20  67  67  22  07  01  78          54  07  81  07  81  09  76
20  67  07  67  22  22  07  44  55  54  07  81  07  07  61  07  20
  67  57  50  50  07  07  14  03  02  15  81  99  91  07  81  04
67  07  50      50  87  39  45  41  34  81  07  07  89  07  81  79
  67  07  50  50  07  07  07  27  07  27  81  07  07  79  81  78
20  67  67  07  07  07  07  99  33  46  02  81  07  07  81  01  20
  33  07  07  01  05  01  92          20  02  81  07  81  15  32
    22  07  20  20  07  20              63  02  80  81  15  32
      45  20  01  20  39                  20  15  07  15  32
        23  20  20  29  43  21  18  41  20  66  66  43  21
      90                  99  47  07  20
    50                      20  02  48
  70                          56  20
                                90

answer = 1432

Salida

Su programa debería generar un solo entero que dé el volumen de agua en centímetros cúbicos.

Puntuación

Su puntaje es el recuento de bytes de su código fuente. Las victorias más bajas.

Las lagunas estándar están prohibidas como de costumbre.

Este rompecabezas fue inspirado por una pregunta SPOJ .

Python 2, 222 bytes

import sys
y=h=v=0;B={}
for l in sys.stdin:
 z=y;y+=2j
 while l:
    if"0"<l:B[z]=int(l[:2])
    l=l[2:];z+=1
while B:C=B;B={b:B[b]for b in B if(h<B[b])+sum(3>abs(c-b)for c in B)/7};a=C==B;h+=a;v+=a*sum(h>B[b]for b in B)
print v

Lee la entrada a través de STDIN y escribe el resultado en STDOUT.

Explicación

Comenzamos en cero y aumentamos gradualmente el nivel del agua de la siguiente manera: supongamos que el nivel del agua es h , y queremos agregar 1 centímetro de agua. Llamaremos hexágonos de altura ho menos, los que están a punto de hundirse (o ya están) bajo el agua, " sumergidos ". El agua se derramará a través de cualquier hexágono sumergido que no esté rodeado por seis vecinos. Eliminamos todos esos hexágonos; Por supuesto, ahora algunos otros hexágonos sumergidos pueden tener menos de seis vecinos, y también deben ser eliminados. Continuamos de esta manera hasta la convergencia, es decir, hasta que todos los hexágonos sumergidos restantes tengan exactamente seis vecinos. En este punto, sumamos el número de hexágonos sumergidos (el volumen de agua ganado) al recuento total e incrementamos el nivel del agua.

Finalmente, todos los hexágonos habrán sido eliminados y nos detendremos.

Rubí 299

f=->i{s={}
l=i.lines
y=0
l.map{|r|x=0
r.scan(/../){s[[x,y]]=[v=$&.to_i,v<1?0:99];x+=1}
y+=1}
loop{break if s.map{|c,r|x,y=c
m = [[-1,-1],[1,-1],[-2,0],[2,0],[1,-1],[1,1]].map{|w,z|s[[x+w,y+z]]}.map{|n|n ?n[0]+n[1]:0}.min
r[1]=[0,m-r[0]].max if r[0]+r[1]>m&&r[1]>0}.none?}
s.map{|c,r|r[1]}.reduce :+}

Breve descripción del algoritmo:

• analiza la entrada y para cada barra guarda una matriz de dos elementos de la forma [rod_height, water_height]
• las barras se colocan en un hash y se indexan por sus coordenadas x, y
• la parte de fuga de agua tiene en cuenta la altura de la barra / agua de los vecinos inmediatos

Una versión un poco más legible está disponible aquí: http://ideone.com/cWkamV

Ejecute la versión de golf en línea con pruebas: http://ideone.com/3SFjPN