Écrivez le programme le plus court pour prévoir le temps pour les 7 prochains jours

L'entrée (de stdin) est le jour de la semaine et la saison

La sortie (vers stdout) est de sept lignes en semaine et la température en centigrades

Les jours de la semaine commencent le jour de la semaine d'entrée

Les températures sont des nombres aléatoires dont la plage dépend de la saison

Printemps 10-30 degrés  
Été 20 - 40 degrés  
Automne 5 - 25 degrés (l'automne est synonyme d'automne)
Hiver -5 - 15 degrés

Exemple d'entrée

Thursday Winter

Exemple de sortie

Jeudi -1
Vendredi 3
Samedi 8
Dimanche 7
Lundi 10
Mardi 10
Mercredi -1

Votre programme ne doit pas avoir une sortie identique chaque fois qu'il est exécuté avec la même entrée

Ruby 1.8, 95 caractères

#!ruby -nrdate
7.times{|i|puts (Date.parse($_)+i).strftime"%A #{"\023\004\016\016\035"[$_[-3]%5]-9+rand(21)}"}

Les caractères qui s'échappent à l'intérieur de la chaîne doivent être remplacés par les littéraux de caractères qu'ils représentent.

• Trouvé un moyen plus court pour emballer les données, Ruby 1.9 serait désormais plus long de 4 caractères (ajouter .ordaprès $_[-3]).
• 112 -> 105 en volant l'idée de Joey de ne pas diviser l'entrée.
• 105 -> 101. Notez que la première ligne est en fait analysée par l'interpréteur Ruby lui-même, donc cela fonctionne même lors de l'exécution de la solution comme echo "Thursday Winter" | ruby1.8 forecast.rb
• 101 -> 96. L'idée de Stole Joey à nouveau d'intégrer simplement les températures dans une chaîne au lieu d'un tableau.
• Oups, je viens de remarquer que ce devrait être rand (21), pas rand (20).
• 96 -> 95. Suppression des espaces inutiles.

Windows PowerShell, 104

