Le contexte

C'est la Saint Valentin. La seule que tu aies aimé t'a laissé hier pour ce type qu'elle a toujours trouvé "stupide et sans intérêt" . En rentrant chez vous, vous avez été bloqué dans la circulation, écoutant de vieilles chansons à la radio, la pluie frappant le pare-brise vous secoue. Après un moment dans votre voiture, vous vous retrouvez seul dans votre petit appartement, incapable de penser à autre chose qu’elle. Il n'y a pas de lumière et vous regardez par la fenêtre, laissant l'obscurité vous entourer. Il n'y a personne à qui parler, vos amis sont maintenant partis il y a longtemps après vous avoir avertis que cette nouvelle fille hantait votre esprit. Vous démarrez votre ordinateur, car c'est la seule chose que vous puissiez faire, ouvrez votre navigateur et publiez un nouveau puzzle de programmation sur stackexchange, dans le but de vous faire changer d'avis.

Défi

Ecrivez un programme dans la langue de votre choix en simulant la pluie qui tombe sur le sol. La sortie peut être composée de caractères ASCII ou de rendu 2D / 3D. La caméra est fixe: vous êtes au-dessus de regarder directement vers le sol. Votre programme doit inclure une sorte d'animation, telle que l'actualisation de la console ou de la page chaque fois que vous générez un nouveau "cadre". Cela doit être réaliste, je sais que c'est un peu subjectif, mais disons que vous ne pouvez pas simplement remplir tout le terrain en une seule grosse goutte.

La sortie ne doit pas obligatoirement être une image, mais si vous utilisez un langage crypté, il est préférable de fournir un fichier .gif pour illustrer son apparence (mais, bien entendu, cela n'affectera pas votre score.)

Règles

• Votre score est le total des octets utilisés
• -20 points si vous utilisez des couleurs
• -50 si vous réussissez à rendre une sorte de vent
• Le score le plus bas gagne

Exemple

Un exemple très basique de ce qui devrait être rendu:

J'espère que vous ferez mieux et apprécierez ce défi.

Désolé pour mon anglais, n'hésitez pas à éditer mon post si vous voulez corriger des erreurs

Classement

Si votre nom n'est pas répertorié, c'est parce que votre tentative a été considérée comme non conforme aux règles.

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

Félicitations à Tobia!

APL, 105 caractères / octet * - 20 - 50 = 35 points

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

*: La plupart des implémentations APL prennent en charge une certaine forme de jeu de caractères (octets) à un octet (hérité), qui mappe les symboles APL sur les valeurs supérieures à 128 octets. Par conséquent, dans le but de jouer au golf, un programme qui utilise uniquement des caractères ASCII et des symboles APL peut être noté en tant que caractères = octets.

Je l'ai testé sur le dernier fichier apl.js de Nick sur Node.js dans un terminal OS X. Mais je n’ai utilisé aucun élément spécifique à son dialecte, il devrait donc fonctionner avec les APL modernes pouvant être exécutés sur un terminal ANSI et prenant en charge d-funs {...}, l’assignation de brins (a b)←...et les déplacements ⍨, tels que Dyalog pour Linux ou pour Raspberry PI ( avec ⎕IO←0)

La ␛ligne 1 est un caractère d'échappement littéral (qui est un octet). Vous pouvez le saisir en utilisant Ctrl-V Escun terminal Linux ou Vim, ou supposément quelque chose comme Alt-027Windows. De plus, je ne pouvais pas trouver un moyen fiable de connaître la taille du terminal, vous pouvez donc modifier le nombre de lignes et de colonnes à la fin de la dernière ligne.

Je défends le bonus de 50 par le fait que chaque goutte de pluie présente les formes suivantes: ⍟∘.qui donnent l’impression d’un léger vent vers le bas, étant donné que la scène est vue de haut. En fait, en regardant le gif ci-dessous, vous devriez avoir l’impression que chaque goutte se déplace doucement vers le bas et vers la gauche, avant de disparaître sur le sol.

Version non-golfée:

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

Sortie:

APL, style différent

Hors compétition.

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

Mon objectif était de donner l’impression que les gouttes de pluie tombaient en oblique et s’accumulaient sur le sol, tout en essayant de maintenir en moyenne le nombre de gouttes visibles (en chute ou éclaboussées). L'astuce consistait à créer un certain nombre de nouvelles gouttes tombantes /à chaque cycle et à les faire "éliminer" les éclaboussures qu'elles traversent.

Le résultat rappelle étrangement le code Matrix.

Sortie
(le jerk toutes les 5 secondes est le gif en boucle)

Bash: 111 octets - 20 = 91 points!

Une bruine douce contemplative dans votre terminal. Ajustez les chiffres 819 et 41 en fonction de la hauteur et de la largeur.

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 bonus agréable est la façon dont le curseur passe à travers la zone de pluie.

Edit: raccourcir de 140 octets à 129 octets grâce aux suggestions de @ manatwork. 2ème édition: réduction de 129 octets à 111 octets grâce aux suggestions de @ manatwork et @ Tobia, plus une inspiration supplémentaire - voir les commentaires.

(Remarque: la capture d'écran montre la version précédente du code moins golfée, qui est fonctionnellement identique.)

Python, 312 octets - 50 (vent) = 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

Exemple de sortie (une boucle de 50 images):

Le playpack réel est nettement plus rapide que ne le permettent les gifs.

HTML / JS, 170 caractères - 20 = 150 points

<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: golfed plus loin en passant une chaîne setInterval, withles noms de variables d'identification automatique ... il se sent si mal! frissonne )

Il dessine simplement des rectangles bleus aléatoires.

HTML / JS, 309 caractères - 20 - 50 = 239 points

Maintenant avec le vent!

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

Copier / coller cette ligne dans la console du navigateur (appuyez généralement sur la touche 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)

Des coeurs rouges animés pleuvent pour la Saint-Valentin!

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

La forme de la goutte de pluie est réalisée via un graphe de révolution autour de l'axe z.

Initialement, la pluie est générée pour une région qui s'étend bien au-dessus de la région d'affichage. L'apparition d'une pluie tombante est obtenue en déplaçant le point de vue vers le haut le long de l'axe z. (C'est plus efficace que de recalculer la position de chaque goutte de pluie.)

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]

