Der neue Supercomputer mit Wettervorhersage ist da und funktioniert nicht.

In der Zwischenzeit möchte Ihr Chef, dass Sie den Technikern etwas Zeit verschaffen, indem Sie die täglichen Windkarten fälschen.

Ihre Aufgabe ist es, ein Pfeilgitter zu zeichnen, das die Windrichtung darstellt.

Das Raster ist:

• Bestehend aus 15px quadratischen Kacheln
• 8 Fliesen von 8 Fliesen
• Insgesamt 120 Pixel pro Quadrat

• 000 Hintergrund

Jedes Gitter hat 8 mögliche Ausrichtungen, die die Windrichtung darstellen:

1. Norden
2. Nordost
3. Osten
4. Süd-Ost
5. Süd
6. Südwesten
7. Westen
8. Nordwest

Was muss wie folgt dargestellt werden:

N NE E SE S SW W NW

Die Karten müssen allmählich variieren , um glaubwürdig zu sein.

Das heißt, jedes Plättchen darf sich nur um einen Schritt vom Nachbarn unterscheiden. Speziell:

• Ein Plättchen kann sich nur um ein Inkrement oder Dekrement von jedem der 4 benachbarten Plättchen unterscheiden. (oder 3 für Seitenfliesen, 2 für Eckfliesen).
• ZB könnte ein Plättchen mit dem Nachbarn E NE, E oder SE sein (vorausgesetzt, es stimmt mit seinen anderen Nachbarn überein).
• Orientierungen können zurücklaufen, dh N -> NW und NW -> N.

Zur Veranschaulichung ist die folgende Karte gültig:

NW  N NE NE NE NE NE NE 
 N NE NE NE NE NE NE  E 
NE NE NE NE NE NE  E SE 
 E NE NE NE NE  E SE  S 
SE  E  E  E  E SE  S SE 
 S SE SE SE SE  S SE  E 
SW  S  S  S  S SE  E NE 
SW SW  S  S SE  E NE  N 

Maps müssen eindeutig sein . Generieren Sie nicht dieselbe Map für verschiedene Eingaben.

• Die Eingabe ist eine Ganzzahl, die den Tagen zwischen jetzt und Ihrer Prognose entspricht (z. B. 1 ist die Prognose von morgen, 365 ist die Jahreszeit).
• Ausgabe ist die Karte als Bild.
• Die Ausgabe sollte reproduzierbar sein. Dieselbe Eingabe ergibt immer dieselbe Ausgabe
• Sie müssen eindeutige Zuordnungen für mindestens 8 Jahre angeben - dh für Eingaben zwischen 1 und 2920 ist keine identische Ausgabe möglich (Schaltjahre werden ignoriert).
• Es gibt keine definierte Ausgabe für Eingaben, die größer als 2920 sind.

Die Gewinner-Einsendung wird gültige Maps (bis Tag 2920) mit den wenigsten Bytes Quellcode erstellen.

BBC Basic, 83 ASCII-Zeichen, tokenisierte Dateigröße 72

Laden Sie den Emulator unter http://www.bbcbasic.co.uk/bbcwin/bbcwin.html herunter

  INPUTn:VDU23,48,516;543;4;0;23,49,783;5,9;0;0:WIDTH8FORi=1TO64PRINT;1ANDn;:n/=2NEXT

Dies ist im Grunde eine Portierung von Martins Konzept, aber die Implementierung in BBC basic ist sehr unterschiedlich. Ich programmiere die Schriftart für die Zahlen um 0und 1gebe dann die Binärziffern nin umgekehrter Reihenfolge aus.

Ungolfed Code ist unten. In BBC Basic können Sie einzelne ASCII-Zeichen mit dem VDUBefehl drucken. Die Sprache verfügt jedoch über eine Reihe maschinenspezifischer Codes, die den Escape-Sequenzen ähneln, jedoch mit nicht druckbaren Zeichen beginnen. Für die Neuprogrammierung der Schriftart beginnen wir mit ASCII 23. Normalerweise werden 8-Bit-Werte verwendet. Wenn Sie jedoch ein Semikolon als Trennzeichen anstelle eines Kommas verwenden, werden 16-Bit-Little-Endian-Werte benötigt (wie in der Golf-Version verwendet).

  INPUTn
  VDU23,48,4,2,31,2,4,0,0,0         :REM redefine font for "0" as an east facing arrow, with an 8x8 bitmap
  VDU23,49,15,3,5,9,0,0,0,0         :REM redefine font for "1" as a northeast facing arrow, with an 8x8 bitmap
  WIDTH8                            :REM set print width to 8 characters
  FORi=1TO64PRINT;1ANDn;:n/=2:NEXT  :REM print the binary digits of n in reverse order from least significant to most significant.

Ausgabe

Für die Nummern 0 bis 7. Beachten Sie, dass die Schriftart am Ende des Programms nicht zurückgesetzt wird. Daher erscheinen die Nummern 0 und 1 in den ersten beiden Beispielen als Pfeile.

Matlab (182 *)

Es wird angenommen, dass die Eingabe in gespeichert ist n. Beim Betrachten des Algorithmus ist nicht sicher, ob die Ergebnisse eindeutig sind, aber ich habe überprüft, n=1 upto 3000ob sie eindeutig sind und den Regeln entsprechen. Ich benutze im Grunde genommen nur komplexe Zahlen des Einheitskreises und 'glätt' sie durch conv2 mit einem Gauß-Filter. Danach werden sie in die 8 möglichen Richtungen "gerundet".

