आप शायद यह जानते हैं कि एक गिलास आधा भरा हुआ है या आधा खाली है । मैं वाक्यांश से थोड़ा थक गया हूं, इसलिए मैंने फैसला किया कि यह ग्लास फुलनेस या खालीपन के बारे में प्रोग्रामिक रूप से इस भ्रम को खत्म करने का समय है।

आपका कार्य एक प्रोग्राम लिखना है जो एक बदसूरत ग्लास का ASCII कला प्रतिनिधित्व लेता है और एक समान अच्छे ग्लास के ASCII कला को आउटपुट करता है । यह भी तय करना है कि कांच है full, या mostly full, mostly emptyया emptyआउटपुट के रूप में अच्छी तरह से (किसी भी 4 स्थिर, अलग आउटपुट मान करते हैं)।

टी एल; डॉ

इनपुट एक ग्लास ( #अक्षर) और तरल ( a-z) के ASCII कला है जो कांच के अंदर और बाहर यादृच्छिक रूप से वितरित की जाती है। कांच के भीतर तरल नीचे गिरता है और उसके तल पर जमा हो जाता है, इसके बाहर का तरल निकल जाता है। तरल के ASCII कला का उत्पादन तल पर तरल के जमने के बाद होता है। निर्धारित करें कि ग्लास कितना भरा हुआ है और आउटपुट भी।

बदसूरत और अच्छा चश्मा

सामान्य रूप से एक ग्लास एक कंटेनर होता है जिसमें #नीचे, दो साइड की दीवारें और ऊपर कोई पात्र नहीं होता है।

वैध चश्मे में छेद नहीं होते हैं। (सभी #पात्रों को जोड़ा जाना है।)
#इनपुट 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 स्तरों के लिए किसी भी विशिष्ट (लेकिन स्थिर!) मूल्यों का उत्पादन कर सकता है, इसे ऊपर दिए गए सटीक तारों को प्रिंट करने की आवश्यकता नहीं है। कृपया निर्दिष्ट करें कि कौन सा मान किस पूर्णता स्तर का प्रतिनिधित्व करता है।

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

विविध

यह कोड गोल्फ है इसलिए सबसे कम उत्तर जीतता है।
यदि संभव हो, तो कृपया एक ऑनलाइन दुभाषिया को एक लिंक प्रदान करें जिसका उपयोग आपके प्रोग्राम को दिए गए उदाहरण इनपुट पर चलाने के लिए किया जा सकता है, उदाहरण के लिए tio .run

code-golf ascii-art classification

— जोनाथन एस।
स्रोत

1

क्या ये वैध कप हैं? paste.ubuntu.com/26097168

— l4m2

मैं सुझाव दे सकता हूं: "एक गिलास ज्यादातर भरा हुआ है अगर 50% से अधिक आंतरिक स्थान भरा है।" - यदि आप वास्तव में अवैध इनपुट के रूप में 50% मानते हैं (इस मामले को संभालने के लिए समाधानों की आवश्यकता के बिना) वास्तव में "आधा खाली गिलास" (या "आधा पूर्ण गिलास") जैसी कोई चीज नहीं है, तो शीर्षक को और भी बेहतर तरीके से मिलान करना। । वास्तव में इस मामले को संभालने वाले किसी भी समाधान को अमान्य किए बिना।

— आदार

1

@ l4m2 ने अपडेट को चुनौती दी और इनपुट को और भी सीमित कर दिया। आपका पहला उदाहरण अमान्य है, दूसरा वैध है, तीसरा एक अमान्य है।

— जोनाथन एस।

@ आॅनर हालांकि यह चुनौती को खिताब से बेहतर बना सकता है, लेकिन मेरे विचार से यह चुनौती से बहुत दूर होगा और इसके पास पहले से ही पर्याप्त अमान्य इनपुट हैं। मैं वहां 50% केस छोड़ दूंगा।

— जोनाथन एस।

12

रेटिना , 56 बाइट्स

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

 +

इसे ऑनलाइन आज़माएं!

आउटपुट एन्कोडिंग 0\n0पूर्ण के 0\n1लिए है, खाली के लिए, 1\n0अधिकतर पूर्ण के लिए और 1\n1अधिकतर खाली के लिए (दूसरे शब्दों में, पहला बिट "ज्यादातर" इंगित करता है और दूसरा बिट "रिक्त" इंगित करता है)।

व्याख्या

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

हम कांच के बाहर सभी रिक्त स्थान और अक्षरों को मोड़कर शुरू करते हैं !। यह या तो पहले से लाइन-शुरुआत #से मेल खा रहा है या लाइन-एंड से मेल खा रहा है जिसमें ए नहीं है #और उन मैचों में सभी रिक्त स्थान और अक्षरों का अनुवाद करना है।

O` |\w

सभी रिक्त स्थान और अक्षरों को क्रमबद्ध करें। चूँकि अक्षरों में स्थान की तुलना में अधिक कोड अंक होते हैं, इसलिए यह सभी अक्षरों को अंत तक ले जाता है, जिसका अर्थ ग्लास के नीचे होता है। यह आपस में अक्षरों को क्रमबद्ध करने के लिए भी होता है, लेकिन परिणाम में अक्षरों का क्रम अप्रासंगिक है।

*`!

ड्राई रन: सभी !रिक्तियों को बदलने के परिणाम को प्रिंट करें , लेकिन वास्तव में इस बदलाव को कार्यशील स्ट्रिंग पर लागू न करें। यह अच्छा ग्लास प्रिंट करता है।

T`#!¶

सब त्याग दो # , !और पंक्तिबद्ध करें, ताकि हम केवल ग्लास के अंदर रिक्त स्थान और अक्षरों के साथ छोड़ दें।

*M` \w

सूखा रन: एक पत्र के बाद एक स्थान के मैचों की संख्या प्रिंट करें। यह सबसे अधिक एक मैच में मिलेगा, और यह कि यदि ग्लास के अंदर रिक्त स्थान और अक्षर दोनों होते हैं, तो ही ग्लास होता है ज्यादातर (पूर्ण या खाली) होता है।

+` \w

एक पत्र के बाद बार-बार एक स्थान को हटा दें। यह "रद्द" पत्र और रिक्त स्थान, ताकि हम केवल उस प्रकार के चरित्र के साथ समाप्त होते हैं जो कांच के अंदर अधिक बार दिखाई देते हैं।

इस रेगेक्स के मैचों की संख्या की गणना करें, जो यह बताता है 1कि क्या कोई जगह बची है (यानी कांच [ज्यादातर] खाली था) और 0अगर गैर छोड़ दिया गया है (यानी कांच बिल्कुल 50% या अधिक था और इसलिए [ज्यादातर] पूर्ण )।

— मार्टिन एंडर
स्रोत

4

सी, 190 बाइट्स

17 बाइट बचाने के लिए @ l4m2 के लिए धन्यवाद!

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 पूर्ण के लिए।

पहले इनपुट स्ट्रिंग के माध्यम से ग्लास के अंदर के स्थान को गिनते हुए, नीचे अक्षरों को चिह्नित करते हुए, जो ग्लास के अंदर होते हैं, और सभी अक्षरों को रिक्त स्थान में बदलते हैं। फिर स्ट्रिंग के माध्यम से छोरों को पीछे की तरफ सभी अक्षरों को रखकर जो ग्लास के नीचे कांच में थे।

इसे ऑनलाइन आज़माएं!

unrolled:

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
स्रोत

वैश्विक रूप से चंचलता 0 होती है, इसलिए इसे प्रबल करने की आवश्यकता नहीं होती है

— l4m2

@ l4m2 धन्यवाद, लेकिन फ़ंक्शन को पुन: प्रयोज्य होने की आवश्यकता है , इसलिए मुझे फ़ंक्शन के अंदर चर को आरंभीकृत करने की आवश्यकता है। iइसे छोड़कर, ऐसा लगता है कि फ़ंक्शन हमेशा अंत में 0 पर अपना मूल्य छोड़ देता है।

— स्टेडीबॉक्स

· Char * malloc (strlen (g)) · char l[strlen(g)]C99 की अनुमति हो सकती है , क्योंकि यह छोटा है और मेमोरी लीक नहीं करता है

— l4m2

t = *p-35 ? t : !t-> t ^= *p==35अगर t हमेशा 0 या 1

— l4m2

&&(*p=32)-> ?*p=32:0 char l[strlen(g)],*p=g->char*p=g,l[strlen(g)]

— l4m2

1

पायथन 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)

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

1

पर्ल 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

— Xcali
स्रोत

"आधा खाली गिलास" जैसी कोई चीज नहीं है

टी एल; डॉ

बदसूरत और अच्छा चश्मा

एक बदसूरत गिलास का एक अच्छा गिलास में बदलना

कांच परिपूर्णता का निर्धारण

I / O उदाहरण

विविध

रेटिना , 56 बाइट्स

व्याख्या

सी, 190 बाइट्स

पायथन 2 , 342 बाइट्स

पर्ल 5 , 197 बाइट्स