Il giorno più lungo dell'anno - ecco qualcosa da perdere il tempo extra ...

Panoramica

Nota che questo non è un concorso di popolarità e non una sfida di output grafico: devi solo generare una stringa di 65.536 zero e uno. Lo snippet di stack nella parte inferiore della domanda visualizzerà questo come un'immagine in bianco e nero 256 per 256 e calcolerà il tuo punteggio ufficiale. È quindi possibile salvare l'immagine e caricarla nella risposta insieme al codice (poiché l'output della stringa non si adatta a una risposta Stack Exchange di 30.000 caratteri).

punteggio

Il punteggio di un'immagine è la somma dei punteggi dei suoi singoli pixel. Il punteggio di un singolo pixel è la somma dei punteggi parziali per ciascuna delle non ortogonali , distanza primi pixel che sono di colore opposto al pixel in azione. Il carattere di sottolineatura per ciascuno di questi pixel è 1/pdove si ptrova la distanza principale.

Nel contesto di questa domanda, i termini hanno le seguenti definizioni:

• Non ortogonale: un pixel non è ortogonale al pixel oggetto del punteggio se non è nella stessa riga e non è nella stessa colonna.

• Distanza principale: un pixel si trova a una distanza primaria dal pixel che viene segnato se sono separati da una distanza euclidea che è esattamente un numero primo. In particolare, la distanza è la distanza minima misurata toroidalmente - il pixel in alto a sinistra è una distanzasqrt(2)dal pixel in basso a destra (tutti i 4 bordi si avvolgono).

• Colore opposto: un pixel ha un colore opposto al pixel da assegnare se i loro valori sono pari a 1. Cioè, il primo è 0 e il secondo è 1, oppure il primo è 1 e il secondo è 0.

Lo snippet di stack include un codice di esempio che mostra come assegnare un punteggio a un'immagine, ma non include alcuna ottimizzazione o un approccio efficiente, ma solo un codice corretto in modo che il punteggio delle immagini finali possa essere eseguito in modo coerente.

Se qualcosa nel codice non è corretto, per favore fatemi sapere nei commenti o nella chat .

JavaScript potrebbe non essere necessariamente la lingua migliore per rispondere a questa particolare sfida. Nota che il codice dello snippet non fornisce deliberatamente indizi su approcci più rapidi. Verranno introdotte solo efficienze che sono già state dimostrate in una risposta esistente.

visualizzazione

I pixel di punteggio

Per un'idea intuitiva della distribuzione dei pixel di punteggio, qui (in viola) sono riportati i pixel di distanza primi non ortogonali per pixel (128, 128) di un'immagine 256 per 256:

Un'immagine casuale

Questa è l'immagine generata casualmente dalla risposta di esempio Python 3. Ha un punteggio di 138.267,64 e ti dà qualcosa da battere.

Ingresso

Il codice non richiede input.

Produzione

Il codice dovrebbe generare una stringa di 65.536 zero e uno, che rappresentano i pixel di un'immagine in bianco e nero 256 per 256. Le cifre dovrebbero essere una stringa continua, senza separatori. Potresti trovare più facile copiare e incollare se esegui l'output in un file, ma dipende da te.

Il codice può anche generare altre informazioni che ritieni utili, a condizione che la stringa possa essere copiata e incollata nello snippet dello stack. Ad esempio, potresti voler inviare la stringa migliore ma ancora in un file e il punteggio migliore ancora a STDOUT a intervalli regolari, consentendo all'utente di scegliere quando interrompere la ricerca.

Stack Snippet

Come sottolineato da Sp3000 , lo snippet impiegava 10 minuti per calcolare un punteggio, che è un po ' troppo lento, anche per un'implementazione di riferimento deliberatamente inefficiente. Ho modificato il miglioramento suggerito da Sp3000 di pre-calcolare gli offset dei pixel per il punteggio e ora ci vogliono alcuni secondi per calcolare un punteggio.

canvas = document.getElementById('canvas')
ctx = canvas.getContext('2d')
scoreArea = document.getElementById('scoreArea')
pastedData = document.getElementById('pastedData')
timeout = 0

primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

primesSquared = []
for (i=0; i<primes.length; i++) {
    primesSquared.push(primes[i] * primes[i])
}

width = canvas.width
height = canvas.height
area = width * height

scoringFilter = calculateScoringFilter()

function calculateScore() {
    var percentage = Math.floor(currentIndex / 65536 * 10000) / 100
    scoreArea.value = 'Calculating:' + percentage + '%'
    for (var t=0; t<1000; t++) {
        if (currentIndex < 65536) {
            partialScore += pixelScore(currentIndex)
            currentIndex += 1
        } else {
            scoreArea.value = 'Score: ' + partialScore
            return
        }
    }
    
    timeout = setTimeout(calculateScore, 10)
}

function pixelScore(i) {
    var score = 0
    var x = i % width
    var y = Math.floor(i / width)
    var a, b, xd, yd, j, k, d, m
    for (k=0; k<scoringFilter.length; k++) {
        bundle = scoringFilter[k]
        m = bundle[0]
        a = m % width
        b = Math.floor(m / width)
        j = ((x+a) % width) + width * ((y+b) % height)
        d = bundle[1]
        score += Math.abs(pixels[i] - pixels[j]) / d
    }
    return score
}

function display(pixels) {
    for (var i=0; i<area; i++) {
        ctx.fillStyle = pixels[i] ? 'white' : 'black'
        ctx.fillRect(i % width, Math.floor(i / width), 1, 1)
    }
}

function stop() {
    clearTimeout(timeout)
    scoreArea.value = 'Calculation cancelled.'
}

function isPrimeSquared(n) {
    return primesSquared.indexOf(n) > -1
}

function applyToImage() {
    var potentialPixels = []
    var pastedString = pastedData.value
    if (pastedString.length !== 65536) {
        scoreArea.value = 'Incorrect length:' + pastedString.length
        return
    }
    var i, digit
    for (i=0; i<pastedString.length; i++) {
        digit = pastedString.substring(i, i + 1)
        if (digit === '0') {
            potentialPixels.push(0)
        } else if (digit === '1') {
            potentialPixels.push(1)
        } else {
            scoreArea.value = 'Invalid character ' + i + ':' + digit
            return
        }
    }
    pixels = potentialPixels
    display(pixels)
    scoreArea.value = 'Calculating score...'
    partialScore = 0
    currentIndex = 0
    
    timeout = setTimeout(calculateScore, 10)
}

function calculateScoringFilter() {
    var scoringFilter = []
    var i, x, y, xd, yd
    for (i=0; i<area; i++) {
        x = i % width
        y = Math.floor(i / width)
        xd = Math.min(x,(-x+width)%width)
        yd = Math.min(y,(-y+height)%height)
        dSquared = xd*xd + yd*yd
        if (xd && yd && isPrimeSquared(dSquared)) {
            d = Math.sqrt(dSquared)
            scoringFilter.push([i, d])
        }
    }
    return scoringFilter
}

<canvas id='canvas' width='256' height='256'></canvas>
<br>
<input id='scoreArea' rows='1' readonly></input>
<br>
<button onclick='applyToImage()'>Apply string to image</button>
<button onclick='stop()'>Stop</button>
<br>
<br>
Paste in string of 65,536 zeroes and ones here:
<br>
<input id='pastedData'></input>

Se usi l'output o il codice di un'altra risposta come punto di partenza per il tuo codice, ricorda di dare credito e di collegarti alla risposta di supporto. Le risposte a questa domanda non devono accreditare la risposta di esempio o il codice nella domanda.

Ringraziamo Randall Munroe per il termine Nerd Sniping

CJam, punteggio 276496.9062958626

2,128*_(]128*

Risulta essere ottimale, perché: Non ci sono coppie non ortogonali con distanza 2. Quindi la distanza deve essere dispari, così come la distanza al quadrato. Dato che p ² = x ² + y ² , uno di xey (al quadrato o no) deve essere dispari e l'altro deve essere pari. Questi punti hanno sempre il colore opposto in questa immagine.

Questo e il suo negativo sono anche le uniche soluzioni ottimali. In una soluzione ottimale, nessun pixel non ortogonale a prima distanza dovrebbe avere lo stesso colore. Vi sono pixel opposti adiacenti diagonalmente come (3,4) e (4,3). Riempiendo i pixel dell'opposto del colore opposto, ecc., Possiamo ottenere una diagonale con lo stesso colore. A partire da ciascun pixel nella diagonale, possiamo riempire tutte le anti-diagonali nello stesso modo. Si noti che si avvolgono. Tuttavia, è comunque ottimale.

Python 3, punteggio 138267,64

Questa è una risposta minima come esempio di ciò che è richiesto e come qualcosa da battere ...

Include

• Il nome della lingua.
• Il punteggio dello snippet di stack nella domanda.
• L'immagine salvata dallo snippet di stack.
• Il codice utilizzato per produrre la stringa di 65.536 zero e uno.

Produzione

Codice

from random import random

output_string = ''
filename = '65536digits.txt'

for t in range(65536):
    digit = int(random() * 2)
    output_string += str(digit)

with open(filename, 'w') as output_file:
    output_file.write(output_string)

Questo è solo un esempio. Python potrebbe non essere necessariamente il miglior linguaggio per le risposte competitive a questa particolare sfida.