Introdução

Um quixel é um pixel quântico. Semelhante a um pixel clássico, é representado com 3 valores inteiros (vermelho, verde, azul). No entanto, os quixels estão em uma super posição desses 3 estados, em vez de uma combinação. Essa super posição dura apenas até que o quixel seja observado, no ponto em que cai para um dos três pixels clássicos; RGB(255,0,0), RGB(0,255,0)E RGB(0,0,255).

Especificação

• Representação
  • Cada quixel é representado como uma matriz de 3 números inteiros entre 0 e 255 r, ge brespectivamente.
• Super Posições
  • Cada Quixel está em uma posição de super entre o vermelho, azul e verde estados representados por R, Ge Brespectivamente.
• Observação
  • Quando cada quixel é observado, ele entra em colapso em um dos três estados. A probabilidade de cada estado clássico é R = (r + 1) / (r + g + b +3), G = (g + 1) / (r + g + b + 3) e B = (b + 1) / (r + g + b + 3). Dessa forma, cada estado clássico sempre tem uma probabilidade diferente de zero de aparecer.
• Entrada
  • A função ou programa deve ter uma imagem de quixels. Como isso é flexível. Um nome de arquivo, usando uma matriz multidimensional, etc, são aceitáveis.
• Saída
  • A função ou programa deve produzir uma imagem de pixels clássicos. A estrutura de dados para esta imagem produzida também é flexível. Note-se que todos os pixels deve ser um destes três: RGB(255,0,0), RGB(0,255,0)eRGB(0,0,255)
  • A saída não deve ser determinística ; estes são pixels quânticos ! A mesma entrada deve resultar em saídas diferentes.
  • Se seu idioma não tem como gerar um número aleatório, você pode usar bytes aleatórios como entrada
• Pontuação
  • Este é o código-golfe, pois o menor número de bytes vence.

Imagens

Mona Lisa por Leonardo da Vinci

Noite estrelada por Vincent van Gogh

Persistência da Memória por Salvador Dali

Teddy Roosevelt VS. Bigfoot por SharpWriter

Dyalog APL , 23 21 19 bytes

Toma a tabela de trigêmeos (R, G, B).

Inspirado no algoritmo das milhas

Retorna a tabela de índices em {(255, 0, 0), (0, 255, 0), (0, 0, 255)}. Terrivelmente inútil.

(?∘≢⊃⊢)¨(⊂⍳3)/¨⍨1+⊢

(
 ?∘≢ índice aleatório
 ⊃ seleciona
 ⊢de
)¨cada um

(
 ⊂os
 ⍳3três primeiros índices inteiros
)/¨⍨replicados por cada um dos

1+⊢ os trigêmeos incrementados

TryAPL!

Versão antiga

Retorna a tabela de índices baseados em 0 em {(255, 0, 0), (0, 255, 0), (0, 0, 255)}

{+/(?0)≥+\(1+⍵)÷3++/⍵}¨

{... }¨ para cada quixel na tabela, encontre o:

 +/ a soma de (isto é, contagem de verdades de)

 (?0)≥ um aleatório 0 <número <1 sendo maior ou igual a

 +\ a soma acumulada de

 (1+⍵)÷ os valores RGB incrementados divididos por

 3+ mais três

 +/⍵ a soma do quixel

Nota: O Dyalog APL permite escolher entre o gerador congruencial linear Lehmer , o Mersenne Twister e o RNG G ² do sistema operacional .

Por exemplo, a imagem:

┌──────────┬──────────┬───────────┬───────────┬─────────┐
│52 241 198│148 111 45│197 165 180│9 137 120  │46 62 75 │
├──────────┼──────────┼───────────┼───────────┼─────────┤
│81 218 104│0 0 255   │0 255 0    │181 202 116│122 89 76│
├──────────┼──────────┼───────────┼───────────┼─────────┤
│181 61 34 │84 7 27   │233 220 249│39 184 160 │255 0 0  │
└──────────┴──────────┴───────────┴───────────┴─────────┘

pode dar

┌─┬─┬─┬─┬─┐
│1│0│2│2│1│
├─┼─┼─┼─┼─┤
│2│2│1│1│2│
├─┼─┼─┼─┼─┤
│0│2│1│2│0│
└─┴─┴─┴─┴─┘

Observe como os três quixels "puros" desmoronaram em suas respectivas cores.

TryAPL online!

Mathematica, 53 bytes