* Ich weiß nicht, wie ich die Ausgabe auf eine bestimmte Anzahl von Pixeln skalieren soll, das muss also manuell gemacht werden = /

BEARBEITEN: Ich habe gerade festgestellt, dass mein Überprüfungsprogramm in einigen Fällen falsche Lösungen nicht erkannt hat (Änderungen um mehr als einen Schritt), aber ich versuche, eine andere Lösung zu finden.

Eingang:

n = 1

Code:

rand('seed',0);
for x=1:n
    b = exp(1i*rand(8)*2*pi);
end
for k=1:12
    b = conv2(b,[1,2,1]'*[1,2,1],'same');b=b./abs(b);
end
c = exp(1i*round(angle(b)*4/pi)*pi/4)/3;
quiver(real(c),imag(c));

Mathematica, 116 115 Bytes

f@n_:=Graphics[Array[(d=n~BitGet~#;Arrow@{1+{w=15#~Mod~8+6.5d,h=15Floor[#/8]},14+{w-13d,h}})&,64,0],ImageSize->120]

Ich nehme an, ein gutes Pferd springt nie höher als es muss. 2920 verschiedene Gitter werden sehr einfach mit nur zwei Richtungen (ich benutze Nund NE) erreicht, was das Erfüllen der Kontinuitätsregel trivial macht. Ich wähle einfach zwischen N und NE basierend auf den Bits von n, so dass tatsächlich 2 ⁶⁴ verschiedene Windkarten erzeugt werden.

Hier sind die ersten zehn Karten:

PS: Meine ursprüngliche Idee war es, alle 8 ⁴ Kombinationen für die 4 Ecken aufzulisten und den Rest des Gitters "linear" zu interpolieren. Das hätte wahrscheinlich zu schöneren Karten geführt, aber das ist doch Codegolf, also habe ich mich für das entschieden, was die Mindestanforderungen erfüllt.

PHP 5.4, 549 Bytes

Etwas behindert durch die Notwendigkeit, Pfeile als Grafiken zu definieren, ist hier mein PHP-Code:

<? $i=$argv[1];$p="R0lGODdhBQAFAIAAAP///wAAACwAAAAABQAFAAAC";$a=[$p."BwRiicGsDwoAOw",$p."CEQeoLfmlhQoADs",$p."CARiF8hnmGABADs",$p."CIwDBouYvGIoADs",$p."BwRil8Gs+QoAOw",$p."CIQRYcqrnkABADs",$p."CARihscYn1YBADs",$p."CAx+Bmq6HWIBADs"];$c=[$i&7,$i>>3&7,$i>>6&7,$i>>9];$m=imagecreate(120,120);imagecolorallocate($m,255,255,255);foreach($a as$_)$z[]=imagecreatefromstring(base64_decode($_));for($y=0;$y<8;$y++)for($x=0;$x<8;$x++)imagecopy($m,$z[($c[0]*(7-$x)*(7-$y)+$c[1]*$x*(7-$y)+$c[2]*(7-$x)*$y+$c[3]*$x*$y)/49%8],$x*15+5,$y*15+5,0,0,5,5);imagepng($m);

Übernimmt sein Argument von der Kommandozeile, wie zum Beispiel:

php windmap.php 123

Diese Lösung verwendet die Eingabe als Definition der vier Ecken. Der Rest der Karte wird reibungslos zwischen den Werten interpoliert. Es wurden Ergebnisse für alle Werte von 0 bis 4095 definiert, eine Gesamtsumme von ~ 11,25 Jahren gefälschter Vorhersage, was mehr als genug Zeit sein sollte, um die Wettersoftware zu reparieren!

Hier ist eine GIF aller Ergebnisse:

Eine ZIP-Datei mit jeder Karte kann hier heruntergeladen werden

^{(Kleiner Hinweis: Meine Domain ist kürzlich abgelaufen, weil ich nicht darauf geachtet habe. Ich habe sie erneuert, aber das obige Bild und der obige Link funktionieren möglicherweise nicht, bis die DNS-Updates durchgeführt wurden.)}

Unquishified:

<?php
$input = $argv[1];
$prefix = "R0lGODdhBQAFAIAAAP///wAAACwAAAAABQAFAAAC";
$arrows = [
    $prefix."BwRiicGsDwoAOw", // E
    $prefix."CEQeoLfmlhQoADs", // NE
    $prefix."CARiF8hnmGABADs", // N
    $prefix."CIwDBouYvGIoADs", // NW
    $prefix."BwRil8Gs+QoAOw", // W
    $prefix."CIQRYcqrnkABADs", // SW
    $prefix."CARihscYn1YBADs", // S
    $prefix."CAx+Bmq6HWIBADs", // SE
];
$points = [
    $input & 7,
    $input >> 3 & 7,
    $input >> 6 & 7,
    $input >> 9 // input beyond 0o7777 (4095) will be undefined due to lack of & 7 here
];
$img = imagecreate(120,120);
imagecolorallocate($img,255,255,255);
$arrowimgs = [];
foreach($arrows as $src) {
    $arrowimgs[] = imagecreatefromstring(base64_decode($src));
}
for($y=0; $y<8; $y++) {
    for($x=0; $x<8; $x++) {
        $point = (
              $points[0] * (7-$x)/7 * (7-$y)/7
            + $points[1] *   $x  /7 * (7-$y)/7
            + $points[2] * (7-$x)/7 *   $y  /7
            + $points[3] *   $x  /7 *   $y  /7
        ) % 8;
        imagecopy($img,$arrowimgs[$point],$x*15+5,$y*15+5,0,0,5,5);
    }
}
imagepng($img,"out.png");