J'habite au Royaume-Uni, où il pleut. Beaucoup. J'ai aussi la malheureuse nécessité de devoir porter des lunettes pour voir, ce qui signifie que lorsqu'il pleut (comme c'est le cas actuellement), je peux à peine voir hors d'eux. Ce défi est pour que vous puissiez tous vivre la même chose!

Tâche

Sortie de verres d'art ASCII avec une goutte d'eau ajoutée chaque seconde.

Contribution

Aucun

Sortie

Une paire de verres avec des gouttes d'eau dessus.

Des lunettes

 ________________________
|          /__\          |
|         /    \         |
|        /      \        |
\_______/        \_______/

Gouttes de pluie

Une goutte de pluie est désignée par un .. Une goutte de pluie est placée au hasard sur les verres des lunettes. Donc, quand une goutte de pluie est placée, les lunettes peuvent ressembler à ceci

 ________________________
|          /__\          |
|    .    /    \         |
|        /      \        |
\_______/        \_______/

S'il est placé sur un espace vide ( ), un .est placé sur l'image. S'il est placé sur un carré qui a déjà une goutte de pluie, la goutte est graduée.

Les étapes sur les gouttes sont

• aucune goutte placée:
• 1 goutte placée: .
• 2 gouttes placées: o
• 3 gouttes déposées: O
• 4+ gouttes placées: @

Règles

• L'image doit avoir l' air de rester en place. Cela signifie que vous pouvez soit effacer l'écran, soit imprimer suffisamment de nouvelles lignes pour «effacer» l'écran. Vous ne pouvez pas retourner une liste d'étapes. Désolé pour cela, mais vous devriez pouvoir contourner cela.
• Lors de la sortie de sauts de ligne pour "effacer" l'écran, vous devez avoir au moins 3 sauts de ligne entre les lunettes.
• Le code s'exécute jusqu'à ce que les verres soient pleins de gouttes entièrement graduées, c'est-à-dire jusqu'à ce que la sortie ressemble à ceci:

     ________________________
    | @@@@@@@@@@ / __ \ @@@@@@@@@@ | |
    | @@@@@@@@@ / \ @@@@@@@@@ |
    | @@@@@@@@ / \ @@@@@@@@ |
    \ _______ / \ _______ /

• Le code le plus court en octets gagne.

JavaScript (ES6), 269 267 265 octets

document.write('<pre id=o>')
a=[...` _8_8_8
| 9 /__\\  9|
| 9/ 4\\ 9|
| 8/ 6\\ 8|
\\_7/ 8\\_7/`.replace(/.\d/g,s=>s[0].repeat(s[1]))]
s=" .oO@@"
g=_=>o.innerHTML=a.join``
f=(i=s.indexOf(a[j=Math.random()*a.length|0])+1)=>i?g(a[j]=s[i]):f()
g()
setInterval(f,1e3)

Edit: sauvé 2 4 octets grâce à @Shaggy.

Java 8, 449 421 octets

v->{String q="########",g=" ________________________\n|##"+q+"/__\\##"+q+"|\n|#"+q+"/    \\#"+q+"|\n|"+q+"/      \\"+q+"|\n\\_______/        \\_______/\n\n\n";for(int t=0,n,x;g.matches("(?s).*[#\\.oO].*");Thread.sleep(150)){for(;(x=g.charAt(n=(int)(Math.random()*g.length())))!=35&x!=46&x!=111&x!=79;);if(t++>0)g=g.substring(0,n)+(x<36?".":x<47?"o":x<80?"@":"O")+g.substring(n+1);System.out.println(g.replace('#',' '));}}

Explication:

Essayez-le ici. ( Thread.sleepest supprimé pour que vous puissiez voir instantanément le résultat.)

