Il nuovo supercomputer per la previsione del tempo è arrivato e non funziona.

Nel frattempo il tuo capo vuole che tu acquisti i tecnici un po 'di tempo falsificando le mappe del vento quotidiane.

Il tuo compito è disegnare una griglia di frecce che rappresentano la direzione del vento.

La griglia è:

• composto da piastrelle quadrate 15px
• 8 tessere da 8 tessere
• Totale quadrato di 120px

• 000 sfondo

Ogni riquadro della griglia ha 8 potenziali orientamenti, che rappresentano la direzione del vento:

1. Nord
2. nord-est
3. est
4. sud-est
5. Sud
6. sud-ovest
7. ovest
8. Nord Ovest

Che deve essere rappresentato come segue:

N NE E SE S SW W NW

Le mappe devono variare gradualmente , per essere credibili.

Ciò significa che ogni tessera può differire dal suo vicino solo di un passo. In particolare:

• Una tessera può differire di un solo incremento o decremento da ciascuna delle 4 tessere adiacenti. (o 3 per i pannelli laterali, 2 per i pannelli angolari).
• ad esempio una tessera con il vicino E potrebbe essere NE, E o SE (supponendo che sia in accordo con gli altri vicini).
• Gli orientamenti possono tornare indietro, ovvero N -> NW e NW -> N.

Per illustrare, è valida la seguente mappa:

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 

Le mappe devono essere uniche , non generare la stessa mappa per input diversi.

• L'input è un numero intero corrispondente ai giorni tra oggi e la tua previsione (ad esempio 1 è la previsione di domani, 365 è un anno).
• L'output è la mappa come immagine.
• L'output dovrebbe essere riproducibile, lo stesso input fornirà sempre lo stesso output
• Devi fornire mappe univoche per almeno 8 anni, ovvero nessun output identico per qualsiasi input tra 1 e 2920 (sto ignorando gli anni bisestili).
• Non esiste un output definito per alcun input maggiore di 2920.

L'invio vincente produrrà mappe valide (fino al giorno 2920) con il minor numero di byte di codice sorgente.

BBC Basic, 83 caratteri ASCII, dimensione file tokenizzata 72

Scarica l'emulatore da 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

Questo è fondamentalmente un punto di riferimento del concetto di Martin, ma l'implementazione in BBC Basic è molto diversa. Riprogrammo il carattere per i numeri 0e 1quindi stampo le cifre binarie din in ordine inverso.

Il codice non registrato è sotto. In BBC Basic puoi stampare singoli caratteri ASCII usando il VDUcomando, ma la lingua ha una serie di codici specifici per la macchina simili alle sequenze di escape ma che iniziano con caratteri non stampabili. Per riprogrammare il carattere, iniziamo con ASCII 23. Normalmente vengono presi valori a 8 bit, ma se si usa un punto e virgola come separatore invece di una virgola, si impiegano piccoli valori endian a 16 bit (come usato nella versione golfata).

  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.

Produzione

Per i numeri da 0 a 7. Notare che il carattere non viene resettato alla fine del programma, quindi i numeri 0 e 1 appaiono come frecce nei primi due esempi.

Matlab (182 *)

Si presume che l'ingresso sia archiviato n. Quando guardo l'algoritmo, non sono sicuro che i risultati saranno unici, ma ho verificato n=1 upto 3000che sono unici e soddisfano le regole. Fondamentalmente uso solo numeri complessi del cerchio unitario e li "ammorbido" conv2 con un filtro gaussiano. Successivamente vengono "arrotondati" alle 8 direzioni possibili.

* Non so come ridimensionare l'output su un determinato numero di pixel, quindi deve essere fatto manualmente = /

EDIT: ho appena scoperto che ci sono casi in cui il mio programma di controllo non ha riconosciuto soluzioni sbagliate (modifiche di più di 1 passaggio), ma sto cercando di trovare un'altra soluzione.

Ingresso:

n = 1

Codice:

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 byte

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]

Suppongo che un buon cavallo non salti mai più in alto di quanto deve. 2920 diverse griglie si ottengono molto facilmente usando solo due direzioni (sto usando Ne NE), il che rende banale soddisfare la regola della continuità. Sto semplicemente scegliendo tra N e NE in base ai bit di n, quindi questo produrrà effettivamente 2 ⁶⁴ diverse mappe del vento.

Ecco le prime dieci mappe:

PS: La mia idea originale era quella di enumerare tutte le 8 ⁴ combinazioni per i 4 angoli e di "linearmente" interpolazione il resto della griglia. Ciò avrebbe probabilmente portato a mappe più belle, ma dopotutto si tratta di codice golf, quindi sono andato con quello che soddisfa i requisiti minimi.

PHP 5.4, 549 byte

Un po 'ostacolato dalla necessità di definire le frecce come grafica, ecco il mio codice 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);

Prende il suo argomento dalla riga di comando, come ad esempio:

php windmap.php 123

Questa soluzione utilizzerà l'input come definizione dei quattro angoli. Il resto della mappa verrà interpolato uniformemente tra i valori. Ha definito risultati per tutti i valori compresi tra 0 e 4095, un totale complessivo di ~ 11,25 anni di previsioni false, che dovrebbe essere più che sufficiente per riparare il software meteorologico!

Ecco una GIF di tutti i risultati:

E un ZIP contenente ogni mappa può essere scaricato qui

^{(Piccola nota: il mio dominio è scaduto di recente perché non stavo prestando attenzione. L'ho rinnovato, ma l'immagine e il link sopra potrebbero non funzionare fino agli aggiornamenti DNS)}

Unsquishified:

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