Avec le vent

Il y a beaucoup de frais généraux pour que la pluie tombe avec le vent. Mais j'inclus ici quand même.

Le sol bleu conserve à peu près la région de la vue {x, y} limitée à la zone d'intérêt. Il y a quelques problèmes, mais, eh bien,

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 directement au-dessus

Les gouttes de pluie les plus proches sont coupées, mais je vais oublier.

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>

Version annotée:

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

avec vent aléatoire ;-)

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

sortie en vue:

Traitement, 94 - 20 = 74

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

(Nouvelle ligne ajoutée pour plus de lisibilité.)

Cliquez ici pour une démonstration en ligne.

Frapper

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

Je ne suis pas sûr que cela devrait être un code de golf car il n'y a pas d'exigence stricte sur ce que doit être la "pluie".

EDIT: Si vous voulez que la caméra pointe vers le bas, utilisez ceci:

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

Python 2.7: 195 - 20 = 175

Je suis sûr qu'il y a plus à faire ici, mais voici ce que j'ai pour l'instant:

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)

Je posterai un gif de la sortie quand je me souviendrai de comment faire cela.

Cela fonctionne sur linux. Remplacer 'clear'par le 'cls'fait fonctionner sur les fenêtres, mais les couleurs ANSI ne fonctionnent pas et je perds le bonus.

J'ai un tableau 2D de chaînes à un caractère, initialisé à . Toutes les 0,05 secondes, l’un d’eux est choisi au hasard .et l’écran est redessiné.

from random import*enregistre deux caractères import os,time,randomet en utilise random.randint()deux fois, bien que je ne sois pas convaincu que ce soit le meilleur moyen de choisir une cellule. Je voulais utiliser random.choice()mais je ne pouvais pas penser à un moyen de contourner des chaînes immuables qui ne gâcheraient pas plus de caractères que ce qui en aurait été sauvé.

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

Démo: http://jsfiddle.net/kelunik/5WC87/4/embedded/result/

Traitement, 62 - 20 = 42

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

Génère des pixels bleus sur un fond blanc. Démonstration dans un langage très similaire ici: https://www.khanacademy.org/cs/rain2/6172053633761280

Traitement.js, 86 - 20 = 66

... mais elle disparaît aussi lentement (le sol absorbe naturellement la pluie). Des points pour ça?

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

Les bonus incluent des variations entre verdâtre et bleuâtre (il est clairement sale "pluie" de la ville).

De plus, j'étais très heureux d'avoir pu utiliser un piratage JavaScript ici; Notez que, car il s’agit d’un traitement. js , vous pouvez ajouter des éléments tels que la déclaration sans type de g = 99 ou le pseudonyme de rfor random( pseudonyme multilingue ).

D'autres idées à minimiser?

Version lisible:

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
}

Le tout peut être vu ici .

... plus une autre version sans fade: 58 - 20 = 38

Si vous n'aimez pas la décoloration et ne craignez pas la saleté grise:

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

Tcl / Tk, 139-20 = 119

Réutilisation de ma propre réponse http://codegolf.stackexchange.com/a/143018/29325

Doit être exécuté dans le shell interactif

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}

Malheureusement, la conversion expr int(rand()*en a procfait que le script a un octet de plus!

Pour arrêter, il suffit de cliquer sur le bouton "X" ineffable.