Dies sind Regentropfen:

! | . " :

Dies sind Wolkenteilchen:

( ) _ @ $ &

Ich möchte, dass Sie bei einem Textblock überprüfen, ob es regnet oder nicht. Es regnet, wenn sich für jeden Regentropfen irgendwo darüber ein Wolkenteilchen befindet. Für jeden Regentropfen muss ein Wolkenteilchen vorhanden sein. Geben Sie einen wahrheitsgemäßen oder falschen Wert aus , der Ihre Schlussfolgerungen angibt.

Gültige Beispiele

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

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

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

Ungültige Beispiele

!
()

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

Dies ist ein Code-Golf, so dass das kürzeste Programm in Charakteren gewinnt.

APL (30)

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

Dies ist eine Funktion, die eine Zeichenmatrix als Eingabe verwendet und eine boolesche Ausgabe liefert.

Prüfung:

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

Erläuterung:

• ⍵∘∊¨'!|.":' '()_@$&': Überprüfen Sie für beide Zeichensätze (Regen und Wolken) und für jedes Zeichen in ⍵, ob das Zeichen Mitglied des Satzes ist.
• +⍀¨: Erhalte eine laufende Summe für jede Spalte und jeden Satz
• ≤/: Überprüfen Sie für jede Position in ⍵, ob die Menge der Regentropfen die Menge der Wolkenteilchen in der laufenden Summe nicht überschreitet
• ∧/∊: Gibt das boolesche UND aller Elemente im Ergebnis zurück

C ++ 11, 186 184 Bytes

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

Grundlegender Ansatz: Speichern von Positionen von Wolkenteilchen in einer Reihe. Wenn Regenpartikel angetroffen werden, wird geprüft, ob sich das Wolkenteilchen darüber befindet, und der Zähler der Wolkenteilchen in dieser Spalte wird verringert. Das Programm gibt 0 zurück, wenn es gültig ist, und 1, wenn es gültig ist.

Schnecken , 125

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

Das Programm gibt die Fläche des Gitters aus (oder 1, wenn die Fläche 0 ist), wenn es regnet. sonst 0. Wenn ich nur Zeichenklassen im Regex-Stil implementiert hätte.

Ungolfed-Version Diese enthält gefälschte Anweisungen für Wolken oder Regentropfen, anstatt den ganzen Kauderwelsch aufzuschreiben . \whatever( .im realen Programm durch ersetzt) ​​bedeutet eine Sache, die ein Regentropfen sein sollte, aber eigentlich alles sein kann, da es keine Rolle spielt, ob wir einen Nicht-Regentropfen einer Wolke zuordnen.

{
    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

Python 2, 121 Bytes

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

Erwartet, dass die aufgefüllte Eingabe rechteckig ist.

JavaScript ES6, 112

Testen Sie das Ausführen des folgenden Snippets in einem EcmaScript 6-kompatiblen Browser, der Pfeilfunktionen, Spread-Operator- und Vorlagenzeichenfolgen implementiert (ich verwende Firefox).

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>

Perl 5, 80

79 plus eins für -Estatt-e

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

Julia, 90 Zeichen

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

Im Gegensatz zur ursprünglichen Lösung (unten) wird hierfür die Lösung mithilfe der Mathematik bestimmt. mapfoldl(collect,hcat,split(s,"\n"))(oben geschrieben \ndurch durch eine neue Zeile ersetzt, um Zeichen zu speichern) konvertiert die Zeichenfolge in ein 2D-Array von Zeichen. map(i->i∈"!|.\":"?-1:i∈"()_@\$&",...)Erstellt ein Array von Zahlen, mit 1, wenn das Zeichen eine Wolke ist, -1, wenn das Zeichen Regen ist, und 0, wenn dies nicht der Fall ist.

cumsum(...')berechnet die kumulierten Summen der Zeilen (wird normalerweise geschrieben cumsum(...,2), aber da uns die Orientierung von diesem Punkt an egal ist, kostet das Transponieren nur ein Zeichen) und all(... .>-1)prüft dann auf eine negative Zahl - Negative treten nur auf, wenn ein Regenzeichen vorliegt wird angezeigt, ohne dass ein Wolkenzeichen vorangestellt ist.

Julia, 139 136 Zeichen

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

Diese Funktion transponiert zuerst den Text, sodass Zeilen zu Spalten werden und umgekehrt. Beachten Sie, dass Zeilenumbrüche im Code in Form von tatsächlichen Zeilenumbrüchen vorhanden sind, um ein Zeichen pro Instanz zu speichern.

Die Funktion ersetzt dann iterativ Wolken / Tröpfchen-Paare durch Leerzeichen. Sobald alle diese Paare entfernt wurden, gibt sie true zurück, wenn noch Tröpfchen übrig sind, andernfalls false.

r"[()_@$&](.*?)[!|.\":]"- Dies ist eine Regex, die Wolken / Tröpfchen-Paare auf träge Weise zusammenbringt, wobei Gruppe 1 alles zwischen Wolke und Tröpfchen enthält. Dann s"\g<1>"wird es angewiesen, die übereinstimmende Wolke und die Tröpfchen zu entfernen, aber das Material dazwischen zu belassen (notwendig, da es möglicherweise Wolken enthält) - das \g<1>ist alles, was in Gruppe 1 der Regex abgeglichen wurde. ∩("!|.\":",t)==[]generiert den Schnittpunkt der Tröpfchenzeichen mit der letzten Zeichenfolge. Wenn diese leer ist, ist keines der Tröpfchenzeichen vorhanden und es regnet.