Contexto

É dia dos namorados. O único que você já amou deixou você ontem para esse cara que ela sempre achou "estúpido e desinteressante" . No caminho para casa, você ficou preso no trânsito, ouvindo músicas antigas no rádio, a chuva batendo no pára-brisa está balançando você. Depois de um tempo em seu carro, você se vê sozinho em seu pequeno apartamento, incapaz de pensar em outra coisa além dela. Não há luz e você olha através da janela, deixando a escuridão o cercar. Não há com quem conversar, seus amigos já se foram há muito tempo depois de avisá-lo sobre essa nova garota assombrando sua mente. Você inicia o computador, pois é a única coisa que pode fazer, abre o navegador e publica um novo quebra-cabeça de programação para o stackexchange, na tentativa de mudar de idéia.

Desafio

Escreva um programa no idioma de sua escolha simulando a chuva que cai no chão. A saída pode ser composta por caracteres ASCII ou renderizados em 2D / 3D. A câmera está fixa: você está olhando diretamente para o chão. Seu programa deve incluir algum tipo de animação, como atualizar o console ou a página toda vez que você gerar um novo "quadro". Tem que ser realista, eu sei que é um pouco subjetivo, mas digamos que você não pode simplesmente preencher todo o terreno em apenas uma grande gota.

A saída não precisa ser uma imagem, mas se você estiver usando uma linguagem enigmática, é melhor fornecer um .gif para ilustrar como fica em ação (mas, é claro, isso não afetará sua pontuação, se você não o fizer).

Regras

• Sua pontuação é o total de bytes usados
• -20 pontos se você usar cores
• -50 se conseguir render algum tipo de vento
• Menor pontuação ganha

Exemplo

Um exemplo muito básico do que deve ser renderizado:

Espero que você faça melhor e aproveite esse desafio.

Desculpe meu inglês, sinta-se à vontade para editar minha postagem, se você quiser corrigir alguns erros

Entre os melhores

Se o seu nome não estiver listado, é porque sua tentativa foi considerada não adequada às regras.

Tobia - APL - 35  
j6m8 - Processing.js - 38
The Guy with The Hat - Processing - 42  
ace - Processing - 74  
kelunik - JS/CSS - 89  
Riot - Bash - 91  
Michael - JS/jQuery - 105  
Florent - HTML/JS - 123  
David Carraher - Mathematica - 134  
Doorknob - HTML/JS - 150  
undergroundmonorail - Python - 175

Parabéns a Tobia!

APL, 105 caracteres / bytes * - 20 - 50 = 35 pontos

e←{⍞←∊'␛['⍵}
e¨'36m' '?25l' '2J'
{⍵←3⌊⍵+3×0=?t⍴50
⍵{(⍵c)←⍕¨⍵+1
e⍵';'c'H',' .∘⍟'[⍺]}¨⍳t
∇0⌈⍵-1}0⍴⍨t←24 80

*: A maioria das implementações de APL suporta alguma forma de conjunto de caracteres de byte único (legado), que mapeia os símbolos da APL para os valores superiores de 128 bytes. Portanto, para fins de golfe, um programa que usa apenas caracteres ASCII e símbolos APL pode ser pontuado como chars = bytes.

Eu testei no apl.js mais recente do Nick no Node.js em um terminal do OS X. Mas eu não usei nada específico para o dialeto dele, portanto, ele deve funcionar em qualquer APL moderno que possa ser executado em um terminal ANSI e ofereça suporte a d-funs {...}, atribuição de vertente (a b)←...e deslocamento ⍨, como Dyalog para Linux ou Raspberry PI ( com ⎕IO←0)

A ␛linha 1 é um caractere de escape literal (que é de 1 byte). Você pode inseri-lo usando Ctrl-V Escum terminal Linux ou no Vim, ou supostamente algo como Alt-027no Windows. Além disso, não consegui encontrar uma maneira confiável de descobrir o tamanho do terminal; portanto, convém editar o número de linhas e colunas no final da última linha.

Defendo o bônus de 50 pelo fato de que cada gota de chuva passa pelas seguintes formas: ⍟∘.que dão a impressão de um leve vento descendente, dado que a cena está sendo vista de cima. De fato, olhando para o gif abaixo, você deve ter a impressão de que cada gota se move suavemente para baixo e para a esquerda, antes de desaparecer no chão.

Versão não destruída:

e←{⍞←∊"␛["⍵}                  # utility to print escape sequence
e¨'36m' '?25l' '2J'            # set cyan, hide the cursor and clear screen
{                              # repeat (⍵=current board of raindrops)
  ⍵←3⌊⍵+3×0=?t⍴50              #   add some new drops (=3) in random places
  ⍵{                           #   print the drops (⍺=drop value, ⍵=coords)
    (r c)←⍕¨⍵+1                #     convert the coordinates to string
    e r';'c'H',' .∘⍟'[⍺]       #     print or clear the drop
  }¨⍳t                         #   ..
  ∇0⌈⍵-1                       #   remove 1 from every drop and repeat
}0⍴⍨t←24 80                    # ..starting with an empty board

Saída:

APL, estilo diferente

Fora de competição.

m←×/t←1+(ζη)←2×(βγ)←24 80
e←{⍞←∊(⎕UCS 27)'['⍵}
s←{⍵[β-1-⍳β;1+⍳γ]}
p←{⍺{e'H'⍺,⍨{⍺,';',⍵}/⍕¨⍵}¨(,s⍵)/,1+⍳βγ}
e¨'2J' '36m' '?25l'
{'/'p⍵←(200<m÷?t⍴m)∨0⍪⍵[⍳ζ;1+⍳η],0
' 'p(~⍵)∧0,⍵[1+⍳ζ;⍳η]⍪0
'.∘°'[?(+/,sδ)/3]pδ←⍵∧~d←.2<m÷⍨?t⍴m
∇⍵∧d}t⍴0

Aqui, meu objetivo era dar a impressão de gotas de chuva caindo inclinadas e se acumulando no chão, enquanto tentavam manter o número de quedas visíveis (caindo ou salpicadas) constantes, em média. O truque era criar um número de novas gotas caindo /a cada ciclo e fazer com que as gotas "varressem" quaisquer gotas espalhadas pelas quais elas viajassem.

O resultado é estranhamente remanescente do código Matrix.

Saída
(o empurrão a cada 5s é o loop gif)

Bash: 111 bytes - 20 = 91 pontos!

Uma garoa suave e contemplativa em seu terminal. Ajuste os números 819 e 41 para diferentes alturas e larguras, respectivamente.