v->(){                      // Method without empty unused parameter and no return-type
  String q="########",g=" ________________________\n|##"+q+"/__\\##"+q+"|\n|#"+q+"/    \\#"+q+"|\n|"+q+"/      \\"+q+"|\n\\_______/        \\_______/\n\n\n";
                            //  The glasses (with inner spaces replaced by '#')
  for(int t=0,n,x;          //  Index integers
      g.matches("(?s).*[#\\.oO].*");
                            //   Loop (1) as long as the glasses still contain "#.oO"
      Thread.sleep(150)){   //   And sleep 150ms after each iteration to give the animation
    for(;                   //   Inner loop (2)
         (x=g.charAt(n=(int)(Math.random()*g.length())))!=35&x!=46&x!=111&x!=79;
                            //    To find the next '#', '.', 'o' or 'O' randomly
    );                      //   End of inner loop (2)
    if(t++>0)               //   Flag so it prints the initial glasses without a raindrop
      g=g.substring(0,n)+(x<36?".":x<47?"o":x<80?"@":"O")+g.substring(n+1);
                            //    Add a raindrop on this random position
    System.out.println(g    //   And print the glasses
        .replace('#',' ')); //   After we've replaced '#' with spaces
  }                         //  End of loop (1)
}                           // End of method

Sortie:

REMARQUE: les points sont un peu bizarres dans le gif, mais c'est un problème dans mon ScreenToGif.exe ..

F #, non récursif 379 414 404 octets

open System
let z=String.replicate
let mutable s,d=z 54" ",new Random()
while Seq.exists((<>)'@')s do printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"(z 24"_")(s.[..9])(s.[10..19])(s.[20..28])(s.[29..37])(s.[38..45])"\\"(s.[46..53])"\\";Threading.Thread.Sleep(1000);d.Next54|>fun i->s<-(s.[i]|>function|' '->"."|'.'->"o"|'o'->"O"|_->"@")|>(fun c->s.Remove(i,1).Insert(i,c))

Essayez-le en ligne!

• -7 octets grâce à @vzwick
  • par aliasing String.replicate
  • en ouvrant System au lieu de le référencer à chaque fois
• -3 octets en réduisant la boucle while à une ligne

J'adore la prémisse de ce défi :)

Et merci pour le ver de l'oreille.

F #, 406 441 438 437 423 octets

open System
let z=String.replicate
let s,d=z 54" ",new Random()
let rec(!)s=s="";printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"(z 24"_")(s.[..9])(s.[10..19])(s.[20..28])(s.[29..37])(s.[38..45])"\\"(s.[46..53])"\\";Threading.Thread.Sleep(1000);if Seq.exists((<>)'@')s then d.Next 54|>fun i-> !((s.[i]|>function|' '->"."|'.'->"o"|'o'->"O"|_->"@")|>(fun c->s.Remove(i,1).Insert(i,c)))else()
!s

Essayez-le en ligne!

• -3 octets en contraignant s à la chaîne en le comparant à la chaîne
• -1 octet, le nom de la fonction est désormais "!" économiser un seul espace lors de l'appel
• -7 octets grâce à @vzwick
  • par aliasing String.replicate
  • en ouvrant System au lieu de le référencer à chaque fois
• -1 octet, pas besoin de parenthèses lors de l'appel de d.Next
• -6 octets, la fonction est maintenant une ligne

Explication

open System
let z = String.replicate    // define alias
let s, d = z 54 " ", new Random() // s holds a flat representation of the glasses.. glasses
let rec(!) s =
    s=""; // type s to string
    printfn" %s\n|%s/__\\%s|\n|%s/    \\%s|\n|%s/%7s%s|\n\\_______/%9s_______/\n\n"
        (z 24 "_")     // top of the glasses
        (s.[..9])      // slice
        (s.[10..19])   // and
        (s.[20..28])   // dice
        (s.[29..37])   // the
        (s.[38..45])   // glasses
        "\\"           // \ gets prepended with 6 spaces thanks to %7s
        (s.[46..53])
        "\\";          // same deal, just 8 spaces this time
    Threading.Thread.Sleep(1000);
    if Seq.exists((<>)'@') s then // if not everything's totally covered
        d.Next 54                 // get new random int < 54 (string has indices 0-53)
        |> fun i->                // passing is shorter than a let binding, saves two spaces and a new line
            !(                    // call the function again with new drop on glasses
              (s.[i]              // get part of the glasses drop fell on
              |>function
              |' '->"."           // promote drop
              |'.'->"o"
              |'o'->"O"
              |_->"@")
              |>(fun c-> s.Remove(i,1).Insert(i,c))) // and insert this in the string
    else ()
