No hay tal cosa como un "vaso medio vacío"

15

Probablemente conozca la pregunta retórica de si un vaso está medio lleno o medio vacío . Me estoy cansando un poco de la frase, así que decidí que es hora de eliminar esta confusión sobre la plenitud o el vacío del vidrio mediante programación.

Su tarea es escribir un programa que tome una representación artística ASCII de un vidrio feo y genere un arte ASCII de un vidrio agradable correspondiente . También tiene que decidir si el vidrio es full, o mostly full, y generar esto también (lo hacen 4 valores de salida constantes y distintos).mostly emptyempty

TL; DR

La entrada es un arte ASCII de un vidrio ( #caracteres) y un líquido ( a-z) distribuidos aleatoriamente dentro y fuera del vidrio. El líquido dentro del vidrio se cae y se acumula en su fondo, el líquido afuera se desecha. Imprima un arte ASCII del vidrio después de que el líquido se haya asentado en el fondo. Determine qué tan lleno está el vidrio y dé salida también.

Gafas feas y bonitas

Un vaso en general es un contenedor hecho de #personajes con una parte inferior, dos paredes laterales y sin parte superior.

  • Las gafas válidas no tienen agujeros en ellas. (Todos los #personajes tienen que estar conectados).
  • Habrá al menos dos #caracteres en cada línea del arte ASCII de entrada, o ninguno. No habrá una línea con exactamente una #.
  • La línea superior del arte ASCII de entrada siempre tendrá exactamente dos #.
  • Las gafas válidas tienen exactamente un mínimo local en su muro de #caracteres delimitador . Esto significa que el líquido no puede quedar atrapado en alguna parte.
  • La pared delimitadora de un vaso no tendrá máximos locales.
  • No habrá ninguna #debajo del fondo del cristal.
  • El interior del vidrio siempre será un espacio conectado .
  • Puede haber espacios en blanco iniciales / finales y nuevas líneas en la entrada.

Ejemplos de gafas válidas e inválidas:

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.
#  #  #
#     #
#######

Un vaso feo es un vaso con líquido flotando en su interior.

  • El líquido está representado por las letras minúsculas a-z.
  • No habrá líquido por encima de la primera línea de #caracteres. Esto significa que no es necesario permitir que el líquido caiga en el vidrio.
  • Puede haber líquido fuera del vaso. . Este líquido se desechará al convertir el vidrio feo en un buen vaso.

Ejemplos de gafas feas :

        # 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)

Un buen vaso es un vaso donde todo el líquido se ha acumulado en el fondo.

  • De abajo hacia arriba, el interior de un bonito vaso consiste en una serie de líneas que están completamente llenas de letras, seguidas, como máximo, de una línea que no está completamente llena de letras, y luego una serie de líneas que están vacías.
  • Es posible que no haya líquido fuera del interior de un buen vaso.

Conversión de un vaso feo en un vaso bonito

  • El líquido dentro del vaso se cae y se acumula en el fondo.
  • El líquido fuera del vidrio se desecha.
  • Al convertir un vaso feo en un vaso bonito, deben conservarse las letras exactas. Por ejemplo, si el vidrio feo tiene tres a's', el buen vidrio también debe tener tres a''. (La soda no se convierte de repente en agua).
  • Las letras dentro del vaso bonito no tienen que ser ordenadas.
  • La forma del vidrio tiene que ser preservada. No #se pueden agregar ni eliminar caracteres.
  • Se permite cualquier cantidad de espacios en blanco iniciales / finales y nuevas líneas.

Determinación de la plenitud del vidrio.

  • Un vaso es fullsi todo su espacio interior está lleno de letras.
  • Es mostly fullsi el 50% o más del espacio interior está lleno.
  • Sus mostly empty si se llena menos del 50% del espacio interior.
  • Es emptysi no hay letras en el cristal.
  • Puede haber cualquier número de nuevas líneas y espacios adicionales entre el vidrio artístico ASCII y la salida de plenitud.
  • El programa puede generar valores distintos (¡pero constantes!) Para los 4 niveles de plenitud del vidrio, no tiene que imprimir las cadenas exactas anteriores. Especifique qué valor representa qué nivel de plenitud.

Ejemplos de E / S

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

Misceláneos

  • Este es el código de golf, por lo que gana la respuesta más corta.
  • Si es posible, proporcione un enlace a un intérprete en línea que pueda usarse para ejecutar su programa en las entradas de ejemplo proporcionadas, por ejemplo tio.run
code-golf  ascii-art  classification 
— Jonathan S.
fuente
1
¿Son estas tazas válidas? paste.ubuntu.com/26097168
— l4m2
Puedo sugerir: "Un vaso está lleno en su mayoría si se llena más del 50% del espacio interior". - Si luego considera exactamente el 50% como entrada inválida (sin requerir las soluciones para manejar este caso), realmente ya no hay tal cosa como un "vaso medio vacío" (o un "vaso medio lleno"), igualando el título aún mejor . Sin invalidar ninguna solución que realmente maneje este caso.
— Anedar
1
@ l4m2 Actualizó el desafío y restringió la entrada aún más. El primero de sus ejemplos no es válido, el segundo es válido, el tercero no es válido.
— Jonathan S.
@Anedar Si bien podría hacer que el desafío coincida mejor con el título, en mi opinión, esto quitaría demasiado del desafío y de todos modos ya tiene suficientes entradas inválidas. Dejaré el caso del 50% allí.
— Jonathan S.

Respuestas:

12

Retina , 56 bytes

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

 +

Pruébalo en línea!

La codificación de salida es 0\n0para lleno, 0\n1para vacío, 1\n0para mayormente lleno y 1\n1para mayormente vacío (en otras palabras, el primer bit indica "mayormente" y el segundo bit indica "vacío").

Explicación

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

Comenzamos convirtiendo todos los espacios y letras fuera del cristal !. Esto se hace combinando una línea que comienza hasta la primera #o combinando una línea que no contiene #ay transliterando todos los espacios y letras en esas coincidencias.

O` |\w

Ordenar todos los espacios y letras. Dado que las letras tienen puntos de código más altos que los espacios, esto ordena todas las letras hasta el final, lo que significa que está en la parte inferior del cristal. Esto también sucede para ordenar las letras entre sí, pero el orden de las letras en el resultado es irrelevante.

*`!

Ejecución en seco: imprima el resultado de reemplazar todo !con espacios, pero en realidad no aplique este cambio a la cadena de trabajo. Esto imprime el bonito vaso.

T`#!¶

Descartar todos #, !y avances de línea, por lo que sólo nos quedamos con los espacios y letras en el interior del vidrio (siendo clasificada).

*M` \w

Ejecución en seco: imprime el número de coincidencias de un espacio seguido de una letra. Esto encontrará como máximo una coincidencia, y eso solo si hubiera espacios y letras dentro del vaso, es decir, el vaso está mayormente (lleno / vacío).

+` \w

Eliminar repetidamente un espacio seguido de una letra. Esto "cancela" letras y espacios, de modo que terminamos con solo ese tipo de carácter que aparece más a menudo dentro del cristal.

 +

Cuente el número de coincidencias de esta expresión regular, que da 1si quedan espacios (es decir, el vaso estaba [en su mayoría] vacío) y 0si no quedan (es decir, el vaso estaba exactamente al 50% o más y, por lo tanto, [en su mayoría] lleno )

— Martin Ender
fuente
4

C, 190 bytes

¡Gracias a @ l4m2 por guardar 17 bytes!

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);}

Salidas 0 para vaso vacío, 1 para vaso vacío en su mayoría, 2 para vaso lleno y 3 para vaso lleno.

Primero recorre la cadena de entrada contando el espacio dentro del cristal, marcando las letras que están dentro del cristal y cambiando todas las letras a espacios. Luego, recorre la cuerda hacia atrás colocando todas las letras que estaban en el cristal en la parte inferior del cristal.

Pruébalo en línea!

Desenrollado:

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);
}
— Steadybox
fuente
las variables globales son inicialmente 0, por lo que no es necesario
— reiniciar
@ l4m2 Gracias, pero las funciones deben ser reutilizables , por lo que necesito inicializar las variables dentro de la función. Excepto ique parece, ya que la función siempre deja su valor en 0 al final.
— Steadybox
· Char * malloc (strlen (g)) · puede ser char l[strlen(g)]si C99 lo permite, ya que es más corto y no
— produce
t = *p-35 ? t : !t-> t ^= *p==35si t es siempre 0 o 1
— l4m2
&&(*p=32) -> ?*p=32:0 char l[strlen(g)],*p=g ->char*p=g,l[strlen(g)]
— l4m2
1

Python 2 , 342 bytes

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)

Pruébalo en línea!

— TFeld
fuente
1

Perl 5 , 197 bytes

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

Pruébalo en línea!

Salidas:

 e  empty
me  mostly empty
mf  mostly full
 f  full
— Xcali
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.