RandomChoice[255#+1->IdentityMatrix@3]&~ImageApply~#&

Função anônima. Pega um Mathematica Imagecomo entrada e retorna um Imagecomo saída. Observe que a imagem de entrada deve ter um espaço de cores RGB.

C #, 366 243 bytes

Muito obrigado a @TheLethalCoder por jogar isso!

var r=new Random();c=>{double t=c.R+c.G+c.B+3,x=(c.R+1)/t,d=r.NextDouble();return d<=x?Color.Red:d<=x+(c.G+1)/t?Color.Lime:Color.Blue;};b=>{fo‌​r(int x=0,y;x<b.Width;x++)for(y=0;y<b.Height;y++)b.SetPixel(x,y,g(‌​b.GetPixel(x,y)));re‌​turn b;};

Ideia básica:

using System;
using System.Drawing;
static Random r = new Random();

static Image f(Bitmap a) {
    for (int x = 0; x < a.Width; x++) {
        for (int y = 0; y < a.Height; y++) {
            a.SetPixel(x, y, g(a.GetPixel(x, y)));
        }
    }
    return a;
}

static Color g(Color c) {
    int a = c.R;
    int g = c.G;
    double t = a + g + c.B + 3;
    var x = (a + 1) / t;
    var y = x + (g + 1) / t;
    var d = r.NextDouble();
    return d <= x ? Color.Red : d <= y ? Color.Lime : Color.Blue;
}

Exemplos:

Monalisa

Noite estrelada

Persistência de memória

Teddy Roosevelt VS. Pé Grande

Aqui está um álbum imgur atualizado com mais alguns exemplos, para mostrar que isso não é determinístico.

Python 2, 172 166 162 bytes

O segundo e o terceiro níveis de recuo são uma guia bruta e uma guia bruta mais um espaço, respectivamente; isso funciona muito mal com o Markdown, então as guias foram substituídas por dois espaços.

from random import*
i=input()
E=enumerate
for a,y in E(i):
 for b,x in E(y):
  t=sum(x)+3.;n=random()
  for j,u in E(x):
   n-=-~u/t
   if n<0:i[a][b]=j;break
print i

Usa um formato de entrada / saída semelhante à resposta do Adám no APL . A entrada é uma matriz 2D de tuplas RGB; saída é uma matriz 2D de 0, 1ou 2, representando vermelho, verde e azul, respectivamente. Por exemplo:

$ echo "[[(181,61,34),(39,184,160),(255,0,0)],[(84,7,27),(123,97,5),(12,24,88)]]" | python quixel.py
[[2, 2, 0], [0, 0, 0]]

Abaixo está minha resposta mais antiga do Python 3 usando PIL.

Python 3 + PIL, 271 250 245 243 bytes

import random as a,PIL.Image as q
i=q.open(input())
w,h=i.size
for k in range(w*h):
 m=k//h,k%h;c=i.getpixel(m);t=sum(c)+3;n=a.random()
 for j,u in enumerate(c):
  n-=-~u/t
  if n<0:z=[0]*3;z[j]=255;i.putpixel(m,tuple(z));break
i.save('o.png')

Repete cada pixel e aplica a função quixel a ele. Pega o nome do arquivo como entrada e salva sua saída em o.png.

Aqui estão alguns resultados:

$ echo mona-lisa.jpg | python quixel.py

$ echo starry-night.jpg | python quixel.py

$ echo persistence-of-memory.jpg | python quixel.py

$ echo roosevelt-vs-bigfoot.jpg | python quixel.py

R, 58 bytes

mapply(function(r,g,b)rmultinom(1,1,c(r+1,g+1,b+1)),r,g,b)

A entrada consiste em três vetores numéricos mantidos em r, ge brespectivamente.

Não precisamos normalizar as probabilidades de somar uma, o que acontece automaticamente rmultinom.

Saída é da forma

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    0    0    0    0    0    0    0    0    0     0
[2,]    0    0    0    1    0    0    1    1    1     0
[3,]    1    1    1    0    1    1    0    0    0     1

Onde existe um único 1em cada coluna. A 1é em primeira linha para pixels "R", a segunda linha de "L" e a terceira fila para "B".

Pitão - 11 10 bytes

Pega bitmap RGB 2d e gera bitmap com cores indexadas de 3 bits.

mLOs.emkbk

Esse nível de aninhamento está doendo minha cabeça.

Experimente online aqui .

J, 20 18 17 bytes

(>:({~?@#)@##\)"1

A imagem é inserida como uma matriz com dimensões h x w x 3 representando os valores RGB como números inteiros no intervalo de 0 a 255. A saída é uma tabela com dimensões h x w em que 1 é um valor rgb de (255, 0, 0 ), 2 é (0, 255, 0) e 3 é (0, 0, 255).

Explicação

O ()"1representa que esse verbo deve ser aplicado a cada matriz da classificação 1 na entrada, o que significa que será aplicado a cada pixel .

>:({~?@#)@##\  Input: array [R G B]
>:             Increment each, gets [R+1, G+1, B+1]
           #\  Gets the length of each prefix of [R G B], forms [1 2 3]
          #    Make a new array with R+1 copies of 1, G+1 copies of 2,
               and B+1 copies of 3
  (     )@     Operate on that array
       #         Get the length of the array of copies, will be R+G+B+3
     ?@          Generate a random integer in the range [0, R+G+B+3)
   {~            Select the value at that index from the array of copies and return

Gelatina , 8 7 bytes

Jx‘Xµ€€

A entrada é uma lista 3d com dimensões h x w x 3. A saída é uma lista 2d com dimensões h x w em que 1 representa o valor rgb (255, 0, 0), 2 é (0, 255, 0) e 3 é (0, 0, 255).

A entrada de amostra abaixo é a região 4x4 superior esquerda da imagem da Mona Lisa.

Experimente online!

Explicação

Jx‘Xµ€€  Input: The 3d list of rgb pixels
    µ    Begin a monadic chain (Will operate on each pixel, input: [R, G, B])
J          Enumerate indices to get [1, 2, 3]
  ‘        Increment each to get [R+1, G+1, B+1]
 x         Make R+1 copies of 1, G+1 copies of 2, B+1 copies of 3
   X       Select a random value from that list of copies and return
     €€  Apply that monadic chain for each list inside each list

Python 3, 119 bytes

Onde mé feita a entrada como uma matriz bidimensional de pixels em que cada pixel é uma lista do formulário [r,g,b]. Na posição de cada pixel, retorna 0,1,2para representar (250,0,0), (0,250,0), and (0,0,250)respectivamente.

import random
lambda m:[map(lambda x:x.index(sum((((i+1)*[i])for i in x),[])[random.randint(0,sum(x)+2)]),i)for i in m]