Inspirado por isso . Nenhum abacate foi prejudicado na realização deste desafio.

Olá eu tenho desafio, preciso de ajuda juic um abacate, então eu preciso de um programa para me dizer quanto tempo juic avocad para

Observe este abacate de arte ASCII:

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

Esse abacate consiste em um exterior de #s (especificamente a primeira e a última sequências de #s em cada linha) e um caroço (uma forma de #s no abacate que não toca o exterior do abacate).

Através de rigorosas experiências com esses abacates de arte ASCII, descobri o seguinte:

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 exemplo, este abacate levará 26 (2 espaços dentro do poço * 13) minutos para o suco e dará 23 (19 espaços dentro do abacate, mas fora do poço + 2 * 2 espaços dentro do poço) fl oz de suco.

Desafio

Dada a entrada de exatamente um abacate de arte ASCII, como o descrito acima, que consiste apenas em #espaço em branco, produza a quantidade de tempo em minutos que leva para o suco e a quantidade de suco que ele produzirá em qualquer ordem.

Você pode supor que o abacate de entrada sempre terá exatamente um poço e o abacate e o poço sempre estarão fechados. O poço e o abacate sempre estarão conectados e qualquer subconjunto do poço também será conectado. O abacate e o caroço serão sempre convexos. Observe que o exterior do abacate pode ser arbitrariamente espesso.

Amostras de entradas e saídas

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


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

Isso é código-golfe , então o código mais curto em bytes vence.

Pitão, 59 51 bytes

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

Experimente aqui!

Mostra o tempo para juic o advacado (inglês totalmente correto) primeiro e na próxima linha a quantidade de juic.

Explicação

Código - Visão Geral

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

                    fq4l: T "# +" 4.z # Obter as linhas de pit
   m / .sssd \ \ # \ \ # Mapeie as linhas de pit para a quantidade de espaço em branco
 Ks # Soma a quantidade de espaços no poço e atribua a K
* 13 # Imprima o tempo juic
                                     /s.sR \ .zd # Conte todos os espaços em branco no advacado
                                    - K # Subtrair o tamanho do poço
                                   + * 2K # Faça o restante da calibração do valor e imprima-o

Explicações detalhadas das peças de cálculo de tamanho, veja abaixo.

Obtendo o tamanho do advacado

Vamos olhar para este:

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

Primeiro, os espaços em branco à esquerda e à direita são removidos. Depois disso, agrupamos tudo em uma linha, o que resulta nessa string:

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

Como contém todos os espaços em branco no advacado, precisamos apenas contá-los (o advacado sempre será convexo, portanto, isso funciona para todas as entradas válidas). Esse número ainda contém os espaços no poço, mas para o cálculo da quantidade de juic, precisamos apenas dos espaços na fruta sem os espaços no poço. Então, precisamos calculá-los também.

O código para isso explicado em detalhes:

/s.sR \ .zd # .z = lista de todas as linhas de entrada

  .sR \ .z # separa espaços de cada linha de entrada
 s # Concatenar todas as linhas
/ d # Contar todos os espaços

Obtendo o tamanho do poço

Isso é um pouco mais complicado. Primeiro, removemos as linhas que não contribuem para o tamanho do poço. Isso é feito filtrando todas as linhas que possuem menos de 4 grupos de hashes (usando o regex #+e contando suas correspondências). No exemplo acima, apenas uma linha sobreviverá a esse processo:

  #  #--# #

Os espaços que marquei -aqui são os que precisamos contar. Então, apenas separamos os espaços, depois os hashes e depois os espaços novamente, o que nos deixa com isso:

#  #

Lá, apenas temos que contar os espaços. Fazemos tudo isso para todas as linhas que sobreviveram ao processo de filtragem, somamos tudo e terminamos. O resto é matemática trivial.

O código para isso explicado em detalhes:

sm / .sssd \ \ # \ \ fq4l: T "# +" 4.z # .z = lista de todas as linhas de entrada

                  f .z # filtra a entrada
                     l: T "# +" 4 # duração das correspondências para a regex `# +`
                   q4 # se houver 4 grupos de hashes, é uma linha de pit
 m # mapeie as linhas do poço para ...
  / \ # As ocorrências de espaços em ..
   .sssd \ \ # \ # ... a linha do poço despojado (veja a explicação acima)
s # Soma todas as quantidades de espaços nos poços

Retina , 70

• 25 bytes salvos graças a @FryAmTheEggman e @randomra

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

Experimente online.

Pitão, 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