[dayofweek]$d,$s=-split$input
(0..6*2)[+$d..(6+$d)]|%{''+[dayofweek]$_,((random 20)-5+'☼

↓'[$s[3]%5])}

Les chaînes sont un peu capricieuses, donc une vue hexadécimale pour votre commodité:

000: 5B 64 61 79 6F 66 77 65 │ 65 6B 5D 24 64 2C 24 73  [dayofweek]$d,$s
010: 3D 2D 73 70 6C 69 74 24 │ 69 6E 70 75 74 0A 28 30  =-split$input◙(0
020: 2E 2E 36 2A 32 29 5B 2B │ 24 64 2E 2E 28 36 2B 24  ..6*2)[+$d..(6+$
030: 64 29 5D 7C 25 7B 27 27 │ 2B 5B 64 61 79 6F 66 77  d)]|%{''+[dayofw
040: 65 65 6B 5D 24 5F 2C 28 │ 28 72 61 6E 64 6F 6D 20  eek]$_,((random
050: 32 30 29 2D 35 2B 27 0F │ 00 0A 0A 19 27 5B 24 73  20)-5+'☼ ◙◙↓'[$s
060: 5B 33 5D 25 35 5D 29 7D │                          [3]%5])}

Histoire:

• 2011-02-04 00:16 (179) - Première tentative simple.
• 2011-02-04 00:20 (155) - Pourquoi faire correspondre des noms de saison entière quand vous pouvez vous en sortir avec des personnages individuels et un match regex? Ne traitera pas bien avec une entrée invalide, mais c'est toujours à prévoir dans le golf.
• 2011-02-06 13:12 (149) - Je me suis débarrassé de $tce qui n'a fait qu'allonger les choses.
• 2011-02-10 22:50 (142) - La génération de noms de jour simplifiée. Je génère juste une semaine deux fois, indexe dans la bonne position et retire sept articles.
• 2011-02-10 22:52 (138) - Déplacer la distribution initiale vers la déclaration de $dsauvegarde également quelques octets - et se débarrasse de $x.
• 2011-02-10 23:03 (135) - Déplacer le casting plus loin dans le pipeline pour éviter un casting de tableau (qui a besoin de plus []). La sortie a également été modifiée pour convertir une liste d'objets en chaîne qui insère implicitement un espace ( $OFSpar défaut).
• 2011-02-11 20:54 (132) - Remplacement de la correspondance regex par une liste de codes de caractères et indexation dans une table de hachage avec le troisième caractère de la saison.
• 2011-02-11 21:00 (122) - Remplacement de la carte de hachage par un tableau.
• 2011-02-11 21:12 (117) - Plus de bonté matricielle. Et plus court pour démarrer. Modulo 8 emballe le tableau un peu plus court.
• 2011-02-11 21:16 (116) - Extrait d'un facteur de cinq à remplacer 0,0,2par 0..2lequel est plus court.
• 2011-02-11 21:22 (114) - Utilisé un calcul légèrement différent. Il mappe toujours l'automne et l'automne au même indice et a l'avantage de ne nécessiter que cinq valeurs. Très agréable. L'index négatif dans la chaîne joue également très bien avec »Fall« étant plus court que le reste.
• 2011-02-11 21:45 (112) - Stolen Ventero a déterminé la plage de températures de la saison qui est de deux octets plus courte.
• 2011-02-12 03:16 (105) - Retour à 105 après une tentative différente vient d'imprimer une seule ligne.
• 2011-02-12 13:23 (104) - Revenons à 104 à nouveau, en utilisant un indice positif dans la saison depuis que je me suis à nouveau séparé.

Script de test (tant qu'il ne produit rien, le résultat est correct):

foreach ($d in 'Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday') {
    foreach ($s in 'Winter','Summer','Spring','Autumn','Fall') {
        $o=-split("$d $s"|./weather_foo.ps1)
        if ($o.Count -ne 14) { "Wrong output length" }
        $days = $o -notmatch '\d'
        $temps = $o -match '\d'
        if ($days[0]-ne$d) { "Found "+ $days[0] + " instead of $d" }
        $m = $temps | measure -min -max
        switch ($s) {
            'Summer'{ $min = 20 }
            'Spring'{ $min = 10 }
            'Fall'  { $min = 5  }
            'Autumn'{ $min = 5  }
            'Winter'{ $min = -5 }
        }

        if ($m.Minimum -lt $min) { "Minimum temperature $($m.Minimum) didn't match for $s" }
        if ($m.Maximum -gt $min + 20) { "Maximum temperature $($m.Maximum) didn't match for $s" }
    }
}

Golfscript - 110 caractères

' ':^/){*}*43845%7&5*:|;){*}*333121%7&:$;7,{($+'Sun Mon Tues Wednes Thurs Fri Satur'^/.+='day '+20rand|+5-+n}/

• Supporte entièrement toutes les plages de températures, les saisons et prend également en charge "Fall" comme synonyme de "Autumn".
• Je pense qu'il y a des améliorations à apporter, mais mes connaissances actuelles sur le golf sont limitées jusqu'à présent.

Voici les tests, 2 passes chacun pour confirmer le caractère aléatoire

$ echo -n Thursday Spring | gs codegolf-404.gs
Thursday 23
Friday 28
Saturday 25
Sunday 22
Monday 19
Tuesday 14
Wednesday 25

$ echo -n Thursday Spring | gs codegolf-404.gs
Thursday 27
Friday 12
Saturday 26
Sunday 12
Monday 27
Tuesday 17
Wednesday 21


$ echo -n Friday Autumn | gs codegolf-404.gs
Friday 10
Saturday 5
Sunday 17
Monday 24
Tuesday 24
Wednesday 12
Thursday 18

$ echo -n Friday Autumn | gs codegolf-404.gs
Friday 13
Saturday 7
Sunday 14
Monday 6
Tuesday 14
Wednesday 21
Thursday 5


$ echo -n Sunday Summer | gs codegolf-404.gs
Sunday 39
Monday 31
Tuesday 35
Wednesday 34
Thursday 21
Friday 36
Saturday 28

$ echo -n Sunday Summer | gs codegolf-404.gs
Sunday 34
Monday 20
Tuesday 30
Wednesday 39
Thursday 30
Friday 31
Saturday 37


$ echo -n Monday Fall | gs codegolf-404.gs
Monday 6
Tuesday 7
Wednesday 18
Thursday 13
Friday 7
Saturday 5
Sunday 14

$ echo -n Monday Fall | gs codegolf-404.gs
Monday 16
Tuesday 22
Wednesday 19
Thursday 23
Friday 21
Saturday 9
Sunday 17


$ echo -n Saturday Winter | gs codegolf-404.gs
Saturday 0
Sunday -5
Monday 10
Tuesday -3
Wednesday -5
Thursday 13
Friday -1

$ echo -n Saturday Winter | gs codegolf-404.gs
Saturday -4
Sunday 13
Monday 11
Tuesday 0
Wednesday 0
Thursday -5
Friday 9


$ echo -n Tuesday Summer | gs codegolf-404.gs
Tuesday 38
Wednesday 29
Thursday 25
Friday 29
Saturday 34
Sunday 20
Monday 39

$ echo -n Tuesday Summer | gs codegolf-404.gs
Tuesday 33
Wednesday 26
Thursday 31
Friday 37
Saturday 39
Sunday 24
Monday 28


$ echo -n Wednesday Winter | gs codegolf-404.gs
W    ednesday 7
Thursday 12
Friday 0
Saturday -3
Sunday 11
Monday 14
Tuesday 8

$ echo -n Wednesday Winter | gs codegolf-404.gs
Wednesday 0
Thursday -1
Friday 7
Saturday 12
Sunday -5
Monday -3
Tuesday 2

D: 436 caractères

import std.algorithm, std.random, std.range, std.stdio, std.typecons;

void main(string[] g)
{
    alias canFind w;
    alias tuple t;

    auto s = g[2];
    auto e = w(s, "g") ? t(10, 30) : w(s, "Su") ? t(20, 40) : w(s, "W") ? t(-5, 15) : t(5, 25) ;
    auto r = rndGen();

    int v()
    {
        r.popFront();
        return e[0] + cast(int)(r.front % (e[1] - e[0]));
    }

    auto x = findSplitBefore(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], [g[1]]);

    foreach(q; chain(x[1], x[0]))
        writefln("%s %s", q, v());
}

Version avec espaces blancs superflus supprimés (c'est ainsi que ça fait 436 caractères):

import std.algorithm,std.random,std.range,std.stdio,std.typecons;void main(string[] g){alias canFind w;alias tuple t;auto s=g[2];auto e=w(s,"g")?t(10,30):w(s,"Su")?t(20,40):w(s,"W")?t(-5,15):t(5,25);auto r=rndGen();int v(){r.popFront();return e[0]+cast(int)(r.front%(e[1]-e[0]));}auto x=findSplitBefore(["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],[g[1]]);foreach(q;chain(x[1],x[0]))writefln("%s %s",q,v());}

PHP, 353 319 305 304 288 caractères

<?$i=split(" ",fgets(STDIN));$d=$i[0][0].$i[0][1];$s=$i[1][2];$r=json_decode('{"i":[10,30],"m":[20,40],"t":[5,25],"n":[-5,15]}',true);$n=array(Sun,Mon,Tues,Wednes,Thurs,Fri,Satur);$z=$x=0;while($z<7)if($n[++$x][0].$n[$x][1]==$d||$z){$z++;echo$n[$x%7]."day ".rand($r[$s][0],$r[$s][1])."
";}

Non golfé

<?php
    $input = fgets(STDIN);
    $info = split(" ", $input);
    $day = substr($info[0], 0, 2);
    $season = $info[1][2];
    $range[i][] = 10;
    $range[i][] = 30;
    $range[m][] = 20;
    $range[m][] = 40;
    $range[t][] = 5;
    $range[t][] = 25;
    $range[n][] = -5;
    $range[n][] = 15;
    $days[0] = "Sun";
    $days[1] = "Mon";
    $days[2] = "Tues";
    $days[3] = "Wednes";
    $days[4] = "Thurs";
    $days[5] = "Fri";
    $days[6] = "Satur";

    $i = $d = 0;

    while($i<7)
        if(substr($days[++$d], 0, 2)==$day||$i){
            $i++;
            echo $days[$d%7]."day ".rand($range[$season][0], $range[$season][1])."\n";
        }
?>

305 -> 304: Commuté la nouvelle ligne
304 -> 288: Utilise les tableaux JSON au lieu des tableaux PHP

Caractères C # 350

Il doit y avoir un moyen plus efficace que cela. Mais voici ce que j'ai jusqu'à présent:

using System;class P{static void Main(string[]x){var r=new Random();var s=x[1][2];int l=s=='r'?10:s=='m'?20:s=='n'?-5:5,u=s=='r'?31:s=='m'?41:s=='n'?16:26,i=0,z=(int)Enum.Parse(typeof(DayOfWeek),x[0]);for(;i<7;i++){var d=z<1?"Sun":z<2?"Mon":z<3?"Tues":z<4?"Wednes":z<5?"Thurs":z<6?"Fri":"Satur";Console.WriteLine(d+"day "+r.Next(l,u));z=z>5?0:z+1;}}}

Ou dans un format plus lisible, avec quelques commentaires:

using System;
class P 
{
    static void Main(string[] x) 
    {
        var r = new Random();
        var s = x[1][2]; //3rd char of season, first where all have unique letter

   // lower & upper limits for random, based on season
        int l = s == 'r' ? 10 : s == 'm' ? 20 : s == 'n' ? -5 : 5, 
            u = s == 'r' ? 31 : s == 'm' ? 41 : s == 'n' ? 16 : 26, 
            i = 0,
   // this line makes me cringe, but converting to an int and back seems
   // the easiest way to loop through days
            z = (int)Enum.Parse(typeof(DayOfWeek), x[0]); 

        for (; i < 7; i++) 
        { 
            var d = z < 1 ? "Sun" : z < 2 ? "Mon" : z < 3 ? "Tues" : z < 4 ? "Wednes" : z < 5 ? "Thurs" : z < 6 ? "Fri" : "Satur";
            Console.WriteLine(d + "day " + r.Next(l, u)); 
            z = z > 5 ? 0 : z + 1; // increments day, resets to 0 after saturday
        }
    }
}

PHP - 150 caractères

<?$t=array("m"=>15,"r"=>5,"n"=>-10);for($a=split(" ",fgets(STDIN));$i<7;$i++)echo date("l ",strtotime($a[0]."+$i day")),rand(5,25)+$t[$a[1][2]],"\n";

J'ai pensé que j'écrirais ma propre solution PHP après que la solution actuelle ne satisfasse même pas complètement les conditions du défi.

Il s'appuie sur strtotime pour analyser la journée et la date pour la reprendre. Pour déterminer la saison, il suit la troisième lettre du nom de la saison, qui est unique (comme indiqué).

Pour fonctionner correctement, il faut désactiver les notifications et activer les balises courtes.

Javascript - 251 caractères

d=['Mon','Tues','Wednes','Thurs','Fri','Satur','Sun'],g=function(c){return Math.random()*21+c|0},p=prompt();for(i=0,j=7,t=true;i<j;i++){t=t&&p.indexOf(d[i])!=0;t?j++:console.log(d[i>6?i-7:i]+'day '+g(/mm/.test(p)?20:/g/.test(p)?10:/te/.test(p)?-5:5))}

Malheureusement, le script ne répond pas à l'exigence stdin / stdout mais il accepte Fall comme synonyme de Autumn.

Espaces blancs:

  d = [
    'Mon'
  , 'Tues'
  , 'Wednes'
  , 'Thurs'
  , 'Fri'
  , 'Satur'
  , 'Sun'
  ]
, g = function(c) {
    return Math.random()*21+c|0
  }
, p = prompt()

  ;

  for(i = 0, j = 7, t = true; i < j; i++) {
    t = t && p.indexOf(d[i]) != 0; 
    t ? 
      j++ : 
      console.log(d[i > 6 ? i - 7 : i] + 'day ' + g(/mm/.test(p) ? 
                                                      20 : 
                                                    /g/.test(p) ? 
                                                      10 : 
                                                    /te/.test(p) ? 
                                                      -5 : 
                                                      5
                                                    )
                  )
  }

Mathematica 218

s_~g~d_ := 
Grid@RotateLeft[r = Thread@{DateString[{2012, 1, #}, {"DayName"}] & /@ Range@7, 
  RandomInteger[Cases[{{"Spring", {10, 30}}, {"Summer", {20, 40}}, {"Autumn", {5, 25}}, 
  {"Winter", {-5, 15}}}, {s, _}][[1, 2]], 7]}, Position[r, d][[1, 1]] - 1]

Usage

g["Winter", "Sunday"]

Python 2, 220 caractères

Un peu grand mais (presque) lisible.

import random
c,e=raw_input().split()
a=[d+'day'for d in'Mon Tues Wednes Thurs Fri Satur Sun'.split()]*2
x='rmtn'.index(e[2])*2
g=(10,30,20,40,5,25,-5,15)[x:x+2]
f=a.index(c)
for b in a[f:f+7]:
 print b,random.randint(*g)

Production

# echo "Monday Summer" | python forecast.py 
Monday 33
Tuesday 29
Wednesday 33
Thursday 28
Friday 25
Saturday 21
Sunday 30