Introducción

Un quijel es un píxel cuántico. Similar a un píxel clásico, se representa con 3 valores enteros (rojo, verde, azul). Sin embargo, los quijels están en una súper posición de estos 3 estados en lugar de una combinación. Esta súper posición solo dura hasta que se observa el quijel, momento en el que colapsa en uno de los tres píxeles clásicos; RGB(255,0,0), RGB(0,255,0)Y RGB(0,0,255).

Especificación

• Representación
  • Cada quijel se representa como una matriz de 3 enteros entre 0 y 255 r, gy brespectivamente.
• Super Posiciones
  • Cada quijel está en una súper posición entre los estados Rojo, Azul y Verde representados por R, Gy Brespectivamente.
• Observación
  • Cuando se observa cada quijel, colapsa en uno de los tres estados. La probabilidad de cada estado clásico es R = (r + 1) / (r + g + b +3), G = (g + 1) / (r + g + b + 3) y B = (b + 1) / (r + g + b + 3). De esta manera, cada estado clásico siempre tiene una probabilidad distinta de cero de aparecer.
• Entrada
  • La función o programa debe tomar una imagen de quijels. Cómo lo hace es flexible. Un nombre de archivo, utilizando una matriz multidimensional, etc., son aceptables.
• Salida
  • La función o programa debe producir una imagen de píxeles clásicos. La estructura de datos para esta imagen producida también es flexible. Nótese que todos los píxeles debería ser uno de estos tres: RGB(255,0,0), RGB(0,255,0)yRGB(0,0,255)
  • La salida no debe ser determinista ; ¡Son píxeles cuánticos ! La misma entrada debería dar como resultado diferentes salidas.
  • Si su idioma no tiene forma de generar un número aleatorio, puede tomar bytes aleatorios como entrada
• Tanteo
  • Este es el código de golf, por lo que ganan menos bytes.

Imágenes

Mona Lisa de Leonardo da Vinci

Noche estrellada de Vincent van Gogh

Persistencia de la memoria por Salvador Dali

Teddy Roosevelt VS. Bigfoot por SharpWriter

Dyalog APL , 23 21 19 bytes

Toma la tabla de trillizos (R, G, B).

Inspirado en el algoritmo de millas

Devuelve la tabla de índices en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}. Horriblemente derrochador.

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

(
 ?∘≢índice aleatorio
 ⊃selecciona
 ⊢de
)¨cada uno de

(
 ⊂los
 ⍳3primeros tres índices completos
)/¨⍨replicados por cada uno de

1+⊢ los tripletes incrementados

TryAPL!

Versión antigua

Devuelve la tabla de índices basados ​​en 0 en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}

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

{... }¨ para cada quijel en la tabla, encuentre el:

 +/ la suma de (es decir, el recuento de verdades de)

 (?0)≥ un 0 aleatorio <número <1 es mayor o igual que

 +\ la suma acumulativa de

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

 3+ tres más

 +/⍵ la suma del quijel

Nota: Dyalog APL le permite elegir entre el generador congruencial lineal de Lehmer , el Mersenne Twister y el RNG ¹ ² del sistema operativo .

Por ejemplo, la imagen:

┌──────────┬──────────┬───────────┬───────────┬─────────┐
│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  │
└──────────┴──────────┴───────────┴───────────┴─────────┘

puede dar

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

Observe cómo los tres quijels "puros" colapsaron en sus respectivos colores.

TryAPL en línea!

Mathematica, 53 bytes

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

Función anónima. Toma un Mathematica Imagecomo entrada y devuelve un Imagecomo salida. Tenga en cuenta que la imagen de entrada debe tener un espacio de color RGB.

C #, 366243 bytes

¡Muchas gracias a @TheLethalCoder por jugar al golf!

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;};

Idea 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;
}

Ejemplos:

Mona Lisa

Noche estrellada

Persistencia de la memoria

Teddy Roosevelt VS. Pie Grande

Aquí hay un álbum de imgur actualizado con algunos ejemplos más, para mostrar que esto no es determinista.

Python 2, 172 166 162 bytes

Los niveles de sangría segundo y tercero son una pestaña sin procesar y una pestaña sin procesar más un espacio, respectivamente; esto juega muy mal con Markdown, por lo que las pestañas han sido reemplazadas por dos espacios.

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

Utiliza un formato de entrada / salida similar a la respuesta APL de Adám . La entrada es una matriz 2D de tuplas RGB; la salida es una matriz 2D de 0, 1o 2, que representa rojo, verde y azul, respectivamente. Por ejemplo:

$ 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]]

A continuación se muestra mi respuesta anterior de 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')

Itera sobre cada píxel y le aplica la función de quijel. Toma el nombre de archivo como entrada y guarda su salida en o.png.

Aquí hay algunos 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)

La entrada consta de tres vectores numéricos mantenidos en r, gy brespectivamente.

No necesitamos normalizar las probabilidades para sumar uno, eso sucede automáticamente en rmultinom.

La salida es de la 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

Donde hay un solo 1en cada columna. El 1está en la primera fila para los píxeles "R", la segunda fila para "G" y la tercera fila para "B".

Pyth - 11 10 bytes

Toma un mapa de bits RGB 2d y genera un mapa de bits con color indexado de 3 bits.

mLOs.emkbk

Ese nivel de anidación me duele la cabeza.

Pruébelo en línea aquí .

J, 20 18 17 bytes

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

La imagen se ingresa como una matriz con dimensiones h x w x 3 que representan los valores RGB como enteros en el rango de 0 a 255. La salida es una tabla con dimensiones h x w donde 1 es un valor rgb de (255, 0, 0 ), 2 es (0, 255, 0) y 3 es (0, 0, 255).

Explicación

El ()"1representa que este verbo se debe aplicar a cada matriz de rango 1 en la entrada, lo que significa que se aplicará a cada píxel .

>:({~?@#)@##\  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

Jalea , 8 7 bytes

Jx‘Xµ€€

La entrada es una lista 3d con dimensiones h x w x 3. La salida es una lista 2d con dimensiones h x w donde 1 representa el valor rgb (255, 0, 0), 2 es (0, 255, 0) y 3 es (0, 0, 255).

La entrada de muestra a continuación es la región 4 x 4 superior izquierda de la imagen de Mona Lisa.

Pruébalo en línea!

Explicación

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

¿Dónde mse toma la entrada como una matriz de píxeles en 2-d donde cada píxel es una lista de la forma [r,g,b]? En la posición de cada píxel, vuelve 0,1,2a 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]