Dia mais longo do ano - aqui está algo para desperdiçar o tempo extra ...

Visão geral

Observe que este não é um concurso de popularidade nem um desafio gráfico de saída - você só precisa gerar uma sequência de 65.536 zeros e uns. O snippet de pilha na parte inferior da pergunta exibirá isso como uma imagem em preto e branco de 256 por 256 e calculará sua pontuação oficial. Em seguida, você pode salvar a imagem e enviá-la para sua resposta juntamente com o seu código (já que a saída da string não caberá em uma resposta de 30.000 caracteres do Exchange Stack).

Pontuação

A pontuação de uma imagem é a soma das pontuações de seus pixels individuais. A pontuação de um pixel individual é a soma dos subescores de cada um dos pixels de distância principal não ortogonais , que são de cores opostas ao pixel que está sendo pontuado. A sub-pontuação de cada pixel é onde está a distância principal.1/pp

No contexto desta pergunta, os termos têm as seguintes definições:

• Não ortogonal: um pixel não é ortogonal ao pixel que está sendo pontuado, se não estiver na mesma linha e não estiver na mesma coluna.

• Distância principal: um pixel está a uma distância principal do pixel que está sendo pontuado se for separado por uma distância euclidiana que seja exatamente um número primo. Em particular, a distância é a distância mínima medida toroidalmente - o pixel superior esquerdo está a uma distância dosqrt(2)pixel inferior direito (todas as quatro arestas são quebradas).

• Cor oposta: um pixel é de cor oposta ao pixel que está sendo pontuado se seus valores somarem 1. Ou seja, o primeiro é 0 e o segundo é 1, ou o primeiro é 1 e o segundo é 0.

O Snippet de pilha inclui código de exemplo que mostra como classificar uma imagem, mas não inclui otimizações ou uma abordagem eficiente, apenas o código correto para que a pontuação das imagens finais possa ser feita de maneira consistente.

Se alguma coisa no código não estiver correta, informe-me nos comentários ou no chat .

O JavaScript pode não ser necessariamente o melhor idioma para responder a esse desafio específico. Observe que o código do snippet não fornece deliberadamente pistas sobre abordagens mais rápidas. Somente serão introduzidas eficiências que já foram demonstradas em uma resposta existente.

Visualização

Os pixels de pontuação

Para uma sensação intuitiva da distribuição dos pixels de pontuação, aqui (em roxo) estão os pixels de distância principal não ortogonais do pixel (128, 128) de uma imagem de 256 por 256:

Uma imagem aleatória

Esta é a imagem gerada aleatoriamente a partir da resposta de exemplo do Python 3. Tem uma pontuação de 138.267,64 e oferece a você algo para vencer.

Entrada

O código não requer entrada.

Resultado

O código deve gerar uma sequência de 65.536 zeros e uns, representando os pixels de uma imagem em preto e branco de 256 por 256. Os dígitos devem ser uma sequência contínua, sem separadores. Pode ser mais fácil copiar e colar se você imprimir em um arquivo, mas isso depende de você.

Seu código também pode gerar outras informações que você achar úteis, desde que a sequência possa ser copiada e colada no Snippet de Pilha. Por exemplo, você pode enviar a melhor sequência de caracteres para um arquivo e a melhor pontuação para STDOUT em intervalos regulares, permitindo que o usuário escolha quando parar a pesquisa.

Snippet de pilha

Como fora apontado por SP3000 , o trecho estava levando 10 minutos para calcular a pontuação, que é um pouco demasiado lento, mesmo para uma implementação de referência deliberadamente ineficiente. Editei na melhoria sugerida pelo Sp3000 de pré-calcular as compensações de pixel para a pontuação e agora leva alguns segundos para calcular uma pontuação.

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 você usar a saída ou o código de outra resposta como ponto de partida para o seu próprio código, lembre-se de dar crédito e vincular à resposta de suporte. As respostas a esta pergunta não precisam creditar a resposta de exemplo ou o código na pergunta.

Agradecemos a Randall Munroe pelo termo Nerd Sniping

CJam, pontuação 276496.9062958626

2,128*_(]128*

Ele é ideal, porque: Não há pares não ortogonais com a distância 2. Portanto, a distância deve ser ímpar e a distância ao quadrado. Como p ² = x ² + y ² , um de x e y (quadrado ou não) deve ser ímpar e o outro deve ser par. Esses pontos estão sempre na cor oposta nesta imagem.

Essa e sua negativa também são as únicas soluções ótimas. Em uma solução ideal, nenhum pixel de distância primária não ortogonal deve ter a mesma cor. Existem pixels opostos adjacentes na diagonal, como (3,4) e (4,3). Ao preencher pixels do oposto da cor oposta, etc., podemos obter uma diagonal com a mesma cor. A partir de cada pixel na diagonal, podemos obter todos os anti-diagonais preenchidos da mesma maneira. Observe que eles envolvem. Ainda é ótimo se não o fizerem.

Python 3, pontuação 138267.64

Esta é uma resposta mínima como um exemplo do que é necessário e como algo a ser vencido ...

Inclui

• O nome do idioma
• A pontuação do snippet de pilha na pergunta.
• A imagem salva no snippet de pilha.
• O código usado para produzir a sequência de 65.536 zeros e uns.

Resultado

Código

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)

Este é apenas um exemplo. O Python pode não ser necessariamente a melhor linguagem para respostas competitivas para esse desafio em particular.