Inspirado por esto . Ningún aguacate fue dañado en la realización de este desafío.

Hola, tengo un desafío, necesito ayuda para exprimir un aguacate, así que necesito un programa que me diga cuánto tiempo debo jugar

Observe este aguacate ASCII art:

    ###### 
   #      #
   # #### #
  #  # p# #
  ## #### #
   #      #
    ######

Este aguacate consiste en un exterior de #s (específicamente la primera y última secuencia de #s en cada línea) y un hoyo (una forma de #s en el aguacate que no toca el exterior del aguacate).

A través de rigurosos experimentos con estos aguacates de arte ASCII, descubrí lo siguiente:

avocado juice in fluid ounces = number of spaces inside avocado but outside pit (the pit is marked with a p in the example) + 2 * number of spaces inside pit

time to juice avocado in minutes = 13 * number of spaces inside pit

Por ejemplo, este aguacate tomará 26 (2 espacios dentro del hoyo * 13) minutos para jugo y dará 23 (19 espacios dentro del aguacate pero fuera del hoyo + 2 * 2 espacios dentro del hoyo) fl oz de jugo.

Desafío

Dada una entrada de exactamente un aguacate de arte ASCII como el anterior que consta solo de #espacios en blanco, genera la cantidad de tiempo en minutos que tomará jugo y la cantidad de jugo que producirá en cualquier orden.

Puede suponer que el aguacate de entrada siempre tendrá exactamente un hoyo y que tanto el aguacate como el hoyo siempre estarán cerrados. El hoyo y el aguacate siempre estarán conectados, y cualquier subconjunto del hoyo también estará conectado. El aguacate y el hoyo siempre serán convexos. Tenga en cuenta que el exterior del aguacate puede ser arbitrariamente grueso.

Entradas y salidas de muestra

    ###### 
   #      #
   # #### #
  #  #  # # -> 26 23
  ## #### #
   #      #
    ######


   #######
  #       #
  #  ###   ##
  #  #  #   # -> 26 35
  #   ##   #
  #        #
  ##########

Este es el código de golf , por lo que gana el código más corto en bytes.

Pyth, 59 51 bytes

*Ksm/.s.s.sd\ \#\ \ fq4l:T"#+"4.z13+-/s.sR\ .zdK*2K

Pruébalo aquí!

Emite el tiempo para exprimir el advacado (inglés totalmente correcto) primero y en la siguiente línea la cantidad de juic.

Explicación

Código - Descripción general

* Ksm / .sssd \ \ # \ \ fq4l: T "# +" 4.z13 + - / s.sR \ .zdK * 2K # .z = lista de todas las líneas de entrada

                    fq4l: T "# +" 4.z # Obtenga las líneas de pozo
   m / .sssd \ \ # \ \ # Asigna las líneas de pits a la cantidad de espacios en blanco
 Ks # Suma la cantidad de espacios en boxes y asigna a K
* 13 # Imprime el tiempo juic
                                     /s.sR \ .zd # Cuenta todos los espacios en blanco en el advacado
                                    - K # Resta el tamaño del hoyo
                                   + * 2K # Haga el resto de la cantidad calculada e imprímala

Las explicaciones detalladas de las partes de cálculo de tamaño se muestran a continuación.

Obteniendo el tamaño de advacado

Veamos este:

    ###### 
   # #
   # #### #
  # # # #
  ## #### # #
   # #
    ######

Primero se eliminan los espacios en blanco iniciales y finales. Después de eso, envolvemos todo en una línea, lo que da como resultado esta cadena:

#######      ## #### ##  #  # ### #### ##      #######

Esto contiene todos los espacios en blanco en el advacado, por lo que solo tenemos que contarlos (el advacado siempre será convexo, por lo que funciona para todas las entradas válidas). Este número todavía contiene los espacios en el hoyo, pero para el cálculo de la cantidad juic solo necesitamos los espacios en la fruta sin los espacios en hoyo. Así que también tenemos que calcularlos.

El código para eso explica en detalle:

/s.sR \ .zd # .z = lista de todas las líneas de entrada

  .sR \ .z # separa espacios de cada línea de entrada
 s # Concatenar todas las líneas
/ d # Cuenta todos los espacios

Obteniendo el tamaño del hoyo

Esto es un poco más complicado. Primero eliminamos las líneas que no contribuyen al tamaño del pozo. Esto se hace filtrando todas las líneas que tienen menos de 4 grupos de hashes (usando la expresión regular #+y contando sus coincidencias). En el ejemplo anterior, solo una línea sobrevivirá a este proceso:

  #  #--# #

Los espacios que marqué con un -aquí son los que necesitamos contar. Entonces, simplemente eliminamos espacios, luego hashes y luego espacios nuevamente, lo que nos deja con esto:

#  #

Allí solo tenemos que contar los espacios. Hacemos todo eso por cada línea que sobrevivió al proceso de filtrado, sumamos todo y listo. El resto es matemática trivial.

El código para eso explica en detalle:

sm / .sssd \ \ # \ \ fq4l: T "# +" 4.z # .z = lista de todas las líneas de entrada

                  f .z # filtra la entrada
                     l: T "# +" 4 # longitud de las coincidencias para la expresión regular `# +`
                   q4 # si hay 4 grupos de hashes es una línea de pozo
 m # mapear las líneas de pozo a ...
  / \ # Las ocurrencias de espacios en ..
   .sssd \ \ # \ # ... la línea del pozo despojado (ver explicación arriba)
s # Suma todas las cantidades de espacios en los hoyos

Retina , 70

• 25 bytes guardados gracias a @FryAmTheEggman y @randomra

T``i` (? <= # + # +) * (? = # + + #)
T``f` # + #
yo
13 $ * iff
((i) | (f) | \ W) +
$ # 2 $ # 3

Pruébalo en línea.

Pitón, 141 119 bytes

import sys
s=str.strip;l=len;o=i=0
for x in sys.stdin:x=s(s(x),'#');y=s(x);o+=l(x)-l(y);i+=l(s(y,'#'))
print o+2*i,13*i