Вы, наверное, знаете риторический вопрос о том , наполовину ли стакан или наполовину пуст . Я немного устал от этой фразы, поэтому я решил, что пришло время программно устранить эту путаницу в отношении наполненности или пустоты стекла.

Ваша задача - написать программу, которая принимает ASCII-изображение уродливого стекла и выводит ASCII-изображение соответствующего красивого стакана . Он также должен решить , следует ли стекло full, mostly full, mostly emptyили emptyи выход этого , а также (любой 4 константы, различные выходные значения делать).

TL; DR

Ввод - это ASCII-изображение стекла ( #символов) и жидкости ( a-z), распределенных случайным образом внутри и снаружи стекла. Жидкость в стакане падает и накапливается на дне, а жидкость снаружи выбрасывается. Выведите ASCII art из стекла после того, как жидкость осядет на дне. Определите, насколько наполнен стакан, и выведите его.

Гадкие и красивые очки

Стекла в целом представляет собой контейнер , сделанный из #символов с дном, двумя боковыми стенками и без верха.

• У действительных очков нет отверстий в них. (Все #персонажи должны быть связаны.)
• В #каждой строке входного ASCII-текста либо будет по крайней мере два символа, либо ни одного. Там не будет строки с ровно одним #.
• Верхняя строка входного ASCII-текста всегда будет иметь ровно две #.
• Действительные очки имеют ровно один локальный минимум в своей разделительной стенке #символов. Это означает, что жидкость не может где-то попасть в ловушку.
• У разграничивающей стены стакана не будет локальных максимумов.
• Там не будет ничего #ниже дна стекла.
• Внутреннее стекло всегда будет соединенным пространством .
• На входе могут быть пробелы в начале / конце и новые строки.

Примеры действительных и недействительных очков:

VALID (possible input to your program):

#  # 
#  # 
#### 

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

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

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


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


INVALID (you won't get one of those as input to your program):

#  #
   #  Has a hole.
####

#      #
   #  #  This is also considered a hole.
    ##

#   #
 # #  Less than two # on a line.
  #

## #
 # #  More than two # on the first line.
 ###

   #
 # #  Less than two # on the first line.
 ###

#               #
 #     #       #  More than one local minimum.
  #   # #     #   Liquid might get trapped.
   ###   #   #
          ###

#  #
#  #
####  Interior is not a connected space.
#  #
#  #
####

#   #
#   #######
#   ###   #
#   ##   #  Has a local maximum.
#   #   #
#      #
#     #
######

#    #
#    #
#     #
 #####
 #  #    <--- # below the bottom of the glass.

#     #
#  #  #  This is also a glass with a hole. The #'s aren't all connected.
#  #  #
#     #
#######

Некрасиво стекло представляет собой стекло с жидкостью просто плавает вокруг в его интерьере.

• Жидкость представлена ​​строчными буквами a-z.
• Там не будет жидкости выше первой строки #символов. Это означает, что нет необходимости допускать попадание жидкости в стекло.
• Может быть жидкость вне стекла . Эта жидкость будет выброшена при превращении уродливого стакана в хороший стакан.

Примеры некрасивых очков :

        # y    b #      i
   x   v#p  q   l#   l
  a     # a   zj # p   g
     g  #ppcg   c#
   u    #  r   n #   r
        ##########
Discard    Keep    Discard

                   <-- There will never be liquid above the glass
   #  tz  g#
    #y abc # d
 av z#ox s #  l
   c#y abth# b
   #vg y rm#   a
    ########
 e   a  b c  d     <-- Discard this as well (not within interior)

Приятно стекло является стеклом , где вся жидкость накопилась в нижней части.

• Снизу вверх внутренняя часть красивого стакана состоит из ряда строк, которые полностью заполнены буквами, за которыми следует не более одной строки, которая не полностью заполнена буквами, а затем несколько строк, которые являются пустыми.
• Не может быть никакой жидкости за пределами хорошего стекла.

Превращение уродливого стакана в хороший стакан

• Жидкость внутри стекла падает и накапливается на дне.
• Жидкость снаружи стекла выбрасывается.
• При превращении уродливого стакана в красивый стакан, точные буквы в нем должны быть сохранены. Например, если у уродливого стакана есть три a, то у хорошего стакана тоже должно быть три a. (Сода не превращается внезапно в воду.)
• Буквы внутри красивого стакана не нужно заказывать.
• Форма стекла должна быть сохранена. Никакие #символы не могут быть добавлены или удалены.
• Допускается любое количество пробелов в начале / в конце, а также переводы строк.

Определение наполненности стекла

• Стакан - это fullесли все его внутреннее пространство заполнено буквами.
• Это mostly fullесли 50% или более внутреннего пространства заполнено.
• Это mostly emptyесли заполнено менее 50% внутреннего пространства.
• Это emptyесли в стекле нет букв.
• Может быть любое количество дополнительных новых строк и пробелов между художественным стеклом ASCII и выходом наполненности.
• Программа может выводить любые отличные (но постоянные!) Значения для 4 уровней наполненности стекла, она не должна печатать точные строки выше. Пожалуйста, укажите, какое значение представляет какой уровень наполненности.

Примеры ввода / вывода

Example 1 input:

        # y    b #      i
   x   v#p  q   l#   l
  a     # a   zj # p   g
     g  #ppcg   c#
   u    #  r   n #   r
        ##########

Example 1 output:

        #        #       
        #        #    
        #        #      
        #ppcglqb #
        #yprazjnc#    
        ##########
mostly empty

Example 2 input:

   #  tz  g#
    #y abc # d
 av z#ox s #  l
   c#y abth# b
   #vg y rm#   a
    ########
 e   a  b c  d

Example 2 output:

   #       #
    #   bc #  
     #oxysa#   
    #ygabth#  
   #vgtyzrm#    
    ########
mostly full

Example 3 input:

#      #
#  g   # f
 ###ih #  d
a c #  # e
 b  ####

Example 3 output:

#      #
#      #  
 ###  g#   
    #hi#  
    ####
mostly empty

Example 4 input:

#ab# 
#cd# 
#### 

Example 4 output:

#cb# 
#da# 
#### 
full

Example 5 input:

  #        # h
   #      #
  a #    # g
   b#    #  f
 c  #    #  
     #  #  e
   d  ##

Example 5 output:

  #        #  
   #      #
    #    #  
    #    #   
    #    #  
     #  #   
      ##
empty

Example 6 input:

# b  az#
#y s ###
###### t
  l  u

Example 6 output:

#  z   #
#ybsa###
######  
mostly full

Example 7 input:

#   # g
# b #f
#  c###
#da ### i
#  e###
##### h

Example 7 output:

#   #
#   #
#   ###
#de ###
#abc###
#####
mostly empty

Разное

• Это код гольф, поэтому выигрывает самый короткий ответ.
• Если возможно, предоставьте ссылку на онлайн-переводчика, который можно использовать для запуска вашей программы на предоставленных входных данных, например, tio.run

Сетчатка , 56 байт

T%` l`!`^.*?#|[^#]+$
O` |\w
*`!
 
T`#!¶
*M` \w
+` \w

 +

Попробуйте онлайн!

Выходная кодировка 0\n0для полного,0\n1 для пустого, 1\n0для в основном полного и 1\n1для в основном пустого (другими словами, первый бит указывает «в основном», а второй бит указывает «пустой»).

объяснение

T%` l`!`^.*?#|[^#]+$

Мы начинаем с превращения всех пробелов и букв за пределами стекла в !. Это делается путем сопоставления либо начала строки до первого, #либо путем сопоставления конца строки, не содержащего a, #и транслитерации всех пробелов и букв в этих совпадениях.

O` |\w

Сортировать все пробелы и буквы. Так как буквы имеют более высокие кодовые точки, чем пробелы, это сортирует все буквы до конца, то есть до дна стакана. Это также происходит для сортировки букв между собой, но порядок букв в результате не имеет значения.

*`!
 

Пробный прогон: распечатать результат замены всех ! пробелов, но на самом деле не применяйте это изменение к рабочей строке. Это печатает хороший стакан.

T`#!¶

Выбросьте все #, !и символы новой строки, так что мы только оставили с пробелами и буквами внутри стекла (все еще отсортирован).

*M` \w

Пробный прогон: выведите количество совпадений пробела, за которым следует буква. При этом будет найдено не более одного совпадения, и это только в том случае, если внутри стакана были и пробелы, и буквы, т.е. бокал в основном (полный / пустой).

+` \w

Повторно удалите пробел, за которым следует буква. Это «отменяет» буквы и пробелы, так что в итоге мы получаем только тот тип символов, который чаще появляется внутри стекла.

 +

Подсчитайте количество совпадений этого регулярного выражения, которое показывает, 1остались ли какие-либо пробелы (т. Е. Стакан был [в основном] пуст) и 0если осталось не осталось (т. Е. Стакан был ровно на 50% или более и, следовательно, [в основном] заполнен ).

C 190 байт

Спасибо @ l4m2 за сохранение 17 байт!

i,k,t,s;f(char*g){char*p=g,l[strlen(g)];for(s=t=0;*p;*p>35&&(t?l[i++]=*p:1)?*p=32:0,~*p++&t&&++s)t^=*p==35;for(k=i;i;t&*p==32?*p=l[--i]:0)t^=*--p==35;printf("%s\n%d",g,k?k-s?k*2<s?1:2:3:0);}

Выходы 0 для пустого стакана, 1 для в основном пустого, 2 для в основном заполненного и 3 для полного.

Сначала проходит по входной строке, считая пространство внутри стекла, размечая буквы внутри стекла и меняя все буквы на пробелы. Затем перебирает строку назад, помещая все буквы, которые были в стакане в нижней части стакана.

Попробуйте онлайн!

раскатали:

i,k,t,s;
f(char*g)
{
    char l[strlen(g)], *p=g;
    for (s=t=0; *p; *p>35&&(t?l[i++]=*p:1)?*p=32:0, ~*p++&t&&++s)
        t ^= *p==35;
    for (k=i; i; t&*p==32?*p=l[--i]:0)
        t ^= *--p==35;
    printf("%s\n%d", g, k?k-s?k*2<s?1:2:3:0);
}

Python 2 , 342 байта

import re
def f(g):
 g=[l for l in g if'#'in l];s,w,l,W=zip(*[re.findall(r'([^#]*)(#+)'*2,l)[0] for l in g[:-1]]);a=sorted(''.join(l));R=len(a);r=a.count(' ');L=[]
 for x in l:L+=[''.join(a[:len(x)])];a=a[len(x):]
 for l in zip([' '*len(x)for x in s],w,L,W)+[re.sub('[^#]',' ',g[-1]),'mostly '*(0<r<R)+['full','empty'][r>R/2]]:print''.join(l)

Попробуйте онлайн!

Perl 5 , 197 байт

map{/#([^#]+)#/;$l.=$1;y/#/ /c}@a=grep/#/,<>;$f=length$l;$_=$l=~y/ //d/$f;$a[--$i]=~s/#( +)#/'#'.(substr$l,0,($q=length$1),"").$"x($q-$p).'#'/e while$p=length$l;say for@a;say'm'x($_!=int),$_>.5?e:f

Попробуйте онлайн!

Выходы:

 e  empty
me  mostly empty
mf  mostly full
 f  full