Escriba el programa más corto para pronosticar el clima para los próximos 7 días.

La entrada (de stdin) es el día de la semana y la temporada

La salida (a stdout) es de siete líneas entre semana y la temperatura en centígrados

Los días de semana comienzan en el día de la entrada

Las temperaturas son números aleatorios cuyo rango depende de la temporada.

Primavera 10-30 grados  
Verano 20 - 40 grados  
Otoño 5 - 25 grados (otoño es sinónimo de otoño)
Invierno -5 - 15 grados

Entrada de muestra

Thursday Winter

Salida de muestra

Jueves -1
Viernes 3
Sábado 8
Domingo 7
Lunes 10
Martes 10
Miércoles -1

Su programa no debe tener una salida idéntica cada vez que se ejecuta con la misma entrada

Ruby 1.8, 95 caracteres

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

Los caracteres que escapan dentro de la cadena deben reemplazarse por los literales de caracteres que representan.

• Encontró una forma más corta de empaquetar los datos, Ruby 1.9 tendría ahora 4 caracteres más (agregar .orddespués$_[-3] ).
• 112 -> 105 robando la idea de Joey de no dividir la entrada.
• 105 -> 101. Tenga en cuenta que la primera línea en realidad es analizada por el propio intérprete de Ruby, por lo que incluso funciona cuando se ejecuta la solución como echo "Thursday Winter" | ruby1.8 forecast.rb
• 101 -> 96. Robó la idea de Joey nuevamente para integrar las temperaturas en una cadena en lugar de una matriz.
• Vaya, acabo de notar que debería ser rand (21), no rand (20).
• 96 -> 95. Eliminado espacios en blanco innecesarios.

Windows PowerShell, 104

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

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

Las cadenas allí son un poco repulsivas, por lo que una vista hexadecimal para su conveniencia:

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

Historia:

• 2011-02-04 00:16 (179) - Primero, intento directo.
• 2011-02-04 00:20 (155) - ¿Por qué combinar nombres de temporada completa cuando puedes salirte con personajes individuales y una combinación de expresiones regulares? No se tratará bien con entradas no válidas, pero eso siempre es de esperar en Golf.
• 2011-02-06 13:12 (149) - Me deshice de$t que solo alargaba las cosas.
• 2011-02-10 22:50 (142) - La generación del nombre del día se simplificó. Acabo de generar una semana dos veces, indexar en la posición correcta y sacar siete elementos.
• 2011-02-10 22:52 (138) - Mover la conversión inicial a la declaración de $dguardar también unos pocos bytes, y se deshace de él $x.
• 2011-02-10 23:03 (135) - Mover el yeso más abajo en la tubería para evitar un molde de matriz (que necesita más []). También cambió la salida para convertir una lista de objetos en una cadena que inserta implícitamente un espacio ( $OFSpredeterminado).
• 2011-02-11 20:54 (132) - Reemplazó la coincidencia de expresiones regulares por una lista de códigos de caracteres e indexación en un hashmap con el tercer personaje de la temporada.
• 2011-02-11 21:00 (122) - Reemplazó el mapa hash por una matriz.
• 2011-02-11 21:12 (117) - Más bondad de matriz. Y más corto para arrancar. El módulo 8 empaqueta la matriz un poco más corta.
• 2011-02-11 21:16 (116) - Se extrajo un factor de cinco para reemplazar 0,0,2por el 0..2cual es más corto.
• 2011-02-11 21:22 (114) - Usó un cálculo ligeramente diferente. Todavía asigna otoño y otoño al mismo índice y tiene la ventaja de requerir solo cinco valores. Muy agradable. El índice negativo en la cadena también juega muy bien con »Fall« siendo más corto que el resto.
• 2011-02-11 21:45 (112) - La forma robada de Ventero de determinar el rango de temperatura de la temporada, que es dos bytes más corto.
• 2011-02-12 03:16 (105) - Regreso a 105 después de que un intento diferente acaba de imprimir una sola línea.
• 2011-02-12 13:23 (104) - De nuevo a 104, usando un índice positivo en la temporada desde que me separé nuevamente.

Script de prueba (siempre que no muestre nada, el resultado está bien):

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 caracteres

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

• Admite todos los rangos de temperatura, estaciones y también admite "Otoño" como sinónimo de "Otoño".
• Creo que hay algunas posibilidades de mejora, pero mi conocimiento actual de golfscript es limitado hasta ahora.

Aquí están las pruebas, 2 pasa cada una para confirmar la aleatoriedad

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

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

Versión con espacios en blanco extraños eliminados (que es como se trata de 436 caracteres):

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 caracteres

<?$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])."
";}

Sin 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: Cambió la nueva línea
304 -> 288: Utiliza matrices JSON en lugar de matrices PHP

Personajes C # 350

Debe haber una forma más eficiente que esta. Pero esto es lo que tengo hasta ahora:

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

O en un formato más legible, con un par de comentarios:

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 caracteres

<?$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";

Pensé que escribiría mi propia solución PHP después de que la actual ni siquiera satisface completamente las condiciones de desafío.

Se basa en el tiempo de ejecución para analizar el día y la fecha para repetirlo. Para determinar la temporada, sigue la tercera letra del nombre de la temporada, que es única (como se indica).

Para ejecutarse correctamente, se requiere que se desactiven los avisos y se habiliten etiquetas cortas.

Javascript - 251 caracteres

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

Lamentablemente, el script no cumple con el requisito stdin / stdout, pero acepta Fall como sinónimo de Autumn.

Espacio en blanco:

  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]

Uso

g["Winter", "Sunday"]

Python 2, 220 caracteres

Un poco grande pero (casi) legible.

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)

Salida

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