introduzione

Un quixel è un pixel quantico. Simile a un pixel classico, è rappresentato con 3 valori interi (rosso, verde, blu). Tuttavia, i quixel si trovano in una super posizione di questi 3 stati anziché in una combinazione. Questa super posizione dura solo fino a quando non viene osservato il quixel, a quel punto collassa su uno dei tre pixel classici; RGB(255,0,0), RGB(0,255,0)E RGB(0,0,255).

specificazione

• Rappresentazione
  • Ogni quixel è rappresentato come un array di 3 numeri interi compresi tra 0 e 255 r, ge brispettivamente.
• Posizioni super
  • Ogni Quixel è in una posizione eccellente tra il rosso, blu e verdi stati rappresentati da R, Ge B, rispettivamente.
• Osservazione
  • Quando si osserva ogni quixel, collassa in uno dei tre stati. La probabilità di ogni stato classico è R = (r + 1) / (r + g + b +3), G = (g + 1) / (r + g + b + 3) e B = (b + 1) / (r + g + b + 3). In questo modo ogni stato classico è sempre una probabilità diversa da zero di presentarsi.
• Ingresso
  • La funzione o il programma dovrebbe acquisire un'immagine di quixels. Come lo fa è flessibile. Un nome file, utilizzando un array multidimensionale, ecc. Sono tutti accettabili.
• Produzione
  • La funzione o il programma dovrebbe produrre un'immagine di pixel classici. Anche la struttura dei dati per questa immagine prodotta è flessibile. Si noti che tutti i pixel dovrebbe essere uno di questi tre: RGB(255,0,0), RGB(0,255,0)eRGB(0,0,255)
  • L'output non dovrebbe essere deterministico ; questi sono pixel quantistici ! Lo stesso input dovrebbe comportare output diversi.
  • Se la tua lingua non ha modo di generare un numero casuale, puoi prendere byte casuali come input
• punteggio
  • Si tratta di code-golf quindi vincono meno byte.

immagini

Mona Lisa di Leonardo da Vinci

Notte stellata di Vincent van Gogh

Persistenza della memoria di Salvador Dali

Teddy Roosevelt VS. Bigfoot di SharpWriter

Dyalog APL , 23 21 19 byte

Presenta la tabella delle terzine (R, G, B).

Ispirato dall'algoritmo delle miglia

Restituisce la tabella degli indici in {(255, 0, 0), (0, 255, 0), (0, 0, 255)}. Orribilmente dispendioso.

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

(
 ?∘≢indice casuale
 ⊃seleziona
 ⊢da
)¨ciascuno di

(
 ⊂i
 ⍳3primi tre indici interi
)/¨⍨replicati da ciascuno di

1+⊢ le terzine incrementate

TryAPL!

Vecchia versione

Restituisce la tabella degli indici basati su 0 in {(255, 0, 0), (0, 255, 0), (0, 0, 255)}

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

{... }¨ per ogni quixel nella tabella, trova:

 +/ la somma di (cioè il conteggio delle verità di)

 (?0)≥ uno 0 <numero <1 casuale maggiore o uguale a

 +\ la somma cumulativa di

 (1+⍵)÷ i valori RGB incrementati divisi per

 3+ tre più

 +/⍵ la somma del quixel

Nota: Dyalog APL consente di scegliere tra il generatore congruenziale lineare Lehmer , il Mersenne Twister e l'RNG del sistema operativo ¹ ² .

Ad esempio, l'immagine:

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

posso dare

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

Notate come i tre quixel "puri" sono crollati nei rispettivi colori.

ProvaAPL online!

Mathematica, 53 byte

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

Funzione anonima. Prende un Mathematica Imagecome input e restituisce un Imagecome output. Si noti che l'immagine in ingresso deve avere uno spazio colore RGB.

C #, 366 243 byte

Enorme grazie a @TheLethalCoder per aver giocato a 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 base:

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

Esempi:

Monna Lisa

Notte stellata

Persistenza della memoria

Teddy Roosevelt VS. Bigfoot

Ecco un album imgur aggiornato con qualche altro esempio, per dimostrare che questo non è deterministico.

Python 2, 172 166 162 byte

Il secondo e il terzo trattino sono rispettivamente una scheda non elaborata e una scheda non elaborata più uno spazio; questo suona davvero male con Markdown, quindi le schede sono state sostituite da due spazi.

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

Utilizza un formato di input / output simile alla risposta APL di Adám . L'input è un array 2D di tuple RGB; l'output è un array 2D di 0,1 o 2, che rappresenta rispettivamente rosso, verde e blu. Per esempio:

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

Di seguito è la mia vecchia risposta Python 3 utilizzando PIL.

Python 3 + PIL, 271 250 245 243 byte

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')

Passa da un pixel all'altro e applica ad esso la funzione Quixel. Prende il nome file come input e ne salva l'outputo.png .

Ecco alcuni risultati:

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

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

L'input è costituito da tre vettori numerici tenuti in r,g eb rispettivamente.

Non è necessario normalizzare le probabilità per riassumere in una, che avviene automaticamente in rmultinom .

L'output è nella 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

Dove c'è un singolo 1in ogni colonna. La 1è nella prima riga per i pixel "R", la seconda riga per "G" e la terza riga per "B".

Pyth - 11 10 byte

Cattura RGB 2d bitmap e genera bitmap con colori indicizzati a 3 bit.

mLOs.emkbk

Quel livello di nidificazione mi fa male alla testa.

Provalo online qui .

J, 20 18 17 byte

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

L'immagine viene immessa come un array con dimensioni h x w x 3 che rappresentano i valori RGB come numeri interi nell'intervallo 0 - 255. L'output è una tabella con dimensioni h x w dove 1 è un valore rgb di (255, 0, 0 ), 2 è (0, 255, 0) e 3 è (0, 0, 255).

Spiegazione

Il ()"1rappresenta che questo verbo è da applicare ad ogni array di rango 1 in ingresso, il che significa che applicherà a ciascun 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 byte

Jx‘Xµ€€

L'input è un elenco 3d con dimensioni h x w x 3. L'output è un elenco 2d con dimensioni h x w dove 1 rappresenta il valore rgb (255, 0, 0), 2 è (0, 255, 0) e 3 è (0, 0, 255).

Il seguente esempio di input è la regione 4 x 4 in alto a sinistra dell'immagine di Mona Lisa.

Provalo online!

Spiegazione

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 byte

Dove mviene inserito l'input come una matrice 2-d di pixel in cui ogni pixel è un elenco del modulo [r,g,b]. Nella posizione di ciascun pixel, ritorna 0,1,2per rappresentare (250,0,0), (0,250,0), and (0,0,250)rispettivamente.

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]