!s

Python 2, 365 328 octets

C'est un peu mieux ...

import time,random
g=' '+'_'*24+r"""
|xxX/__\Xxx|
|xX/    \Xx|
|X/      \X|
\_______/        \_______/""".replace('X','x'*8)
while 1:
 print'\n'*3+g.replace('x',' ')
 s='x.oO@@'
 if all(c not in g for c in s[:-2]):exit()
 i,c=random.choice([(i,s[s.index(j)+1])for i,j in enumerate(g)if j in s])
 g=g[:i]+c+g[i+1:]
 time.sleep(1)

Essayez-le en ligne

Le lien ci-dessus utilise 30 lignes au lieu de 3, mais vous pouvez le voir avec 3 si vous redimensionnez la fenêtre de votre navigateur pour être suffisamment petite verticalement. Passez time.sleep(1)à time.sleep(.1)une vitesse 10x.

C, 313 309 305 304 octets

Doit être un peu joué au golf;

c;f(r,q){for(char*m=" ________________________\n|**********/__\\**********|\n|*********/    \\*********|\n|********/      \\********|\n\\_______/        \\_______/\n";c<216;r=rand()%144,m-=135)for(system("clear");*m++;putchar(*m^42?*m:32))q=--r?*m:*m^42?*m^46?*m^111?*m^79?*m:64:79:111:46,c+=q!=*m,*m=q;}

Je l'exécute avec le talon de test suivant

main()
{
    srand(time(0));    
    f();
}

Rubis , 237 224 228 218 206 206 198 197 octets

g=" #{?_*24}
|x##/__ax##|
|x#/    ax#|
|x/      ax|
a#{u=?_*7}/xa#{u}/


".gsub ?x,?#*8;217.times{|t|puts g.tr('#a',' \\');()while t<216&&g[x=rand*106]!~/[#.oO]/;g[x]=g[x].tr '#.oO','.oO@';sleep 1}

Essayez-le en ligne!

La réponse précédente était fausse, elle ne tenait pas compte d'une goutte de pluie tombant sur un @. Apparemment pas une exigence. Quelques octets enregistrés.

Cela se termine avec une erreur lancée, mais cela se termine définitivement dès que les verres pleins sont imprimés.

• 13 octets enregistrés en mettant l'impression dans un lambda et en changeant l'affectation pour utiliser tr (duh)
• 8 octets de perte avec l'exigence de 1 seconde.
• 10 octets gagnent en utilisant l'astuce gsub au lieu de l'interpolation (vu et adapté de la réponse Python de mbomb007 ).
• Gain de 12 octets en supprimant l'impression lambda maintenant que l'impression n'est écrite qu'une seule fois>.>
• Gain de 1 octet en faisant tout le \\be a, puis en revenant à l'intérieur du tr
• Gain de 7 octets en plaçant le changement des espaces sur la dernière ligne avec un autre x(duh). Dans le cas où certains d'entre vous se demandent pourquoi cela n'affecte pas la boucle principale: la boucle principale ne prend pas en compte la dernière ligne pour la déterminer x.
• Gain de 1 octet en retirant le bout de la lunette

Oui <200 octets: D

Gif:

Bash, 576 510 429 416 octets

