Ce sont des gouttes de pluie:

! | . " :

Ce sont des particules de nuages:

( ) _ @ $ &

Je veux que vous vérifiiez, quand on vous donne un bloc de texte, s'il pleut ou non. Il pleut si, pour chaque goutte de pluie, il y a une particule de nuage quelque part au-dessus. Il doit y avoir une particule de nuage pour chaque goutte de pluie. Produisez une valeur vraie ou fausse indiquant vos conclusions.

Exemples valides

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

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

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

Exemples non valides

!
()

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

C'est un code-golf donc le programme le plus court en caractères gagne.

APL (30)

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

Il s'agit d'une fonction qui prend une matrice de caractères en entrée et donne une sortie booléenne.

Tester:

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

Explication:

• ⍵∘∊¨'!|.":' '()_@$&': pour les deux ensembles de caractères (pluie et nuages), et pour chaque caractère en ⍵, voyez si le personnage est membre de l'ensemble.
• +⍀¨: obtenir une somme cumulée pour chaque colonne et chaque ensemble
• ≤/: pour chaque position en ⍵, vérifiez que la quantité de gouttes de pluie ne dépasse pas la quantité de particules de nuage dans la somme cumulée
• ∧/∊: retourne le booléen ET de tous les éléments du résultat

C ++ 11, 186 184 octets

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

Non golfé

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

Approche de base, stockant les positions des particules de nuage dans une rangée et si des particules de pluie sont rencontrées, il vérifie si la particule de nuage est au-dessus et diminue le compteur de particules de nuage dans cette colonne. Le programme renvoie 0 s'il est valide et 1 sinon.

Escargots , 125

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

Le programme affiche la zone de la grille (ou 1 si sa zone est 0) s'il pleut; sinon 0. Si seulement j'avais implémenté des classes de caractères de style regex.

Version non golfée Elle contient de fausses instructions pour les nuages ​​ou les gouttes de pluie au lieu d'écrire tout le charabia. \whatever(remplacé par .dans le vrai programme) signifie une chose qui devrait être une goutte de pluie, mais qui peut en fait être n'importe quoi, car cela n'a pas d'importance si nous associons une non-goutte de pluie à un nuage.

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

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

S'attend à ce que l'entrée à remplir soit rectangulaire.

JavaScript ES6, 112

Testez l'exécution de l'extrait ci-dessous dans un navigateur compatible EcmaScript 6 implémentant des fonctions fléchées, un opérateur de diffusion et des chaînes de modèle (j'utilise 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 un pour -Eau lieu de-e

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

Julia, 90 caractères

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

Contrairement à la solution d'origine (ci-dessous), celle-ci utilise les mathématiques pour déterminer la solution. mapfoldl(collect,hcat,split(s,"\n"))(écrit ci-dessus avec \nremplacé par une nouvelle ligne réelle pour enregistrer les caractères) convertit la chaîne en un tableau 2D de caractères. map(i->i∈"!|.\":"?-1:i∈"()_@\$&",...)crée un tableau de nombres, avec 1 si le personnage est un nuage, -1 si le personnage est pluie et 0 sinon.

cumsum(...')calcule les sommes cumulées des lignes (serait normalement écrit cumsum(...,2), mais comme nous ne nous soucions plus de l'orientation à partir de ce moment, la transposition ne coûte qu'un caractère), puis all(... .>-1)vérifie un nombre négatif - les négatifs ne se produiront que si un caractère pluie apparaît sans être précédé d'un caractère de nuage.

Julia, 139 136 caractères

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

Cette fonction transpose d'abord le texte pour que les lignes deviennent des colonnes et vice-versa. Notez que les sauts de ligne sont présents dans le code sous la forme de sauts de ligne réels, pour enregistrer un caractère par instance.

La fonction remplace ensuite de manière itérative les paires nuage / gouttelette par des espaces, et une fois que toutes ces paires sont supprimées, elle renvoie true s'il reste des gouttelettes et false sinon.

r"[()_@$&](.*?)[!|.\":]"- il s'agit d'une expression régulière qui associera les paires nuage / gouttelette de manière paresseuse, le groupe 1 contenant tout entre le nuage et la gouttelette. Puis lui s"\g<1>"dit de supprimer le nuage et les gouttelettes correspondants, mais gardez les choses entre les deux (nécessaire car il peut contenir des nuages) - \g<1>c'est tout ce qui a été mis en correspondance dans le groupe 1 de l'expression régulière. ∩("!|.\":",t)==[]générera l'intersection des caractères de gouttelette avec la chaîne finale, et si elle est vide, alors aucun des caractères de goutte n'est présent et il pleut.