e='printf \e';while :;do for i in {0..819};do((RANDOM<9))&&$e[1\;36m.||$e[1C;((i%41<1))&&$e'
';done;$e[20A;done

Um bônus agradável é a maneira como o cursor bate na área de chuva.

Edit: encurtando de 140 bytes para 129 bytes, graças às sugestões de @ manatwork. 2ª edição: redução de 129 bytes para 111 bytes, graças às sugestões de @ manatwork e @ Tobia, além de inspiração adicional - consulte os comentários.

(Nota: a captura de tela mostra a versão anterior do código com menos golfe, que é funcionalmente idêntica)

Python, 312 bytes - 50 (vento) = 262

from pygame import*
R=__import__('random').randint
t,u=640,480;init();d=display;s=d.set_mode((t,u))
w=[255]*3;r=range(t)
a=[[R(0,t),R(0,u),R(3,6)]for i in r]
while time.wait(9):
 d.flip();event.get();s.fill(R(0,99)<1and w)
 for i in r:x,y,z=a[i];draw.line(s,w,(x,y),(x+z,y+2*z));a[i][0]=(x+z)%t;a[i][1]=(y+z*2)%u

Saída de amostra (um loop de 50 quadros):

O playpack real é significativamente mais rápido do que os gifs permitem.

HTML / JS, 170 caracteres - 20 = 150 pontos

<canvas id=c></canvas><script>d=400;with(c)width=height=d,t=getContext('2d');t.fillStyle='blue';setInterval("t.fillRect(Math.random()*d,Math.random()*d,5,5)",50)</script>

(nota de rodapé: jogou golfe passando uma string para setInterval, withnomes de variáveis ​​de ID automáticos ... parece tão errado! estremece )

Apenas desenha retângulos azuis aleatórios.

HTML / JS, 309 caracteres - 20 - 50 = 239 pontos

Agora com vento!

<canvas id=c></canvas><script>s=400;r=Math.random;with(c)width=height=s,t=getContext('2d');t.fillStyle='blue';o=[];setInterval("t.clearRect(0,0,s,s);for(i=0;++i<o.length;)d=o[i],t.fillRect(d[0],d[1],d[2],d[2]),d[0]+=1,d[1]+=2,d[2]-=1,d[2]<0?o.splice(i,1):0;if(r()<.6)o.push([r()*400,r()*400,20])",50)</script>

JS + jQuery (172-20-50 = 102)

Copie / cole essa linha no console do navegador (geralmente pressione a tecla F12):

r=Math.random;w=$(window);setInterval("$('<b>♥</b>').css({color:'red',position:'fixed',top:r()*w.height(),left:r()*w.width()}).appendTo('body').animate({fontSize:0},3e3)",9)

Corações vermelhos animados chovem no dia dos namorados!

Mathematica

134 - 20 = 114

2D

n = 99; m = Array[0 &, {n, n}]; r := RandomInteger[{1, n}, {2}]
Table[ArrayPlot[m = ReplacePart[m, r ->  1], ColorRules -> {1 -> Blue}], {k, 250}];
Export["d.gif", d]

3D

A forma da gota de chuva é feita através de um gráfico de revolução em torno do eixo z.

Inicialmente, a chuva é gerada para uma região que se estende bem acima da região de exibição. A aparência da chuva caindo é obtida deslocando o ponto de vista para cima ao longo do eixo z. (É mais eficiente do que recalcular a posição de cada gota de chuva.)

r = RandomInteger; z = Table[{r@30, r@30, r@160}, {100}];
w = RevolutionPlot3D[{.7 Sin[x] Cos[x], 0,   1.4 Sin[x] }, {x, 0, -Pi/2}, 
PerformanceGoal -> "Speed"][[1]];
c = Map[Translate[w, #] &, z]; 
p = Table[Graphics3D[c, PlotRange -> {k, k + 50}], {k, 1, 100}]
Export["p.gif", p]

Com vento

Há uma sobrecarga considerável para fazer a chuva cair com o vento. Mas eu estou incluindo aqui de qualquer maneira.

O piso azul praticamente mantém {x, y} a região confinada à área de interesse. Existem algumas falhas, mas, bem,

r = RandomInteger;
z = Table[{r@120, r@30, r@180}, {800}];
w = RevolutionPlot3D[{.7 Sin[x] Cos[x], 0,   1.4 Sin[x] }, {x, 
     0, -Pi/2}, PerformanceGoal -> "Speed"][[1]];
c = Map[Translate[w, #] &, z];
g[k_, z1_, w_, c1_] :=
 Module[{z2},
  z2 = Cases[z, {x_, _, _} /; 0 + k < x < 30 + k];
  c = Map[Translate[w, #] &, z2];
  Graphics3D[{Polygon[{{0 + k, 0, 1 + k}, {30 + k, 0, 1 + k}, {30 + k,
        30, 1 + k}, {0 + k, 30, 1 + k}}], c}, 
   PlotRange -> {k, k + 50}]]

p = Table[g[k, z, w, c], {k, 1, 100, 1}];
Export["p.gif", p]

De diretamente acima

As gotas de chuva mais próximas são cortadas, mas eu vou esquecer isso.

m=40;
r=RandomInteger;
positions=Table[{r@m,r@m,r@1000},{800}];
g[lowZ_,pos_]:=
Module[{hiZ=lowZ+103},
Graphics3D[{PointSize[Small],White,Point[{{0,0,lowZ},{0,m,lowZ},{m,0,lowZ},{m,m,lowZ},{0,0,hiZ},{0,m,hiZ},{m,0,hiZ},{m,m,hiZ}}],
ImageSize-> 350,Sphere/@Cases[pos,{_,_,z1_}/;lowZ<z1<hiZ-2]},PlotRange->{lowZ,hiZ}, 
ViewPoint-> {0,0,1},ImagePadding->5]]

HTML / JavaScript, 156 123 (143-20)

<body bgcolor=0 onload="t=c.getContext('2d');t.fillStyle='#07d';setInterval('n=Math.random()*4e4;t.fillRect(n%270,n/150,1,1)',1)"><canvas id=c>

Versão anotada:

<body bgcolor="#000">
<canvas id="c"></canvas>
<script>
  onload = function() {
    // Retrieve the rendering context
    t=c.getContext('2d');
    // Set rain color
    t.fillStyle='#07d';
    // Render whenever it is possible
    setInterval(function() {
      // Generate a number between 0 and 40,000
      // 40,000 ~= 270 * 150
      n=Math.random()*4e4;
      // Draw a raindrop.
      // Since x and y are not rounded, the raindrop looks blurry!
      t.fillRect(n%270,n/150,1,1)
    }, 1);
  };
</script>
</body>

Smalltalk (Smalltalk / X)

com vento aleatório ;-)

|BG CLR N1 H W v WIND drops gen newDrops draw remove move buffer|


BG := Color black.
CLR := Color blue lightened.
H := 100.
W := 100.
N1 := 10.
WIND := 0.
drops := OrderedCollection new.

gen := [:n | ((1 to:n) collect:[:i | Random nextIntegerBetween:1 and:W] as:Set) collect:[:x | x@0]].
newDrops := [drops addAll:(gen value:N1)].
draw := [buffer fill:BG; paint:CLR. drops do:[:d | buffer displayPoint:d]].
remove := [drops := drops reject:[:d | d y > H]].
move := [:wind | drops := drops collect:[:d| (d x + wind)\\W @ (d y + 1)]].
v := View new openAndWait.
buffer := Form extent:(v extent) depth:24 onDevice:v device.

[
    [v shown] whileTrue:[
        draw value.
        v displayForm:buffer.
        move value:WIND.
        remove value.
        newDrops value.
        WIND := (WIND+(Random nextBetween:-1 and:1)) clampBetween:-5 and:5.
        Delay waitForSeconds:0.1.
    ]
] fork.

saída em vista:

Processando, 94 - 20 = 74

void setup(){background(0);fill(0,0,255);}
void draw(){ellipse(random(0,99),random(0,99),3,3);}

(Nova linha adicionada para facilitar a leitura.)

Clique aqui para uma demonstração online.

Bater

while true;do echo " / / / / /";echo "/ / / / / ";done

Não tenho certeza se este deve ser um código de golfe, porque não há um requisito estrito sobre como deve ser a "chuva".

EDIT: Se você quiser que a câmera esteja apontando para baixo, use o seguinte:

while true;do echo " . . . . .";echo ". . . . . ";done

Python 2.7: 195 - 20 = 175

Tenho certeza de que há mais coisas a serem feitas aqui, mas é isso que tenho por enquanto:

import os,time
from random import*
l=[i[:]for i in[[' ']*100]*50]
while 1:
 os.system('clear')
 l[randint(0,49)][randint(0,99)]='.'
 print'\033[94m\n'.join(''.join(r)for r in l)
 time.sleep(.05)

Vou postar um gif da saída quando me lembrar de como fazer isso.

Isso funciona no linux. Substituir 'clear'por 'cls'faz funcionar no Windows, mas as cores ANSI não funcionam e eu perco o bônus.

Eu tenho uma matriz 2D de seqüências de caracteres de um caractere, inicializada em . A cada 0,05 segundos, um deles é escolhido aleatoriamente em .e a tela é redesenhada.

from random import*salva dois caracteres import os,time,randome usa random.randint()duas vezes, embora não esteja convencido de que seja a melhor maneira de escolher uma célula. Eu queria usar, random.choice()mas não conseguia pensar em uma maneira de contornar cadeias imutáveis ​​que não desperdiçariam mais caracteres do que economizavam.

132 + 27 - 20 - 50 = 89

Javascript (132)

r=Math.random;setInterval("$('body').append($('<i>∘</i>').css({left:r()*2e3,top:r()*2e3}).animate({left:'+=70',fontSize:0},500))",1)

CSS (27)

i{color:blue;position:fixed

Demonstração: http://jsfiddle.net/kelunik/5WC87/4/embedded/result/

Processando, 62 - 20 = 42

void draw(){stroke(0,0,214);point(random(0,99),random(0,99));}

Gera pixels azuis em um fundo branco. Demonstração em um idioma muito semelhante aqui: https://www.khanacademy.org/cs/rain2/6172053633761280

Processing.js, 86 - 20 = 66

... mas também desaparece lentamente (o chão absorve a chuva, naturalmente). Pontos por isso?

g=99;r=random;void draw(){fill(0,9);rect(0,0,g,g);fill(0,g,r(g));rect(r(g),r(g),2,2);}

Os recursos de bônus incluem variação entre esverdeado e azulado (é claramente chuva suja da 'cidade').

Além disso, fiquei muito satisfeito por poder usar um hack de JavaScript aqui; Observe que, porque isso está processando. js , você pode incluir coisas como a declaração sem tipo de g = 99 ou o alias de rfor random( alias em vários idiomas!).

Alguma outra idéia para minificar?

Versão legível:

g = 99;
r = random;                  // Javascript trickery
void draw() {
    fill(0, 9);
    rect(0, 0, g, g);        // Fade the background
    fill(0, r(g), r);
    rect(r(g), r(g), 2, 2);  // Add a new drop
}

A coisa toda pode ser vista aqui .

... mais outra versão sem desbotamento: 58 - 20 = 38

Se você não gosta de desbotar e não se importa com sujeira cinza:

r=random;void draw(){fill(0,0,255);rect(r(99),r(99),2,2);}

Tcl / Tk, 139 - 20 = 119

Reutilizando minha própria resposta http://codegolf.stackexchange.com/a/143018/29325

Deve ser executado no shell interativo

gri [can .c -w 40 -he 40]
set x 0
wh 1 {.c cr o $x [set y [exp int(rand()*40)]] $x [set x $y] -f #[form %06x [exp int(rand()*255**3)]]
upd}

Infelizmente, converter expr int(rand()*em um procfaz com que o script tenha mais um byte!

Para parar, basta clicar no botão "X" inefável.