Contesto

È San Valentino. L'unica che hai mai amato ti ha lasciato ieri per questo ragazzo che ha sempre trovato "stupido e poco interessante" . Sulla strada di casa, sei stato bloccato nel traffico, ascoltando vecchie canzoni alla radio, la pioggia che colpisce il parabrezza ti sta scuotendo. Dopo un po 'in macchina, ti ritrovi solo nel tuo piccolo appartamento a non riuscire a pensare ad altro che a lei. Non c'è luce e guardi attraverso la finestra, lasciando che l'oscurità ti circonda. Non c'è nessuno con cui parlare, i tuoi amici se ne sono andati molto tempo fa dopo averti avvertito di questa nuova ragazza che ti perseguita. Avvii il tuo computer, poiché è l'unica cosa che puoi fare, apri il tuo browser e pubblica un nuovo puzzle di programmazione su StackExchange, nel tentativo di cambiare idea.

Sfida

Scrivi un programma nella lingua che preferisci simulando la pioggia che cade a terra. L'output può essere composto da caratteri ASCII o rendering 2D / 3D. La fotocamera è fissa: stai guardando in alto a terra. Il tuo programma deve includere una sorta di animazione come l'aggiornamento della console o della pagina ogni volta che generi un nuovo "frame". Deve essere realistico, lo so che è un po 'soggettivo, ma diciamo che non puoi riempire tutto il terreno in una sola grande goccia.

L'output non deve essere un'immagine ma se stai usando un linguaggio criptico è meglio fornire un .gif per illustrare come appare in azione (ma ovviamente non influenzerà il tuo punteggio se non lo fai).

Regole

• Il tuo punteggio è il totale dei byte utilizzati
• -20 punti se usi i colori
• -50 se riesci a rendere un qualche tipo di vento
• Il punteggio più basso vince

Esempio

Un esempio molto semplice di ciò che dovrebbe essere reso:

Spero che farai meglio e godrai di questa sfida.

Ci scusiamo per il mio inglese, sentiti libero di modificare il mio post se vuoi correggere alcuni errori

Classifica

Se il tuo nome non è elencato è perché il tuo tentativo è stato considerato non conforme alle regole.

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

Congratulazioni a Tobia!

APL, 105 caratteri / byte * - 20-50 = 35 punti

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

*: La maggior parte delle implementazioni APL supporta una qualche forma di set di caratteri a byte singolo (legacy), che associa i simboli APL ai valori superiori di 128 byte. Pertanto, ai fini del golf, un programma che utilizza solo caratteri ASCII e simboli APL può essere valutato come caratteri = byte.

L'ho provato sugli ultimi apl.js di Nick su Node.js in un terminale OS X. Ma non ho usato nulla di specifico per il suo dialetto, quindi dovrebbe funzionare su qualsiasi APL moderno che può essere eseguito su un terminale ANSI e supporta d-funs {...}, assegnazione di fili (a b)←...e pendolari ⍨, come Dyalog per Linux o per Raspberry PI ( con ⎕IO←0)

La ␛riga 1 è un carattere letterale di escape (che è 1 byte). Puoi inserirlo usando Ctrl-V Escin un terminale Linux o in Vim, o presumibilmente qualcosa di simile Alt-027a Windows. Inoltre, non sono riuscito a trovare un modo affidabile per scoprire le dimensioni del terminale, quindi potresti voler modificare il numero di righe e colonne alla fine dell'ultima riga.

Difendo il bonus di 50 dal fatto che ogni goccia di pioggia ha le seguenti forme: ⍟∘.che danno l'impressione di un leggero vento verso il basso, dato che la scena viene vista dall'alto. In effetti, guardando la gif qui sotto, dovresti avere l'impressione che ogni goccia si muova delicatamente verso il basso e verso sinistra, prima di scomparire sul terreno.

Versione non golfata:

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

Produzione:

APL, stile diverso

Fuori concorso.

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

Qui il mio obiettivo era quello di dare l'impressione che le gocce di pioggia cadessero con una pendenza e si accumulassero sul terreno, mentre cercavo di mantenere costante il numero di gocce visibili (che cadevano o schizzavano). Il trucco era creare un numero di nuove gocce cadenti /ad ogni ciclo e far sì che le gocce cadenti "spazzino via" tutte quelle schizzate che attraversano.

Il risultato ricorda stranamente il codice Matrix.

Output
(il jerk ogni 5 s è il loop gif)

Bash: 111 byte - 20 = 91 punti!

Un lieve pioggerella contemplativa nel tuo terminale. Regola i numeri 819 e 41 rispettivamente per altezza e larghezza diverse.

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

Un piacevole bonus è il modo in cui il cursore schizza via attraverso l'area della pioggia.

