Le nouveau supercalculateur de prévisions météorologiques est arrivé et ne fonctionne pas.

En attendant, votre patron veut que vous achetiez du temps aux techniciens en simulant les cartes de vent quotidiennes.

Votre tâche consiste à dessiner une grille de flèches représentant la direction du vent.

La grille est:

• composé de carreaux carrés 15px
• 8 tuiles par 8 tuiles
• 120px carré total

• 000 arrière-plan

Chaque tuile de grille a 8 orientations potentielles, représentant la direction du vent:

1. Nord
2. Nord-est
3. est
4. Sud-est
5. Sud
6. Sud-ouest
7. Ouest
8. Nord Ouest

Ce qui doit être décrit comme suit:

N NE E SE S SW W NW

Les cartes doivent varier progressivement pour être crédibles.

Cela signifie que chaque tuile ne peut différer de son voisin que d'une étape. Plus précisément:

• Une tuile ne peut différer que d'un incrément ou d'une décrémentation de chacune des 4 tuiles adjacentes. (ou 3 pour les carreaux latéraux, 2 pour les carreaux d'angle).
• Par exemple, une tuile avec le voisin E pourrait être NE, E ou SE (en supposant qu'elle s'accorde avec ses autres voisins).
• Les orientations peuvent rebondir, c'est-à-dire N -> NW et NW -> N.

Pour illustrer, la carte suivante est valide:

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 

Les cartes doivent être uniques , ne générez pas la même carte pour différentes entrées.

• L'entrée est un entier correspondant aux jours entre maintenant et vos prévisions (par exemple 1 est la prévision de demain, 365 est le temps d'un an).
• La sortie est la carte sous forme d'image.
• La sortie doit être reproductible, la même entrée donnera toujours la même sortie
• Vous devez donner des cartes uniques pendant au moins 8 ans - c'est-à-dire aucune sortie identique pour toute entrée entre 1 et 2920 (j'ignore les années bissextiles).
• Il n'y a pas de sortie définie pour une entrée supérieure à 2920.

La soumission gagnante produira des cartes valides (jusqu'au jour 2920) avec le moins d'octets de code source.

BBC Basic, 83 caractères ASCII, taille de fichier à jetons 72

Téléchargez l'émulateur sur http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

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

Il s'agit essentiellement d'un portage du concept de Martin, mais la mise en œuvre dans BBC basic est très différente. Je reprogramme la police pour les nombres 0, 1puis affiche les chiffres binaires de ndans l'ordre inverse.

Le code non golfé est ci-dessous. Dans BBC basic, vous pouvez imprimer des caractères ASCII individuels à l'aide de la VDUcommande, mais le langage possède une série de codes spécifiques à la machine similaires aux séquences d'échappement mais commençant par des caractères non imprimables. Pour reprogrammer la police, nous commençons par ASCII 23. Normalement, des valeurs de 8 bits sont prises, mais si vous utilisez un point-virgule comme séparateur au lieu d'une virgule, cela prend des valeurs endian de 16 bits (comme dans la version golfée).

  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.

Production

Pour les nombres 0 à 7. Notez que la police n'est pas réinitialisée à la fin du programme, donc les chiffres 0 et 1 apparaissent sous forme de flèches dans les deux premiers exemples.

Matlab (182 *)

On suppose que l'entrée est stockée dans n. Quand on regarde l'algorithme, il n'est pas sûr que les résultats soient uniques, mais j'ai vérifié n=1 upto 3000qu'ils sont uniques et satisfont aux règles. J'utilise simplement des nombres complexes du cercle unitaire et je les "adoucit" par conv2 avec un filtre gaussien. Après cela, ils sont «arrondis» dans les 8 directions possibles.

* Je ne sais pas comment redimensionner la sortie à un certain nombre de pixels, donc cela doit être fait manuellement = /

EDIT: Je viens de découvrir qu'il y a des cas où mon programme de vérification n'a pas reconnu les mauvaises solutions (changements de plus d'une étape), mais j'essaie de trouver une autre solution.

Contribution:

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 octets

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]

Je suppose qu'un bon cheval ne saute jamais plus haut qu'il ne doit. 2920 grilles différentes sont très facilement réalisables en utilisant seulement deux directions (j'utilise NetNE ), ce qui rend la règle de continuité triviale. Je choisis simplement entre N et NE en fonction des bits de n, donc cela produira réellement 2 ⁶⁴ cartes de vent différentes.

Voici les dix premières cartes:

PS: Mon idée originale était d'énumérer les 8 ⁴ combinaisons pour les 4 coins et d'interpoler "linéairement" le reste de la grille. Cela aurait probablement abouti à des cartes plus belles, mais c'est du golf de code après tout, alors je suis allé avec ce qui remplit les exigences minimales.

PHP 5.4, 549 octets

Un peu gêné par la nécessité de définir des flèches comme graphiques, voici mon code PHP:

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

Prend son argument à partir de la ligne de commande, tel que:

php windmap.php 123

Cette solution utilisera l'entrée comme définition des quatre coins. Le reste de la carte sera interpolé en douceur entre les valeurs. Il a défini des résultats pour toutes les valeurs de 0 à 4095, un grand total de ~ 11,25 ans de prévisions fausses, ce qui devrait être plus que suffisant pour réparer le logiciel météo!

Voici un GIF de tous les résultats:

Et un ZIP contenant chaque carte peut être téléchargé ici

^{(Petite remarque: mon domaine a récemment expiré parce que je n'y prêtais pas attention. Je l'ai renouvelé, mais l'image et le lien ci-dessus peuvent ne pas fonctionner jusqu'à ce que les mises à jour DNS)}

Non certifié:

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