Ispirato da questo . Nessun avocado è stato danneggiato nel fare questa sfida.

Ciao, ho una sfida, ho bisogno di aiuto per juic un avocado, quindi ho bisogno di un programma che mi dica per quanto tempo juic avocad

Osserva questo avocado artistico ASCII:

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

Questo avocado è costituito da un esterno di #s (in particolare la prima e l'ultima sequenza di #s su ciascuna linea) e una fossa (una forma di #s nell'avocado che non tocca l'esterno dell'avocado).

Attraverso rigorosi esperimenti su questi avocado dell'arte ASCII ho scoperto quanto segue:

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

Ad esempio, questo avocado impiegherà 26 minuti (2 spazi all'interno della fossa * 13) per spremere e darà 23 (19 spazi all'interno dell'avocado ma fuori dalla fossa + 2 * 2 spazi all'interno della fossa) fl oz di succo.

Sfida

Dato un input di esattamente un avocado di arte ASCII come quello sopra che consiste solo #e spazi bianchi, emette la quantità di tempo in minuti che ci vorrà per spremerlo e la quantità di succo che produrrà in qualsiasi ordine.

Puoi presumere che l'input avocado avrà sempre esattamente un pit e che sia l'avocado che il pit saranno sempre chiusi. La fossa e l'avocado saranno sempre collegati e anche qualsiasi sottoinsieme della fossa sarà collegato. L'avocado e la fossa saranno sempre convessi. Si noti che l'esterno dell'avocado può essere arbitrariamente spesso.

Ingressi e uscite di esempio

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


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

Questo è code-golf , quindi vince il codice più breve in byte.

Pyth, 59 51 byte

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

Provalo qui!

Produce il tempo necessario per juic prima di advacado (inglese totalmente corretto) e nella riga successiva la quantità di juic.

Spiegazione

Codice - Panoramica

* Ksm / .sssd \ \ # \ \ fq4l: T "# +" 4.z13 + - / s.sR \ .zdK * 2K # .z = elenco di tutte le righe di input

                    fq4l: T "# +" 4.z # Ottieni le pit-line
   m / .sssd \ \ # \ \ # Mappa le linee di fossa per la quantità di spazi bianchi
 Ks # Somma la quantità di spazi di fossa e assegna a K
* 13 # Stampa l'ora juic
                                     /s.sR \ .zd # Conta tutti gli spazi bianchi nel advacado
                                    - K # Sottrae la dimensione della fossa da essa
                                   + * 2K # Esegui il resto del calcolo della quantità e stampalo

Le spiegazioni dettagliate delle parti di calcolo delle dimensioni sono riportate di seguito.

Ottenere le dimensioni dell'avvocato

Diamo un'occhiata a questo:

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

Innanzitutto vengono rimossi gli spazi bianchi iniziali e finali. Dopodiché avvolgiamo tutto in una riga, che risulta in questa stringa:

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

Questo contiene tutti gli spazi bianchi nel advacado, quindi dobbiamo solo contarli (il advacado sarà sempre convesso, quindi funziona per tutti gli input validi). Questo numero contiene ancora gli spazi nella fossa, ma per il calcolo della quantità juic abbiamo bisogno solo degli spazi nella frutta senza gli spazi della fossa. Quindi dobbiamo calcolarli anche noi.

Il codice per quello spiegato in dettaglio:

/s.sR \ .zd # .z = elenco di tutte le righe di input

  .sR \ .z # rimuove gli spazi da ogni riga di input
 s # Concatena tutte le linee
/ d # Conta tutti gli spazi

Ottenere la dimensione della fossa

Questo è un po 'più complicato. Innanzitutto rimuoviamo le linee che non contribuiscono alla dimensione della fossa. Questo viene fatto filtrando tutte le linee che hanno meno di 4 gruppi di hash (usando il regex #+e contando le sue corrispondenze). Nell'esempio sopra solo una riga sopravviverà a questo processo:

  #  #--# #

Gli spazi che ho segnato con un -qui sono quelli che dobbiamo contare. Quindi eliminiamo semplicemente gli spazi, quindi gli hash e quindi gli spazi di nuovo, il che ci lascia con questo:

#  #

Lì non ci resta che contare gli spazi. Facciamo tutto ciò per ogni linea sopravvissuta al processo di filtraggio, sommiamo tutto e il gioco è fatto. Il resto è banale matematica.

Il codice per quello spiegato in dettaglio:

sm / .sssd \ \ # \ \ fq4l: T "# +" 4.z # .z = elenco di tutte le righe di input

                  f .z # filtra l'input
                     l: T "# +" 4 # lunghezza delle corrispondenze per la regex `# +`
                   q4 # se ci sono 4 gruppi di hash è una pit line
 m # mappa le linee di fossa per ...
  / \ # Le occorrenze di spazi in ..
   .sssd \ \ # \ # ... la pit line spogliata (vedi spiegazione sopra)
s # Somma tutte le quantità di spazi nei box

Retina , 70

• 25 byte salvati grazie a @FryAmTheEggman e @randomra

T``i` (? <= # + # +) * (? = # + + #)
T``f` # + #
io
13 $ * se e solo se
((I) | (f) | \ W) +
$ # 2 $ # 3

Provalo online.

Pitone, 141 119 byte

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