Inspiré par cela . Aucun avocat n'a été blessé dans la réalisation de ce défi.

Bonjour, j'ai un défi, j'ai besoin d'aide pour extraire un avocat, j'ai donc besoin d'un programme pour me dire combien de temps

Observez cet avocat d'art ASCII:

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

Cet avocat se compose d'un extérieur de #s (spécifiquement les première et dernière séquences de #s sur chaque ligne) et d'une fosse (une forme de #s dans l'avocat qui ne touche pas l'extérieur de l'avocat).

Grâce à des expériences rigoureuses sur ces avocats d'art ASCII, j'ai découvert ce qui suit:

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

Par exemple, cet avocat prendra 26 (2 espaces à l'intérieur de la fosse * 13) minutes à jus et donnera 23 (19 espaces à l'intérieur de l'avocat mais à l'extérieur de la fosse + 2 * 2 espaces à l'intérieur de la fosse) fl oz de jus.

Défi

Étant donné une entrée d' exactement un avocat d'art ASCII tel que celui ci-dessus qui se compose uniquement de #et d'espaces, affichez le temps en minutes qu'il faudra pour le jus et la quantité de jus qu'il produira dans n'importe quel ordre.

Vous pouvez supposer que l'avocat d'entrée aura toujours exactement une fosse et que l'avocat et la fosse seront toujours fermés. La fosse et l'avocat seront toujours connectés, et tout sous-ensemble de la fosse sera également connecté. L'avocat et la fosse seront toujours convexes. Notez que l'extérieur de l'avocat peut être arbitrairement épais.

Exemples d'entrées et de sorties

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


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

C'est le code-golf , donc le code le plus court en octets l'emporte.

Pyth, 59 51 octets

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

Essayez-le ici!

Affiche le temps de juic de l'advacado (anglais totalement correct) en premier et sur la ligne suivante la quantité de juic.

Explication

Code - Présentation

* Ksm / .sssd \ \ # \ \ fq4l: T "# +" 4.z13 + - / s.sR \ .zdK * 2K # .z = liste de toutes les lignes d'entrée

                    fq4l: T "# +" 4.z # Obtenez les pit-lines
   m / .sssd \ \ # \ \ # Mappez les lignes des stands sur la quantité d'espace blanc
 Ks # Additionne le nombre d'espaces de fosse et attribue à K
* 13 # Imprimer l'heure juic
                                     /s.sR \ .zd # Compter tous les espaces blancs dans l'advacado
                                    - K # En soustraire la taille de la fosse
                                   + * 2K # Effectuez le reste du calcul du montant et imprimez-le

Des explications détaillées des parties de calcul de taille voir ci-dessous.

Obtenir la taille de l'avocat

Regardons celui-ci:

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

Les espaces blancs avant et arrière sont d'abord supprimés. Après cela, nous emballons tout sur une seule ligne, ce qui donne cette chaîne:

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

Celui-ci contient tous les espaces dans l'advacado, nous devons donc simplement les compter (l'advacado sera toujours convexe, donc cela fonctionne pour toutes les entrées valides). Ce nombre contient toujours les espaces dans la fosse, mais pour le calcul de la quantité de jus, nous n'avons besoin que des espaces dans le fruit sans les espaces dans la fosse. Nous devons donc aussi les calculer.

Le code pour cela expliqué en détail:

/s.sR \ .zd # .z = liste de toutes les lignes d'entrée

  .sR \ .z # supprime les espaces de chaque ligne d'entrée
 s # Concatène toutes les lignes
/ d # compte tous les espaces

Obtenir la taille de la fosse

C'est un peu plus compliqué. Nous supprimons d'abord les lignes qui ne contribuent pas à la taille de la fosse. Cela se fait en filtrant toutes les lignes qui ont moins de 4 groupes de hachages (en utilisant l'expression régulière #+et en comptant ses correspondances). Dans l'exemple ci-dessus, une seule ligne survivra à ce processus:

  #  #--# #

Les espaces que j'ai marqués d'un -ici sont ceux que nous devons compter. Nous supprimons donc simplement les espaces, puis les hachages, puis les espaces à nouveau, ce qui nous laisse avec ceci:

#  #

Là, il suffit de compter les espaces. Nous faisons tout cela pour chaque ligne qui a survécu au processus de filtrage, résumons tout et nous avons terminé. Le reste est des mathématiques triviales.

Le code pour cela expliqué en détail:

sm / .sssd \ \ # \ \ fq4l: T "# +" 4.z # .z = liste de toutes les lignes d'entrée

                  f .z # filtre l'entrée
                     l: T "# +" 4 # longueur des correspondances pour l'expression régulière `# +`
                   q4 # s'il y a 4 groupes de hachages c'est une ligne de fosse
 m # mappe les lignes des stands à ...
  / \ # Les occurrences d'espaces dans ..
   .sssd \ \ # \ # ... la ligne de fosse dépouillée (voir explication ci-dessus)
s # Additionner toutes les quantités d'espaces dans les stands

Rétine , 70

• 25 octets économisés grâce à @FryAmTheEggman et @randomra

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

Essayez-le en ligne.

Python, 141 119 octets

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