Queste sono le gocce di pioggia:

! | . " :

Queste sono particelle di nuvole:

( ) _ @ $ &

Voglio che tu verifichi, quando ti viene dato un blocco di testo, se sta piovendo o meno. Piove se, per ogni goccia di pioggia, c'è una particella di nuvola da qualche parte sopra di essa. Ci deve essere una particella di nuvola per ogni goccia di pioggia. Mostra un valore di verità o falsità che indica le tue conclusioni.

Esempi validi

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

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

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

Esempi non validi

!
()

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

Questo è un codice-golf, quindi vince il programma più breve in caratteri .

APL (30)

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

Questa è una funzione che accetta una matrice di caratteri come input e fornisce un output booleano.

Test:

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

Spiegazione:

• ⍵∘∊¨'!|.":' '()_@$&': per entrambi i set di personaggi (pioggia e nuvole) e per ogni personaggio in ⍵, vedi se il personaggio è un membro del set.
• +⍀¨: ottieni una somma corrente per ogni colonna e ogni set
• ≤/: per ogni posizione in ⍵, controlla che la quantità di gocce di pioggia non superi la quantità di particelle di nuvola nella somma corrente
• ∧/∊: restituisce il valore booleano AND di tutti gli elementi nel risultato

C ++ 11, 186 184 byte

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

Approccio di base, memorizzazione delle posizioni delle particelle di nuvola in una riga e se si incontra una particella di pioggia, controlla se la particella di nuvola è sopra di essa e diminuisce il contatore delle particelle di nuvola in quella colonna. Il programma restituisce 0 se è valido e 1 altrimenti.

Lumache , 125

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

Il programma emette l'area della griglia (o 1 se la sua area è 0) se piove; altrimenti 0. Se solo avessi implementato le classi di caratteri in stile regex.

Versione Ungolfed Questo contiene istruzioni false per nuvole o gocce di pioggia invece di scrivere tutto il gibberish. \whatever(sostituito con .nel programma reale) significa una cosa che dovrebbe essere una goccia di pioggia, ma in realtà può essere qualsiasi cosa perché non importa se abbiniamo una non goccia di pioggia a una nuvola.

{
    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 byte

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

Si aspetta che l'ingresso sia imbottito in modo rettangolare.

JavaScript ES6, 112

Prova a eseguire lo snippet di seguito in un browser conforme a EcmaScript 6 che implementa le funzioni freccia, l'operatore di diffusione e le stringhe di modello (utilizzo 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, più uno per -Eanziché-e

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

Julia, 90 caratteri

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

A differenza della soluzione originale (di seguito), utilizza la matematica per determinare la soluzione. mapfoldl(collect,hcat,split(s,"\n"))(scritto sopra con \nsostituito con una nuova riga effettiva per salvare i caratteri) converte la stringa in una matrice 2d di caratteri. map(i->i∈"!|.\":"?-1:i∈"()_@\$&",...)crea una matrice di numeri, con 1 se il personaggio è una nuvola, -1 se il personaggio è pioggia e 0 altrimenti.

cumsum(...')calcola le somme cumulative delle righe (normalmente verrebbero scritte cumsum(...,2), ma dal momento che non ci preoccupiamo dell'orientamento da questo punto in poi, la trasposizione costa solo un carattere) e quindi all(... .>-1)verifica la presenza di un numero negativo - i negativi si verificano solo se un carattere pioggia appare senza essere preceduto da un personaggio cloud.

Julia, 139 136 caratteri

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

Questa funzione prima traspone il testo in modo che le righe diventino colonne e viceversa. Si noti che le nuove righe sono presenti nel codice sotto forma di nuove righe effettive, per salvare un carattere per istanza.

La funzione sostituisce quindi in modo iterativo le coppie cloud / droplet con spazi e, una volta rimosse tutte queste coppie, restituisce true se sono presenti goccioline rimanenti e false in caso contrario.

r"[()_@$&](.*?)[!|.\":]"- questa è una regex che abbinerà le coppie cloud / droplet in modo pigro, con il gruppo 1 che contiene tutto tra cloud e droplet. Quindi gli s"\g<1>"dice di rimuovere la nuvola e le goccioline abbinate, ma tieni le cose in mezzo (necessario in quanto può contenere nuvole) - \g<1>è tutto ciò che è stato abbinato nel gruppo 1 della regex. ∩("!|.\":",t)==[]genererà l'intersezione dei caratteri della goccia con la stringa finale, e se è vuota, nessuno dei caratteri della goccia è presente e piove.