क्या बारिश हो रही है? मैं बता नहीं सकता

Question

ये बारिश की बूंदें हैं:

! | . " :

ये बादल के कण हैं:

( ) _ @ $ &

मैं चाहता हूं कि आप यह सत्यापित करें, जब पाठ को अवरुद्ध किया गया हो, चाहे बारिश हो रही हो या नहीं। बारिश हो रही है, अगर हर बारिश के मौसम के लिए, इसके ऊपर कहीं एक बादल का कण होता है। हर बरसात के लिए एक बादल कण होना चाहिए। अपने निष्कर्षों को निरूपित करते हुए एक सत्य या मिथ्या मूल्य का उत्पादन करें।

मान्य उदाहरण

(@@@@@@)
 ( $ &  )
Q   (  )
..  .  !
 : .
  |"   !
    .

()()()
......

@_$ &
errrr
h_r-5
.:. .
 "

अमान्य उदाहरण

!
()

$$$$$
(   )
:::::
.....

यह एक कोड-गोल्फ है इसलिए पात्रों की जीत में सबसे छोटा कार्यक्रम है ।

Comments

"हर बारिश की बूंदों के लिए एक बादल कण होना चाहिए"

— ब्लू

@ Faersum दूसरा अमान्य उदाहरण वह उदाहरण है जिसे आप ढूंढ रहे हैं।

— Seadrus

@ फ़ेर्सुम मैं देख रहा हूँ;)

— सद्रुस

क्या हम मान सकते हैं कि आयत बनाने के लिए रिक्त स्थान के साथ पंक्तियाँ गद्देदार हैं?

— feersum

@Zereges, नहीं: कम से कम एक

— msh210

Answer 1

एपीएल (30)

{∧/∊≤/+⍀¨⍵∘∊¨'!|.":' '()_@$&'}

यह एक फ़ंक्शन है जो एक चरित्र मैट्रिक्स को इनपुट के रूप में लेता है, और एक बूलियन आउटपुट देता है।

परीक्षा:

      ex1 ex2 ex3 ex4 ex5
┌─────────┬──────┬─────┬──┬─────┐
│(@@@@@@) │()()()│@_$ &│! │$$$$$│
│ ( $ &  )│......│errrr│()│(   )│
│Q   (  ) │      │h_r-5│  │:::::│
│..  .  ! │      │.:. .│  │.....│
│ : .     │      │ "   │  │     │
│  |"   ! │      │     │  │     │
│    .    │      │     │  │     │
└─────────┴──────┴─────┴──┴─────┘
      {∧/∊≤/+⍀¨⍵∘∊¨'!|.":' '()_@$&'}¨ex1 ex2 ex3 ex4 ex5
1 1 1 0 0

स्पष्टीकरण:

• ⍵∘∊¨'!|.":' '()_@$&': दोनों वर्णों (बारिश और बादलों), और ⍵ में प्रत्येक चरित्र के लिए, देखें कि क्या चरित्र सेट का सदस्य है।
• +⍀¨: प्रत्येक कॉलम और प्रत्येक सेट के लिए एक रनिंग योग प्राप्त करें
• ≤/: of में प्रत्येक स्थिति के लिए, जाँच करें कि बारिश की बूंदों की राशि चल रहे योग में बादल कणों की मात्रा से अधिक नहीं है
• ∧/∊: परिणाम में सभी तत्वों के बूलियन और लौटें

Answer 2

सी ++ 11, 186 184 बाइट्स

#include<map>
int i,c;int main(){std::map<int,int>p;while(~(c=getchar())){for(int m:{40,41,95,64,36,38})p[i]+=c==m;for(int m:{33,124,46,34,58})if(c==m&&!p[i]--)return 1;i=c-10?i+1:0;}}

Ungolfed

#include <map>
int i, c;
int main()
{
    std::map<int, int> p;
    while (~(c = getchar()))
    {
//        for (int m : { '(', ')', '_', '@', '$', '&'})
        for (int m : { 40, 41, 95, 64, 36, 38})
            p[i] += c == m;
//        for (int m : { '!', '|', '.', '"', ':'})
        for (int m : { 33, 124, 46, 34, 58})
            if (c == m && !p[i]--)
                return 1;
        i = c - '\n' ? i + 1 : 0;
    }
    return 0;
}

