Mis disculpas por la palabrería. Nos divertimos con eso en el trabajo en nuestro golf interno, pero requirió algunos correos electrónicos para aclarar, así que espero haber captado la mayor parte de eso la primera vez.

PROBLEMA

Dada una instantánea de nevada "simulada" (como una cadena, stdin o parámetro para su función / método), informe sobre 4 valores: profundidad mínima, profundidad máxima, profundidad promedio y duración.

Aquí hay un ejemplo formateado para ilustrar la entrada:

* * **     
** * ***    
** *  *    
*          
--------

El '*' es un copo de nieve y el '-' es el suelo. Imagina todos esos "copos de nieve" cayendo hacia el suelo. Esta es la última "instantánea":

*      
*          
** * **    
********    
--------

Necesita informar sobre:

1. Profundidad mínima: cuente la "pila" más corta (1, en el ejemplo anterior)
2. Profundidad máxima: cuente la "pila" más alta (4, en el ejemplo anterior)
3. Profundidad media: recuento promedio de todas las "pilas" (1.9, en el ejemplo anterior, redondeando a décimas)
4. Duración - (cada "caída" = 1 segundo) - tiempo desde la primera instantánea hasta la última instantánea (3 segundos, en el ejemplo anterior)

Otro ejemplo de referencia:

     * 
   *   *
      *
*      
--------

Instantánea final:

*  * ***
--------

ENTRADA

La "instantánea" inicial tendrá 8 "filas", 8 "columnas" y estará delimitada por tuberías (las tuberías separan las filas). Por ejemplo (excluyendo comillas):

“        |        |        |        |     *  |   *   *|      * |*       |--------” 

SALIDA

Los 4 valores delimitados por tuberías en una sola línea: 0 | 1 | .6 | 3 o 0 | 5 | 1 | 1

Perl, 128 caracteres

map{$d++;s/\*/$d{$-[0]}++;$t&&$t<$d or$t=$d/ge}split'\|',<>;map{$A+=$_/8}@m=sort values%d;printf"$m[0]|$m[-1]|%.1f|%d\n",$A,8-$t

Python, 153 caracteres

s=raw_input()
R=range(8)
C=[s[i::9].count('*')for i in R]
print"%d|%d|%.1f|%d"%(min(C),max(C),sum(C)/8.,max(8-s[i::9].find('*')-C[i]for i in R if C[i]))

Windows PowerShell, 180 189

$a=(0..7|%{$x=$_;-join(0..7|%{$s[$_*9+$x]})})
$b=$a-replace' '|%{$_.length}|sort
"{0}|{1}|{2:.0}|{3}"-f($b[-1..0]+(($b-join'+'|iex)/8),($a|%{($_-replace'^ +|\*').length}|sort)[-1])

La entrada viene como $s.

Historia:

• 2011-02-10 01:53 (189) - Primer intento.
• 2011-02-10 02:03 (180) - Formatear cadena al rescate. Único inconveniente: genera números en formato regional, ya no se ajusta estrictamente a la especificación de la tarea. Aún así, ese es un problema compartido por la solución C # también, así que supongo que está bien.

Un par de otros resultados de nuestro golf interno:

C #, 188 caracteres (fácil de leer)

int a = 0, b = 8, c = 0, d = 0, f, i, j, x;    
for (i = 0; i < 8; i++)    
{    
      f = x = 0;    
      for (j = 0; j < 8; )
            if (s[i + j++ * 9] == '*')    
            {    
                  x = x > 0 ? x : 9 - j;    
                  f++;    
            }         

      d += f;    
      a = f > a ? f : a;    
      b = f < b ? f : b;    
      c = x - f > c ? x - f : c;    
}

Console.Write("{0}|{1}|{2:.0}|{3}", b, a, d / 8f, c);

Ruby, 173 caracteres

s=gets;n=8;a=o=l=0;8.times{|i|f=x=0;8.times{|j|if(s[i+j*9].chr=='*'):x=8-j if x==0;f+=1;end}
o+=f;a=f if f>a;n=f if f<n;l=x-f if x-f>l}
printf "%d|%d|%.1f|%d",n,a,o.to_f/8,l

PHP, 139 bytes

