Es gibt kein "halb leeres Glas"

15

Sie kennen wahrscheinlich die rhetorische Frage, ob ein Glas halb voll oder halb leer ist . Ich bin der Redewendung ein wenig überdrüssig geworden und habe beschlossen, dass es Zeit ist, diese Verwirrung über die Fülle oder die Leere des Glases programmatisch zu beseitigen.

Ihre Aufgabe ist es, ein Programm zu schreiben, das eine ASCII-Grafik eines hässlichen Glases aufnimmt und eine ASCII-Grafik eines entsprechenden schönen Glases ausgibt . Es hat auch zu entscheiden , ob das Glas full, mostly full, mostly emptyoder emptyund Ausgang dieses auch (alle 4 konstant, unterschiedliche Ausgangswerte tun).

TL; DR

Die Eingabe ist eine ASCII-Grafik aus Glas ( #Zeichen) und Flüssigkeit ( a-z), die zufällig innerhalb und außerhalb des Glases verteilt wird. Die Flüssigkeit im Glas fällt nach unten und sammelt sich am Boden. Die Flüssigkeit außerhalb des Glases wird verworfen. Geben Sie eine ASCII-Grafik des Glases aus, nachdem sich die Flüssigkeit am Boden abgesetzt hat. Bestimmen Sie, wie voll das Glas ist, und geben Sie es auch aus.

Hässliche und schöne Brille

Ein Glas ist im Allgemeinen ein Behälter aus #Zeichen mit einem Boden, zwei Seitenwänden und keiner Oberseite.

  • Gültige Gläser haben keine Löcher. (Alle #Charaktere müssen verbunden sein.)
  • #In jeder Zeile der Eingabe-ASCII-Grafik sind entweder mindestens zwei Zeichen enthalten oder keine. Es wird keine Linie mit genau einer geben #.
  • Die oberste Zeile der Eingabe-ASCII-Grafik enthält immer genau zwei #.
  • Gültige Brillen haben genau ein lokales Minimum in ihrer begrenzenden Zeichenwand #. Dies bedeutet, dass keine Flüssigkeit irgendwo eingeschlossen werden kann.
  • Die Begrenzungswand eines Glases hat keine lokalen Maxima.
  • Es gibt keine #unter dem Boden des Glases.
  • Das Innere des Glases wird immer ein zusammenhängender Raum sein .
  • Möglicherweise enthält die Eingabe führende / nachfolgende Leerzeichen und Zeilenumbrüche.

Beispiele für gültige und ungültige Brillen:

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

Ein hässliches Glas ist ein Glas, in dessen Innerem Flüssigkeit herumschwimmt.

  • Flüssigkeit wird durch Kleinbuchstaben dargestellt a-z.
  • Über der ersten Zeichenzeile befindet sich keine Flüssigkeit #. Dies bedeutet, dass keine Flüssigkeit in das Glas gelangen muss.
  • Möglicherweise befindet sich Flüssigkeit außerhalb des Glases . Diese Flüssigkeit wird verworfen, wenn das hässliche Glas in ein schönes Glas umgewandelt wird.

Beispiele für hässliche Brillen :

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

Ein schönes Glas ist ein Glas, in dem sich die gesamte Flüssigkeit am Boden angesammelt hat.

  • Das Innere eines schönen Glases besteht von unten nach oben aus einer Reihe von Zeilen, die vollständig mit Buchstaben gefüllt sind, gefolgt von höchstens einer Zeile, die nicht vollständig mit Buchstaben gefüllt ist, und einer Reihe von Zeilen, die leer sind.
  • Außerhalb des Inneren eines schönen Glases darf sich keine Flüssigkeit befinden.

Umwandlung eines hässlichen Glases in ein schönes Glas

  • Die Flüssigkeit im Glas fällt nach unten und sammelt sich am Boden.
  • Flüssigkeit außerhalb des Glases wird verworfen.
  • Wenn Sie ein hässliches Glas in ein schönes Glas verwandeln, müssen die genauen Buchstaben darin erhalten bleiben. Zum Beispiel, wenn das hässliche Glas drei ahat, muss das schöne Glas auch drei haben a. (Soda verwandelt sich nicht plötzlich in Wasser.)
  • Die Buchstaben im schönen Glas müssen nicht bestellt werden.
  • Die Form des Glases muss erhalten bleiben. Es #dürfen keine Zeichen hinzugefügt oder entfernt werden.
  • Beliebig viele führende / nachfolgende Leerzeichen und Zeilenumbrüche sind zulässig.

Bestimmung der Glasfülle

  • Ein Glas ist, fullwenn sein gesamter Innenraum mit Buchstaben gefüllt ist.
  • Es ist, mostly fullwenn 50% oder mehr des Innenraums gefüllt ist.
  • Es ist, mostly emptywenn weniger als 50% des Innenraums gefüllt ist.
  • Es ist, emptywenn keine Buchstaben im Glas sind.
  • Es kann eine beliebige Anzahl zusätzlicher Zeilenumbrüche und Leerzeichen zwischen dem ASCII-Grafikglas und der Ausgabe des Füllstands geben.
  • Das Programm kann unterschiedliche (aber konstante!) Werte für die 4 Stufen der Glasfülle ausgeben, es muss nicht die exakten Zeichenfolgen oben drucken. Bitte geben Sie an, welcher Wert für welchen Füllstand steht.

I / O-Beispiele

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

Sonstiges

  • Dies ist Codegolf, also gewinnt die kürzeste Antwort.
  • Stellen Sie nach Möglichkeit einen Link zu einem Online-Interpreter bereit, mit dem Sie Ihr Programm auf den bereitgestellten Beispieleingaben ausführen können , z. B. tio.run
code-golf  ascii-art  classification 
— Jonathan S.
quelle
1
Sind das gültige Tassen? paste.ubuntu.com/26097168
— l4m2
Darf ich vorschlagen: "Ein Glas ist meistens voll, wenn mehr als 50% des Innenraums gefüllt sind." - Wenn Sie dann genau 50% als ungültige Eingabe betrachten (ohne dass die Lösungen für diesen Fall erforderlich sind), gibt es wirklich kein "halb leeres Glas" (oder ein "halb volles Glas") mehr, das noch besser zum Titel passt . Ohne dass Lösungen ungültig werden, die diesen Fall tatsächlich behandeln.
— Anedar
1
@ l4m2 Die Herausforderung wurde aktualisiert und die Eingabe noch weiter eingeschränkt. Das erste Ihrer Beispiele ist ungültig, das zweite ist gültig, das dritte ungültig.
— Jonathan S.
@Anedar Wenngleich die Herausforderung dadurch besser zum Titel passt, würde dies meiner Meinung nach die Herausforderung zu sehr beeinträchtigen und es gibt ohnehin schon genügend ungültige Eingaben. Ich werde den 50% Fall dort belassen.
— Jonathan S.

Antworten:

12

Netzhaut , 56 Bytes

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

 +

Probieren Sie es online!

Die Ausgabecodierung ist 0\n0für voll, 0\n1für leer, 1\n0für größtenteils voll und 1\n1für größtenteils leer (mit anderen Worten, das erste Bit gibt "größtenteils" und das zweite Bit "leer" an).

Erläuterung

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

Wir beginnen damit, alle Leerzeichen und Buchstaben außerhalb des Glases in zu verwandeln !. Dies erfolgt durch Abgleichen eines Zeilenanfangs bis zum ersten #oder durch Abgleichen eines Zeilenendes, das kein a enthält, #und Transliterieren aller Leerzeichen und Buchstaben in diesen Übereinstimmungen.

O` |\w

Sortieren Sie alle Leerzeichen und Buchstaben. Da Buchstaben höhere Codepunkte als Leerzeichen haben, werden alle Buchstaben bis zum Ende sortiert, dh bis zum Glasboden. Dies geschieht auch, um die Buchstaben untereinander zu sortieren, aber die Reihenfolge der Buchstaben im Ergebnis ist irrelevant.

*`!

Probelauf: Gibt das Ergebnis des Ersetzens !durch Leerzeichen aus, wendet diese Änderung jedoch nicht auf die Arbeitszeichenfolge an. Dies druckt das schöne Glas.

T`#!¶

Entsorgen Sie alle #, !und Zeilenvorschübe, so dass wir nur mit den Räumen links und Buchstaben im Glas (noch sortiert).

*M` \w

Trockenlauf: Gibt die Anzahl der Übereinstimmungen eines Leerzeichens gefolgt von einem Buchstaben aus. Dies wird höchstens eine Übereinstimmung finden, und das nur, wenn sich sowohl Leerzeichen als auch Buchstaben im Glas befinden, dh das Glas ist meistens (voll / leer).

+` \w

Entfernen Sie wiederholt ein Leerzeichen, gefolgt von einem Buchstaben. Dies "löscht" Buchstaben und Leerzeichen, so dass wir nur die Art von Zeichen erhalten, die im Glas häufiger vorkommt.

 +

Zählen Sie die Anzahl der Übereinstimmungen mit dieser Regex, die angibt, 1ob noch Leerzeichen vorhanden sind (dh das Glas war [meistens] leer) und 0ob keine mehr vorhanden sind (dh das Glas war zu genau 50% oder mehr und daher [meistens] voll) ).

— Martin Ender
quelle
4

C 190 Bytes

Vielen Dank an @ l4m2 für die Einsparung von 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);}

Gibt 0 für leeres Glas, 1 für größtenteils leeres, 2 für größtenteils volles und 3 für volles Glas aus.

Durchlaufen Sie zunächst die Eingabezeichenfolge und zählen Sie den Platz im Glas, markieren Sie die Buchstaben im Glas und ändern Sie alle Buchstaben in Leerzeichen. Dann zieht man sich rückwärts durch die Schnur und platziert alle Buchstaben, die sich im Glas befanden, am unteren Rand des Glases.

Probieren Sie es online!

Abgerollt:

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
quelle
globale Variablen sind anfänglich 0, daher ist eine erneute
— Aktivierung
@ l4m2 Danke, aber Funktionen müssen wiederverwendbar sein , also muss ich die Variablen innerhalb der Funktion initialisieren. Es sieht iaber so aus, als würde die Funktion am Ende immer den Wert 0 belassen.
— Steadybox
· Char * malloc (strlen (g)) · kann sein, char l[strlen(g)]wenn C99 erlaubt ist, da es kürzer ist und kein Speicherleck verursacht
— l4m2
t = *p-35 ? t : !t-> t ^= *p==35wenn t immer 0 oder 1 ist
— 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)

Probieren Sie es online!

— TFeld
quelle
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

Probieren Sie es online!

Ausgänge:

 e  empty
me  mostly empty
mf  mostly full
 f  full
— Xcali
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.