Schreiben Sie das kürzeste Programm, um das Wetter für die nächsten 7 Tage vorherzusagen

Die Eingabe (von stdin) ist der Wochentag und die Jahreszeit

Die Ausgabe (zu stdout) ist sieben Zeilen Wochentag und die Temperatur in Celsius

Die Wochentage beginnen am eingegebenen Wochentag

Die Temperaturen sind Zufallszahlen und variieren je nach Jahreszeit

Frühling 10 - 30 Grad  
Sommer 20 - 40 Grad  
Herbst 5 - 25 Grad (Herbst ist ein Synonym für Herbst)
Winter -5 - 15 Grad

Sample Input

Thursday Winter

Beispielausgabe

Donnerstag -1
Freitag 3
Samstag 8
Sonntag 7
Montag 10
Dienstag 10
Mittwoch -1

Ihr Programm darf nicht jedes Mal dieselbe Ausgabe haben, wenn es mit derselben Eingabe ausgeführt wird

Ruby 1.8, 95 Zeichen

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

Die in der Zeichenfolge entweichenden Zeichen sollten durch die Zeichenliterale ersetzt werden, die sie darstellen.

• Wenn Ruby 1.9 eine kürzere Methode zum Packen der Daten gefunden hat, ist es jetzt 4 Zeichen länger ( .ordnachher hinzufügen $_[-3]).
• 112 -> 105 durch Diebstahl von Joeys Idee, die Eingabe nicht aufzuteilen.
• 105 -> 101. Beachten Sie, dass die erste Zeile tatsächlich vom Ruby-Interpreter selbst analysiert wird, sodass sie auch dann funktioniert, wenn die Lösung wie folgt ausgeführt wird echo "Thursday Winter" | ruby1.8 forecast.rb
• 101 -> 96. Habe Joeys Idee wieder gestohlen, die Temperaturen einfach in einen String anstatt in ein Array einzubetten.
• Hoppla, habe gerade bemerkt, dass es rand (21) sein sollte, nicht rand (20).
• 96 -> 95. Unnötiges Leerzeichen entfernt.

Windows PowerShell, 104

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

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

Die Zeichenfolgen dort sind ein bisschen icky, also eine hexadezimale Ansicht für Ihre Bequemlichkeit:

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

Geschichte:

• 2011-02-04 00:16 (179) - Erster, unkomplizierter Versuch.
• 2011-02-04 00:20 (155) - Warum werden ganze Saisonnamen abgeglichen, wenn Sie mit einzelnen Charakteren und einem Regex-Match davonkommen können? Wird nicht gut mit ungültigen Eingaben umgehen, aber das ist beim Golfen immer zu erwarten.
• 2011-02-06 13:12 (149) - Wurde entfernt, $twodurch nur die Dinge verlängert wurden.
• 2011-02-10 22:50 (142) - Die Erstellung von Tagesnamen wurde vereinfacht. Ich erstelle nur zweimal eine Woche, indexiere in der richtigen Position und ziehe sieben Elemente heraus.
• 2011-02-10 22:52 (138) - Wenn Sie die ursprüngliche Umwandlung in die Deklaration von " $dsaves" verschieben, werden auch einige Bytes gespart und entfernt $x.
• 2011-02-10 23:03 (135) - Verschieben Sie die Besetzung weiter nach unten, um eine Array-Besetzung zu vermeiden (die zusätzliche benötigt []). Außerdem wurde die Ausgabe dahingehend geändert, dass eine Liste von Objekten in einen String umgewandelt wird, der implizit ein Leerzeichen einfügt ( $OFSStandard).
• 2011-02-11 20:54 (132) - Die Regex-Übereinstimmung wurde durch eine Liste von Zeichencodes ersetzt und in eine Hashmap mit dem dritten Zeichen aus der Saison indexiert.
• 2011-02-11 21:00 (122) - Die Hash-Karte wurde durch ein Array ersetzt.
• 2011-02-11 21:12 (117) - Mehr Array-y-Güte. Und kürzer zu booten. Modulo 8 packt das Array etwas kürzer.
• 2011-02-11 21:16 (116) - Ein Faktor fünf zum Ersetzen 0,0,2wurde extrahiert, 0..2der kürzer ist.
• 2011-02-11 21:22 (114) - Es wurde eine etwas andere Berechnung verwendet. Es ordnet immer noch Herbst und Herbst demselben Index zu und hat den Vorteil, dass nur fünf Werte erforderlich sind. Sehr schön. Der negative Index in der Saite spielt sich auch sehr gut ab, da »Fall« kürzer ist als der Rest.
• 2011-02-11 21:45 (112) - Die Methode von Stolen Ventero zur Bestimmung des um zwei Byte kürzeren Temperaturbereichs der Saison.
• 2011-02-12 03:16 (105) - Zurück zu 105, nachdem ein anderer Versuch nur eine einzelne Zeile gedruckt hat.
• 2011-02-12 13:23 (104) - Wieder zurück zu 104, wobei ein positiver Index für die Saison verwendet wird, seit ich mich wieder getrennt habe.

Testskript (solange es nichts ausgibt, ist das Ergebnis in Ordnung):

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 Zeichen

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

• Unterstützt alle Temperaturbereiche, Jahreszeiten und unterstützt auch "Herbst" als Synonym für "Herbst".
• Ich denke, es gibt einige Verbesserungsmöglichkeiten, aber meine derzeitigen Golfscript-Kenntnisse sind bislang begrenzt.

Hier sind die Tests, jeweils 2 Durchgänge, um die Zufälligkeit zu bestätigen

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

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 mit entferntem Whitespace (das sind 436 Zeichen):

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 Zeichen

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

Ungolfed

<?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: Zeilenumbruch
304 -> 288: Verwendet JSON-Arrays anstelle von PHP-Arrays

C # 350 Zeichen

Es muss einen effizienteren Weg geben. Aber hier ist, was ich bisher habe:

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

Oder in einem besser lesbaren Format mit ein paar Kommentaren:

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 Zeichen

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

Ich dachte, ich würde meine eigene PHP-Lösung schreiben, nachdem die aktuelle nicht einmal die Herausforderungsbedingungen vollständig erfüllt.

Es basiert auf strtotime, um den Tag zu analysieren, und auf dem Datum, um ihn wiederzugeben. Um die Jahreszeit zu bestimmen, folgt sie dem dritten Buchstaben des Jahreszeitnamens, der eindeutig ist (wie angegeben).

Für eine ordnungsgemäße Ausführung müssen Benachrichtigungen deaktiviert und kurze Tags aktiviert sein.

Javascript - 251 Zeichen

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

Leider erfüllt das Skript nicht die Anforderungen für stdin / stdout, akzeptiert jedoch Fall als Synonym für Autumn.

Leerzeichen:

  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]

Verwendung

g["Winter", "Sunday"]

Python 2, 220 Zeichen

Ein bisschen groß, aber (fast) lesbar.

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)

Ausgabe

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