बुनियादी दृष्टिकोण, एक पंक्ति में क्लाउड कणों के भंडारण की स्थिति और अगर बारिश के कण का सामना करना पड़ता है, तो यह जांचता है कि क्या क्लाउड कण इसके ऊपर है और उस स्तंभ में क्लाउड कणों के काउंटर को कम कर देता है। कार्यक्रम 0 पर लौटाता है यदि यह मान्य है और 1 अन्यथा।

Comments

आप को बदल नहीं सकता c-m?0:p[i]++के साथ p[i]+=c==m? या कि अब C ++ 11 में काम नहीं करता है?

— मेरिनस

@marinus शायद हाँ।

— ज़ेरेगस

Answer 3

घोंघे , 125

{t.{t(\(|\)|\_|\@|\$|\&)=(u.,~)d!(.,~)t.!(.,~},!{t(\!|\||\.|\"|\:)ud!(.,~}t(\(|\)|\_|\@|\$|\&)!(d.,~)u.,~},!{t(\!|\||\.|\"|\:

कार्यक्रम ग्रिड के क्षेत्र को आउटपुट करता है (या यदि इसका क्षेत्र 0 है तो बारिश हो रही है); अन्यथा 0. यदि केवल मैंने रेगेक्स-शैली वर्ण वर्ग लागू किया था।

Ungolfed संस्करण में सभी गिबरिश लिखने के बजाय बादलों या बारिश की बूंदों के लिए नकली निर्देश हैं। \whatever( .वास्तविक कार्यक्रम में बदल दिया गया ) का मतलब है कि एक ऐसी चीज़ जो बारिश की बूंद हो, लेकिन वास्तव में कुछ भी हो सकती है क्योंकि अगर हम बादल के लिए गैर-बारिश की बूंद से मेल खाते हैं तो इससे कोई फर्क नहीं पड़ता।

{
    t \whatever   ,, Pick a drop in a new column
    {
        t \cloud ,, Find a cloud with 
        =(u.,~)  ,, nothing above in the same column marked
        !(d.,~)  ,, but not in an empty column
        t \whatever
        !(d.,~)
    },
    !(t \drop ud !(.,~) )  ,,no drops remaining in column
    t \cloud
    !(d.,~)
    u.,~
},             ,, repeated 0 or more times
! (t \drop)   ,, no drops left

Comments

दिलचस्प टिप्पणी प्रणाली।

— सेड्रेस

Answer 4

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

def f(i):
 for l in zip(*i.split('\n')):
  s=0
  for p in l:
   s+=p in'()_@$&';s-=p in'!|.":'
   if s<0:return
 return 1

आयताकार होने के लिए इनपुट को गद्देदार होने की अपेक्षा करता है।

Answer 5

जावास्क्रिप्ट ईएस 6, 112

एक एक्मास्क्रिप्ट 6 अनुरूप ब्राउज़र में एरो फ़ंक्शंस को लागू करने के लिए नीचे स्निपेट का परीक्षण करना, ऑपरेटर और टेम्पलेट स्ट्रिंग्स को फैलाना (मैं उपयोग करता हूं)

f=t=>!t.split`
`.some(r=>[...r].some((c,i)=>(c='!|.":()_@$&'.indexOf(c),n[i]=~c?c<5?~-n[i]:-~n[i]:n[i])<0),n=[])

//TEST
console.log=x=>O.innerHTML+=x+'\n';

test_valid = [
 '(@@@@@@)\n ( $ &  )\nQ   (  )\n..  .  !\n : .\n  |"   !\n    .',
 '()()()\n......',
 '@_$ &\nerrrr\nh_r-5\n.:. .\n "'
] 
console.log('Valid');
test_valid.forEach(t=>console.log(t+'\n'+f(t)+'\n'))

test_invalid = ['!\n()','$$$$$\n(   )\n:::::\n.....']
console.log('Invalid');
test_invalid.forEach(t=>console.log(t+'\n'+f(t)+'\n'))

<pre id=O></pre>

Answer 6

पर्ल 5, 80

79, प्लस के लिए एक -Eके बजाय-e

@a=();while(<>){@_=split'';(0>($a[$_]+=/[()_@&\$]/-/[!|.":]/)?die:1)for@_}say 1

Comments

मैं पर्ल को नहीं पढ़ सकता, लेकिन मैं गणित में मजबूत हूँ: 79 + 1 = 80

— edc65

Answer 7

जूलिया, 90 वर्ण

s->all(cumsum(map(i->i∈"!|.\":"?-1:i∈"()_@\$&",mapfoldl(collect,hcat,split(s,"
")))').>-1)

मूल समाधान (नीचे) के विपरीत, यह समाधान को निर्धारित करने के लिए गणित का उपयोग करता है। mapfoldl(collect,hcat,split(s,"\n"))(ऊपर लिखा है\n पात्रों को बचाने के लिए एक वास्तविक नई पंक्ति के प्रतिस्थापित ) स्ट्रिंग को वर्णों के 2d सरणी में परिवर्तित करता है।map(i->i∈"!|.\":"?-1:i∈"()_@\$&",...)संख्या की एक सरणी बनाता है, 1 के साथ यदि चरित्र एक बादल है, -1 यदि चरित्र बारिश है, और 0 अन्यथा।

cumsum(...') पंक्तियों के संचयी योगों की गणना करता है (सामान्य रूप से लिखा जाएगा cumsum(...,2) , लेकिन जब से हम इस बिंदु से अभिविन्यास के बारे में परवाह नहीं करते हैं, केवल एक चरित्र का खर्च होता है), और फिर all(... .>-1)एक नकारात्मक संख्या की जांच करता है - नकारात्मक केवल तभी होगा जब एक बारिश चरित्र एक बादल चरित्र से पहले होने के बिना प्रकट होता है।

जूलिया, 139 136 वर्ण

s->(t=join(mapfoldl(i->split(i,""),.*,split(s,"
")),"
");while t!=(t=replace(t,r"[()_@$&](.*?)[!|.\":]",s"\g<1>"))end;∩("!|.\":",t)==[])

यह फ़ंक्शन पहले पाठ को स्थानांतरित करता है ताकि पंक्तियाँ स्तंभ बन जाएं और इसके विपरीत। ध्यान दें कि नए वर्ण वास्तविक उदाहरण के रूप में कोड में मौजूद हैं, उदाहरण के लिए एक वर्ण को बचाने के लिए।

तब फ़ंक्शन पुनरावृत्तियों से रिक्त स्थान के साथ क्लाउड / छोटी बूंदों के जोड़े को बदल देता है, और एक बार ऐसी सभी जोड़े हटा दिए जाने के बाद, यह सच है अगर कोई बूंदें शेष हैं और अन्यथा झूठी हैं।

r"[()_@$&](.*?)[!|.\":]"- यह एक रेगेक्स है जो एक आलसी तरीके से क्लाउड / छोटी बूंदों के जोड़े से मेल खाएगा, समूह 1 के साथ क्लाउड और ड्रॉपलेट के बीच सब कुछ होगा। फिर s"\g<1>"इसे मिलान किए गए बादल और बूंदों को हटाने के लिए कहता है, लेकिन सामान को बीच में रखें (आवश्यक रूप से इसमें बादल हो सकते हैं) - वह \g<1>है जो रेगेक्स के समूह 1 में मिलान किया गया था। ∩("!|.\":",t)==[]अंतिम स्ट्रिंग के साथ छोटी बूंद वर्णों के प्रतिच्छेदन को उत्पन्न करेगा, और यदि यह खाली है, तो छोटी बूंद पात्रों में से कोई भी मौजूद नहीं है, और बारिश हो रही है।

Comments

@nimi - आपको वास्तव में इसकी आवश्यकता नहीं है। आप hउपयोग को वास्तविक अनाम फ़ंक्शन के साथ बदल सकते हैं । इस तरह: g((s->join(foldl(.*,[split(i,"")for i=split(s,"\n")]),"\n")s->join(foldl(.*,[split(i,"")for i=split(s,"\n")]),"\n"))("()()()\n......"))- इसे कॉल करने से hबस इनवॉइस करना आसान हो जाता है।

— ग्लेन ओ

@nimi - "कॉल करने के लिए एकल फ़ंक्शन" के रूप में, यह थोड़ा अधिक उचित दावा है, लेकिन यह स्पष्ट नहीं है कि उस पर खड़ा समुदाय क्या है - मैं इसके बारे में पूछते हुए एक मेटा पोस्ट बनाने जा रहा हूं।

— ग्लेन ओ

@nimi - यही कि मैं अभी मेटा पोस्ट के साथ स्पष्टीकरण प्राप्त करने जा रहा हूं।

— ग्लेन ओ

यह अब इस सवाल के लिए बहुत ही कम है, क्योंकि मुझे इसे करने का एक बेहतर तरीका मिला, केवल एक फ़ंक्शन के साथ।

— ग्लेन ओ