<?for(;$y<8;$y++)for($x=0;++$n[$x],$x<8;$x++)'!'>$argv[1][$y*9+$x]&&--$n[$x]?$b[$x]++:0;print_r([min($n),max($n),array_sum($n)/8,max($b)]);

para cada columna, cuente no. de copos de nieve y no. de espacios debajo del primer copo de nieve, luego calcular
toma la cadena como argumento desde la línea de comando

Desglose y pasos de golf

$i=$argv[1];
for(;$y<8;$y++)         # $y=row
{
    for($x=0;$x<8;$x++) # $x=column
    {
        // loop body: 32+26=58 bytes
        if('*'==$i[$p=$y*9+$x])$n[$x]++;# if snowflake: increase snowflakes count
        elseif($n[$x]+=0)$b[$x]++;      # elseif has snowflakes: increase blanks count
                                        # +=0: min needs a value in every column

        // -> golf if/elseif to ternaries, 16+9+25+1 = 51 (-7)
#       '*'==$i[$y*9+$x]
#           ? $n[$x]++
#           : (($n[$x]+=0)?$b[$x]++:0)
#       ;

        // golfing on the ternary, 15+23+9+1 = 48 (-3)
#       '!'>$i[$y*9+$x]                 # -1: char<'!' <=> char==' '
#           ? ($n[$x]+=0)?$b[$x]++:0    # -2: inverted condition -> eliminated parens
#           : $n[$x]++
#       ; # 15+23+9+1-2=46

        // increase snowflakes count in any case (initialization)
        // (needs curlies; elminate them by moving increase to the for condition)
        // decrease snowflakes count for blank
#       ++$n[$x];if('!'>$i[$y*9+$x]&&--$n[$x])$b[$x]++; # if: 47
#       ++$n[$x];'!'>$i[$y*9+$x]&&--$n[$x]?$b[$x]++:0;  # ternary: 46
    }
}
print_r([min($n),max($n),array_sum($n)/8,max($b)]); # calculate and print results

agregar round(...,1)alrededor array_sum($n)/8para redondear (+9)

Mathematica , ~ 115

"        \n        \n* * **  \n        \n** * ***\n** *  * \n*       \n--------"

Most/@ToCharacterCode@%~Partition~9/10-16/5
Min@#|Max@#|Mean@#~Round~.1|Position[#,1][[{-1,1},1]].{1,-1}-1&@Total@%

1 | 4 | 1.9 | 4

En esta publicación, tuve que recurrir a la forma de cadena escapada \nya que pegar y copiar pierde espacios. En el Front End puedo ingresarlo así:

JavaScript, 328 bytes

No es particularmente corto, pero es lo que tengo.

var input = "        |        |        |* * **  |        |** * ***|** *  * |*       |--------";

(s=>{var l=s.split("|"),a=[0,0,0,0,0,0,0,0],o=[8,0,0,0],b;for(i=0;i<l.length;i++){if(!b&&l[i]!="        ")o[3]=7-i,b=1;for(j=0;j<l[i].length;j++){a[j]+=l[i][j]=="*"?1:0}}for(i=0;i<a.length;i++){if(a[i]<o[0])o[0]=a[i];if(a[i]>o[1])o[1]=a[i];o[2]+=a[i];}console.log(o[0]+"|"+o[1]+"|"+(o[2]/a.length).toFixed(1)+"|"+o[3]);})(input)

De-golf:

var input = "        |        |        |        |     *  |   *   *|      * |*       |--------";

(s=>{
  var splits = s.split("|");
  var arr = [0,0,0,0,0,0,0,0];
  var b;
  var o=[8,0,0,0];
  for (var i = 0; i < splits.length; i++) {
    if (!b&&splits[i]!="        ") {
      o[3] = 7-i;b=1;
    }
    for (var j = 0; j < splits[i].length; j++) {
      arr[j]+=splits[i][j]=="*"?1:0;
    }
  }
  for (var i = 0; i < arr.length; i++) {
    if (arr[i]<o[0]) {
      o[0]=arr[i];
    }
    if (arr[i]>o[1]) {
      o[1]=arr[i];
    }
    o[2]+=arr[i];
  }
  console.log(o[0]+"|"+o[1]+"|"+(o[2]/arr.length).toFixed(1)+"|"+o[3]);
})(input)