Modifica: accorciamento da 140 byte a 129 byte grazie ai suggerimenti di @ manatwork. 2a modifica: accorciamento da 129 byte a 111 byte grazie ai suggerimenti di @ manatwork e @ Tobia, oltre a un'ispirazione aggiuntiva - vedere i commenti.

(Nota: lo screenshot mostra la precedente versione meno giocata del codice, che è funzionalmente identica)

Python, 312 byte - 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

Esempio di output (un loop da 50 frame):

Il playpack reale è significativamente più veloce di quanto consentito dalle gif.

HTML / JS, 170 caratteri - 20 = 150 punti

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

(sidenote: golfato ulteriormente passando una stringa a setInterval, withnomi di variabili ID automatiche ... sembra così sbagliato! Brividi )

Disegna solo rettangoli blu casuali.

HTML / JS, 309 caratteri - 20-50 = 239 punti

Ora con il 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)

Copia / incolla quella linea nella console del browser (generalmente premi il tasto 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)

Pioggia di cuori rossi animati per San Valentino!

matematica

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

La forma della goccia di pioggia viene creata tramite un diagramma di rivoluzione attorno all'asse z.

Inizialmente, la pioggia viene generata per una regione che si estende ben al di sopra della regione di visualizzazione. L'aspetto della pioggia che cade si ottiene spostando il punto di vista verso l'alto lungo l'asse z. (È più efficiente del ricalcolo della posizione di ogni goccia di pioggia.)

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]

Con Il Vento

C'è un notevole sovraccarico per far cadere la pioggia con il vento. Ma sto includendo comunque qui.

Il pavimento blu mantiene quasi {x, y} la regione di visualizzazione confinata all'area di interesse. Ci sono alcuni problemi, ma, oh bene,

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]

Dall'alto

Le gocce di pioggia più vicine sono tagliate ma lo trascurerò.

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>

Versione annotata:

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

con vento casuale ;-)

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

uscita in vista:

Elaborazione, 94-20 = 74

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

(Nuova riga aggiunta per leggibilità.)

Clicca qui per una demo online.

bash

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

Non sono sicuro che questo dovrebbe essere un codice golf perché non c'è un requisito rigoroso su come deve essere la "pioggia".

EDIT: Se vuoi che sembri che la fotocamera sia puntata verso il basso, usa questo:

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

Python 2.7: 195-20 = 175

Sono sicuro che c'è di più che si può fare qui, ma questo è quello che ho per ora:

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)

Pubblicherò un gif dell'output quando mi ricordo come farlo.

Funziona su Linux. Sostituzione'clear' con lo 'cls'fa funzionare su Windows, ma poi i colori ANSI non funzionano e perdo il bonus.

Ho una matrice 2D di stringhe di un carattere, inizializzata su . Ogni 0,05 secondi, uno di questi viene scelto in modo casuale su .e lo schermo viene ridisegnato.

from random import*salva due personaggi import os,time,randome ne usa random.randint()due volte, anche se non sono convinto che sia il modo migliore di scegliere una cella. Volevo usarlo random.choice()ma non riuscivo a pensare a un modo per aggirare stringhe immutabili che non sprecasse più caratteri di quanti ne salvasse.

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

Demo: http://jsfiddle.net/kelunik/5WC87/4/embedded/result/

Elaborazione, 62-20 = 42

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

Genera pixel blu su uno sfondo bianco. Dimostrazione in un linguaggio molto simile qui: https://www.khanacademy.org/cs/rain2/6172053633761280

Processing.js, 86 - 20 = 66

... ma svanisce lentamente (il terreno assorbe la pioggia, naturalmente). Punti per quello?

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

Le caratteristiche bonus includono la variazione tra verdastro e bluastro (è chiaramente sporca la pioggia di "città").

Inoltre, sono stato molto contento di aver potuto usare un hack JavaScript qui; Si noti che, poiché si sta elaborando. js , puoi aggiungere cose come la dichiarazione senza nome di g = 99 o l'alias di rfor random(alias in più lingue!).

Altre idee da minimizzare?

Versione leggibile:

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
}

Il tutto può essere visualizzato qui .

... più un'altra versione senza dissolvenza: 58-20 = 38

Se non ti piace lo sbiadimento e non ti dispiace lo sporco grigio:

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

Tcl / Tk, 139-20 = 119

Riutilizzando la mia risposta http://codegolf.stackexchange.com/a/143018/29325

Deve essere eseguito nella shell interattiva

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}

Sfortunatamente, la conversione expr int(rand()*in un procrende lo script un byte in più!

Per interrompere, è sufficiente fare clic sull'ineffabile pulsante "X".