Davon inspiriert . Bei dieser Herausforderung wurden keine Avocados verletzt.

Hallo, ich habe eine Herausforderung, ich brauche Hilfe beim Entsaften einer Avocado, also brauche ich ein Programm, das mir sagt, wie lange es dauert, bis ich Avocad entsaftet habe

Beachten Sie diese ASCII Art Avocado:

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

Diese Avocado besteht aus einem Äußeren von #s (insbesondere der ersten und letzten Folge von #s in jeder Zeile) und einer Vertiefung (einer Form von #s in der Avocado, die das Äußere der Avocado nicht berührt).

Durch rigorose Experimente mit diesen ASCII-Kunstavocados habe ich Folgendes entdeckt:

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

Zum Beispiel benötigt diese Avocado 26 (2 Felder innerhalb der Grube * 13) Minuten für den Saft und gibt 23 (19 Felder innerhalb der Avocado, aber außerhalb der Grube + 2 * 2 Felder innerhalb der Grube) fl oz Saft.

Herausforderung

Bei einer Eingabe von genau einer ASCII-Art-Avocado wie der obigen, die nur aus #Leerzeichen und Leerzeichen besteht, geben Sie die Zeit in Minuten aus, die zum Entsaften benötigt wird, und die Saftmenge, die in beliebiger Reihenfolge produziert wird.

Sie können davon ausgehen, dass die eingegebene Avocado immer genau eine Vertiefung hat und sowohl die Avocado als auch die Vertiefung immer geschlossen sind. Die Grube und die Avocado werden immer verbunden, und jede Untergruppe der Grube wird ebenfalls verbunden. Die Avocado und die Grube werden immer konvex sein. Beachten Sie, dass das Avocado-Äußere beliebig dick sein kann.

Beispieleingänge und -ausgänge

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


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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Pyth, 59 51 Bytes

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

Probieren Sie es hier aus!

Gibt die Zeit zum Entsaften der Advacado (vollständig korrektes Englisch) und in der nächsten Zeile die Menge an Saft aus.

Erläuterung

Code - Übersicht

* Ksm / .sssd \ \ # \ \ fq4l: T "# +" 4.z13 + - / s.sR \ .zdK * 2K # .z = Liste aller Eingabezeilen

                    fq4l: T "# +" 4.z # Hole die Grubenlinien
   m / .sssd \ \ # \ \ # Ordnen Sie die Pit-Linien dem Whitespace-Wert zu
 Ks # Summiere die Anzahl der Boxenräume und ordne K zu
* 13 # Drucke die Saftzeit
                                     /s.sR \ .zd # Zähle alle Leerzeichen im advacado
                                    - K # Subtrahiere die Grubengröße davon
                                   + * 2K # Den Rest der Menge berechnen und ausdrucken

Detaillierte Erläuterungen zu den Größenberechnungsteilen finden Sie weiter unten.

Abrufen der advacado-Größe

Schauen wir uns diesen an:

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

Zuerst werden die führenden und nachfolgenden Leerzeichen entfernt. Danach binden wir alles in eine Zeile, was zu dieser Zeichenfolge führt:

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

Dies enthält alle Leerzeichen in der advacado, also müssen wir sie nur zählen (die advacado ist immer konvex, dies funktioniert also für alle gültigen Eingaben). Diese Zahl enthält noch die Felder in der Grube, aber für die Saftmengenberechnung benötigen wir nur die Felder in der Frucht ohne die Felder in der Grube. Also müssen wir sie auch berechnen.

Der Code dafür erklärt im Detail:

/s.sR \ .zd # .z = Liste aller Eingabezeilen

  .sR \ .z # Entfernt Leerzeichen von jeder Eingabezeile
 s # Verketten Sie alle Zeilen
/ d # Zähle alle Leerzeichen

Grubengröße ermitteln

Das ist etwas kniffliger. Zuerst entfernen wir die Linien, die nicht zur Pitgröße beitragen. Dazu werden alle Zeilen mit weniger als 4 Hash-Gruppen herausgefiltert (mithilfe des regulären Ausdrucks #+und durch Zählen der Übereinstimmungen). Im obigen Beispiel überlebt nur eine Zeile diesen Prozess:

  #  #--# #

Die mit einem gekennzeichneten Felder -müssen gezählt werden. Also streifen wir nur Leerzeichen ab, dann Hashes und dann Leerzeichen, was uns dazu veranlasst:

#  #

Dort müssen wir nur die Leerzeichen zählen. Wir machen das alles für jede Zeile, die den Filterprozess überstanden hat, summieren alles und wir sind fertig. Der Rest ist triviale Mathematik.

Der Code dafür erklärt im Detail:

sm / .sssd \ \ # \ \ fq4l: T "# +" 4.z # .z = Liste aller Eingabezeilen

                  f .z # filtert die Eingabe
                     l: T "# +" 4 # Länge der Übereinstimmungen für den regulären Ausdruck "# +"
                   q4 # wenn es 4 Gruppen von Hashes gibt, ist es eine Grubenlinie
 m # ordne die Grubenlinien zu ...
  / \ # Die Vorkommen von Räumen in ..
   .sssd \ \ # \ # ... die abgestreifte Grubenlinie (siehe Erklärung oben)
s # Summe aller Leerzeichen in der Box

Retina , 70

• 25 Bytes gespart dank @FryAmTheEggman und @randomra

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

Probieren Sie es online aus.

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