Vivo en el Reino Unido, donde llueve. Mucho. También tengo la desafortunada necesidad de usar anteojos para ver, lo que significa que cuando llueve (como ahora), apenas puedo ver fuera de ellos. ¡Este desafío es para que todos puedan experimentar lo mismo!

Tarea

Salida de gafas de arte ASCII con una gota de agua añadida cada segundo.

Entrada

Ninguna

Salida

Un par de vasos con gotas de agua sobre ellos.

Vasos

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

Gotas de lluvia

Una gota de lluvia se denota por a .. Se coloca aleatoriamente una gota de lluvia sobre las lentes de las gafas. Entonces, cuando se coloca una gota de lluvia, los lentes pueden verse así

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

Si se coloca en un espacio en blanco ( ), .se coloca un en la imagen. Si se coloca en un cuadrado que ya tiene una gota de lluvia, la gota se gradúa.

Los pasos sobre las gotas son

• sin gotas colocadas:
• 1 gota colocada: .
• 2 gotas colocadas: o
• 3 gotas colocadas: O
• 4+ gotas colocadas: @

Reglas

• La imagen debería verse como si se quedara en su lugar. Esto significa que puede borrar la pantalla o imprimir suficientes líneas nuevas para "borrar" la pantalla. No puede devolver una lista de pasos. Lo siento, pero deberías poder solucionarlo.
• Al generar líneas nuevas para "borrar" la pantalla, debe tener al menos 3 líneas nuevas entre las gafas.
• El código se ejecuta hasta que las gafas estén llenas de gotas totalmente graduadas, es decir, hasta que la salida se vea así:

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

• El código más corto en bytes gana.

JavaScript (ES6), 269 267 265 bytes

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)

Editar: Guardado 2 4 bytes gracias a @Shaggy.

Java 8, 449 421 bytes

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('#',' '));}}

Explicación:

Pruébalo aquí ( Thread.sleepse elimina para que pueda ver el resultado al instante).

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

Salida:

NOTA: Los puntos son un poco raros en el gif, pero eso es un problema en mi ScreenToGif.exe.

F #, no recursivo 379 414 404 bytes

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))

Pruébalo en línea!

• -7 bytes gracias a @vzwick
  • aliasing String.replicate
  • abriendo el sistema en lugar de hacer referencia a él cada vez
• -3 bytes al reducir el ciclo while a una línea

Me encanta la premisa de este desafío :)

Y gracias por la lombriz.

F #, 406 441 438 437 423 bytes

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

Pruébalo en línea!

• -3 bytes al restringir s a una cadena comparándola con una cadena
• -1 byte, el nombre de la función ahora es "!" ahorrando un solo espacio al llamarlo
• -7 bytes gracias a @vzwick
  • aliasing String.replicate
  • abriendo el sistema en lugar de hacer referencia a él cada vez
• -1 byte, no necesita paréntesis al llamar a d.Next
• -6 bytes, la función ahora es una línea

Explicación

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 bytes

Eso está un poco mejor ...

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)

Pruébalo en línea

El enlace anterior usa 30 líneas en lugar de 3, pero puede verlo con 3 si cambia el tamaño de la ventana de su navegador para que sea lo suficientemente pequeña verticalmente. Cambiar time.sleep(1)a time.sleep(.1)velocidad 10x.

C, 313 309 305 304 bytes

Necesita jugar golf un poco;

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

Lo ejecuto con el siguiente trozo de prueba

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

Ruby , 237 224 228 218 206 198 197 bytes

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}

Pruébalo en línea!

La respuesta anterior era incorrecta, no tenía en cuenta una gota de lluvia que caía sobre una @.Aparentemente no es un requisito. Algunos bytes guardados.

Esto termina con un error arrojado, pero definitivamente termina tan pronto como se imprimen los vasos completos.

• Ahorró 13 bytes poniendo la impresión en una lambda y cambiando la asignación para usar tr (duh)
• Pérdida de 8 bytes con el requisito de 1 segundo.
• 10 bytes de ganancia mediante el uso del truco gsub en lugar de la interpolación (visto y adaptado de la respuesta de Python de mbomb007 ).
• 12 bytes de ganancia al eliminar la impresión lambda ahora que la impresión se escribe solo una vez>.>
• Ganancia de 1 byte haciendo todo el \\ser a, luego cambiando de nuevo dentro del tr
• Ganancia de 7 bytes al cambiar los espacios en la última línea con otro x(duh). En caso de que algunos de ustedes se pregunten por qué esto no afecta el bucle principal: el bucle principal no considera la última línea para determinarlo x.
• Ganancia de 1 byte al quitar el extremo de la parte superior de las gafas

Yay <200 bytes: D

GIF:

Bash, 576 510 429 416 Bytes

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, jugué mucho golf. Si alguien tiene alguna idea para seguir jugando al golf, estoy abierto a sugerencias

¡Inténtalo tú mismo! Tiene el sueño comentado debido al límite de 60 segundos

Aquí está el gif:

Perl, 167 bytes

Tenga en cuenta que \x1b es un carácter de escape literal.

$_="\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

¡Véalo en línea!

Mathematica, 438 bytes

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]

aquí hay un gif de resultados de velocidad 10x

PHP, 262254 bytes

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;

Ejecutar -nRo probarlo en línea .

Descompostura

# 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+=)