j()(IFS=
printf "$*")
for i in {53..0};{ a[$i]= 
b[$i]=@;}
while(($i == 0));do clear
echo  " ________________________
|`j ${a[@]::10}`/__\\`j ${a[@]:10:10}`|
|`j ${a[@]:20:9}`/    \\`j ${a[@]:29:9}`|
|`j ${a[@]:38:8}`/      \\`j ${a[@]:46}`|
\_______/        \_______/"
[ `j ${a[@]}` = `j ${b[@]}` ]&&{
i=1
}
sleep 1
d=`shuf -i0-53 -n1`
c=${a[$d]}
case $c in  )a[$d]=.;;.)a[$d]=o;;o)a[$d]=0;;0)a[$d]=@;esac
done

Wow, j'ai beaucoup joué au golf. Si quelqu'un a une idée de golf, je suis ouvert aux suggestions

Essayez-le vous-même! Il a commenté le sommeil en raison de la limite de 60 secondes

Voici le gif:

Perl, 167 octets

Notez qu'il \x1bs'agit d'un caractère d'échappement littéral.

$_="\x1bc 24_
|10X/__\\10X|
|9X/4 \\9X|
|8X/6 \\8X|
\\7_/8 \\7_/
";s/\d+(.)/$1x$&/ge;do{$a[rand 54]++,sleep print s/X/($",".",o,O)[$a[$-++%54]]||"@"/ger}while grep$_<4,@a

Voyez-le en ligne!

Mathematica, 438 octets

f=Flatten;p=Print;z=32;q=95;l=124;t=Table;v=z~t~8;s={f@{z,q~t~24,z},f@{124,z~t~10,47,q,q,92,z~t~10,l},f@{l,z~t~9,47,z~t~4,92,z~t~9,l},f@{l,v,47,z~t~6,92,v,l},f@{92,q~t~7,47,v,92,q~t~7,47}};c=0;Monitor[While[c<54,a=s[[i=RandomInteger@{2,4},j=RandomChoice[Range[2,13-i]~Join~Range[14+i,25]]]];If[a==z,s[[i,j]]=46,If[a==46,s[[i,j]]=111,If[a==111,s[[i,j]]=48,If[a==48,s[[i,j]]=64]]]];c=Count[Flatten@s,64];Pause@1],Column@FromCharacterCode@s]

voici un gif de résultat de vitesse 10x

PHP, 262 254 octets

for($t=" 8_8_8_
|Y9Y/__\Y9Y|
|9Y/4 \9Y|
|8Y/6 \8Y|
\\7_/8 \\7_/";$c=$t[$i++];)$s.=$c<1?$c:str_repeat($t[$i++],$c);for(;$c=$s[++$k];)$c!=Y?:$s[$m[]=$k]=" ";for(;$u<216;print str_pad($s,999,"
",sleep(1)))$u+=($c=".oO@"[$a[$p=rand(0,53)]++])&&$s[$m[$p]]=$c;

Courez avec -nRou essayez-le en ligne .

panne

# prep 1: generate template from packed string
for($t=" 8_8_8_\n|Y9Y/__\Y9Y|\n|9Y/4 \9Y|\n|8Y/6 \8Y|\n\\7_/8 \\7_/";
    $c=$t[$i++];)$s.=$c<1?$c:str_repeat($t[$i++],$c);
# prep 2: map substituted spaces and replace with real spaces
for(;$c=$s[++$k];)$c!=Y?:$s[$m[]=$k]=" ";
# loop until glasses are fully wet:
for(;$u<216;
    # 4. print glasses prepended with 865 newlines
    print str_pad($s,999,"\n",
    # 3. wait 1 second
        sleep(1)))
    $u+=($c=".oO@"[
        $a[$p=rand(0,53)    # 1. pick random position
        ]++])               # 2. and increment
        &&$s[$m[$p]]=$c         # if not fully wet, graduate drop
    ;                           # and increment drop count ($u+=)