Non esiste un "bicchiere mezzo vuoto"

15

Probabilmente conosci la domanda retorica se un bicchiere è mezzo pieno o mezzo vuoto . Mi sto stancando un po 'della frase, quindi ho deciso che è tempo di eliminare programmaticamente questa confusione sulla pienezza o sul vuoto del vetro.

Il tuo compito è quello di scrivere un programma che prende una rappresentazione di arte ASCII di un brutto vetro e genera un'arte ASCII di un bel vetro corrispondente . Ha anche decidere se il vetro è full, mostly full, mostly emptyo emptye uscita questo pure (ogni 4 costante, valori di uscita distinti fanno).

TL; DR

L'input è un'arte ASCII di un vetro ( #caratteri) e liquido ( a-z) distribuito casualmente all'interno e all'esterno del vetro. Il liquido all'interno del bicchiere cade e si accumula sul fondo, il liquido all'esterno di esso viene scartato. Stampa un'arte ASCII del vetro dopo che il liquido si è depositato sul fondo. Determina quanto è pieno il vetro e produce anche quello.

Occhiali brutti e belli

Un bicchiere in generale è un contenitore fatto di #personaggi con un fondo, due pareti laterali e nessun piano.

  • Gli occhiali validi non presentano buchi. (Tutti i #personaggi devono essere collegati.)
  • Ci saranno almeno due #caratteri in ciascuna riga della grafica ASCII di input, oppure nessuno. Non ci sarà una linea con esattamente una #.
  • La riga superiore dell'input ASCII art ne avrà sempre esattamente due #.
  • Gli occhiali validi hanno esattamente un minimo locale nel loro muro delimitante di #personaggi. Ciò significa che il liquido non può rimanere intrappolato da qualche parte.
  • La parete delimitante di un bicchiere non avrà massimi locali.
  • Non ci sarà alcun #sotto il fondo del vetro.
  • L'interno del vetro sarà sempre uno spazio connesso .
  • Potrebbero esserci spazi iniziali o finali nell'input.

Esempi di occhiali validi e non validi:

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 brutto bicchiere è un bicchiere con liquido che fluttua al suo interno.

  • Il liquido è rappresentato dalle lettere minuscole a-z.
  • Non ci sarà liquido sopra la prima riga di #caratteri. Ciò significa che non è necessario per consentire al liquido di cadere nel bicchiere.
  • Potrebbe esserci del liquido all'esterno del vetro . Questo liquido verrà scartato quando si converte il brutto bicchiere in un bel bicchiere.

Esempi di brutti occhiali :

        # 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 bel bicchiere è un bicchiere in cui tutto il liquido si è accumulato sul fondo.

  • Dal basso verso l'alto, l'interno di un bel vetro è costituito da un numero di linee che sono completamente riempite di lettere, seguite da al massimo una linea che non è completamente riempita di lettere, e quindi un numero di linee che sono vuote.
  • Potrebbe non esserci alcun liquido fuori dall'interno di un bel bicchiere.

Conversione di un brutto bicchiere in un bel bicchiere

  • Il liquido all'interno del bicchiere cade e si accumula sul fondo.
  • Il liquido all'esterno del vetro viene scartato.
  • Quando si converte un brutto bicchiere in un bel bicchiere, le lettere esatte in esso devono essere conservate. Ad esempio, se il brutto bicchiere ha tre a"dentro", anche il bel vetro deve avere tre a". (La soda non si trasforma improvvisamente in acqua.)
  • Non è necessario ordinare le lettere all'interno del bel bicchiere.
  • La forma del vetro deve essere preservata. Nessun #personaggio può essere aggiunto o rimosso.
  • È consentita qualsiasi quantità di spazi vuoti e newline iniziali / finali.

Determinare la pienezza del vetro

  • Un bicchiere è fullse il suo intero spazio interno è pieno di lettere.
  • È mostly fullse il 50% o più dello spazio interno è riempito.
  • È mostly emptyse viene riempito meno del 50% dello spazio interno.
  • È emptyse non ci sono lettere nel bicchiere.
  • Potrebbe esserci un numero qualsiasi di nuove linee e spazi aggiuntivi tra il vetro artistico ASCII e l'output di pienezza.
  • Il programma può generare valori distinti (ma costanti!) Per i 4 livelli di pienezza del vetro, non è necessario stampare le stringhe esatte sopra. Specificare quale valore rappresenta quale livello di pienezza.

Esempi di I / O

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

Varie

  • Questo è il golf del codice, quindi vince la risposta più breve.
  • Se possibile, fornire un collegamento a un interprete online che può essere utilizzato per eseguire il programma sugli input di esempio forniti, ad esempio tio.run
code-golf  ascii-art  classification 
— Jonathan S.
fonte
1
Sono coppe valide? paste.ubuntu.com/26097168
— l4m2
Posso suggerire: "Un bicchiere è per lo più pieno se viene riempito più del 50% dello spazio interno". - Se poi consideri esattamente il 50% come input non valido (senza richiedere le soluzioni per gestire questo caso) non esiste più un "bicchiere mezzo vuoto" (o un "bicchiere mezzo pieno"), abbinando ancora meglio il titolo . Senza invalidare le soluzioni che gestiscono effettivamente questo caso.
— Anedar,
1
@ l4m2 Aggiornato la sfida e limitato ulteriormente l'input. Il primo dei tuoi esempi non è valido, il secondo è valido, il terzo non è valido.
— Jonathan S.
@Anedar Anche se potrebbe far corrispondere meglio la sfida al titolo, questo a mio avviso toglierebbe troppo alla sfida e comunque ha già abbastanza input non validi. Lascio lì il caso del 50%.
— Jonathan S.

Risposte:

12

Retina , 56 byte

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

 +

Provalo online!

La codifica dell'output è 0\n0per pieno, 0\n1per vuoto, 1\n0per lo più pieno e 1\n1per lo più vuoto (in altre parole, il primo bit indica "principalmente" e il secondo bit indica "vuoto").

Spiegazione

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

Iniziamo trasformando tutti gli spazi e le lettere all'esterno del vetro !. Questo viene fatto abbinando un inizio di riga al primo #o abbinando un finale di riga che non contiene un #e traslitterando tutti gli spazi e le lettere in quelle corrispondenze.

O` |\w

Ordina tutti gli spazi e le lettere. Dal momento che le lettere hanno punti di codice più alti degli spazi, questo ordina tutte le lettere fino alla fine, il che significa verso il fondo del vetro. Questo accade anche per ordinare le lettere tra loro, ma l'ordine delle lettere nel risultato è irrilevante.

*`!

Esecuzione a secco: stampa il risultato della sostituzione di tutto !con spazi, ma in realtà non applica questa modifica alla stringa di lavoro. Questo stampa il bel bicchiere.

T`#!¶

Scarta tutti #, !e ritorni a capo, in modo che ci resta solo con gli spazi e le lettere all'interno del vetro (ancora ordinato).

*M` \w

Corsa a secco: stampa il numero di corrispondenze di uno spazio seguito da una lettera. Questo troverà al massimo una corrispondenza, e che solo se ci fossero sia spazi che lettere all'interno del vetro, cioè il vetro è principalmente (pieno / vuoto).

+` \w

Rimuovere ripetutamente uno spazio seguito da una lettera. Questo "annulla" le lettere e gli spazi, in modo da finire con solo quel tipo di carattere che appare più spesso all'interno del vetro.

 +

Conta il numero di corrispondenze di questa regex, che indica 1se sono rimasti spazi (ovvero il vetro era [principalmente] vuoto) e 0se non sono rimasti (ovvero il vetro era esattamente al 50% o più e quindi [principalmente] pieno ).

— Martin Ender
fonte
4

C, 190 byte

Grazie a @ l4m2 per il risparmio di 17 byte!

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

Uscite 0 per bicchiere vuoto, 1 per lo più vuoto, 2 per lo più pieno e 3 per intero.

Per prima cosa scorre attraverso la stringa di input contando lo spazio all'interno del vetro, segnando le lettere all'interno del vetro e cambiando tutte le lettere in spazi. Quindi scorre indietro la corda posizionando tutte le lettere che erano nel bicchiere nella parte inferiore del vetro.

Provalo online!

srotolato:

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
fonte
le variabili globali sono inizialmente 0, quindi non è necessario reinizializzare
— l4m2
@ l4m2 Grazie, ma le funzioni devono essere riutilizzabili , quindi devo inizializzare le variabili all'interno della funzione. Tranne iche sembra, poiché la funzione lascia sempre il suo valore a 0 alla fine.
— Steadybox,
· Char * malloc (strlen (g)) · può essere char l[strlen(g)]se C99 lo consente, poiché è più corto e non
— perde la
t = *p-35 ? t : !t-> t ^= *p==35se t è sempre 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 byte

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)

Provalo online!

— TFeld
fonte
1

Perl 5 , 197 byte

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

Provalo online!

Uscite:

 e  empty
me  mostly empty
mf  mostly full
 f  full
— Xcali
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.