introduction

Un quixel est un pixel quantique. Semblable à un pixel classique, il est représenté avec 3 valeurs entières (rouge, vert et bleu). Cependant, les quixels sont dans une super position de ces 3 états au lieu d'une combinaison. Cette super position ne dure que jusqu’à ce que le quixel soit observé, puis se réduit à l’un des trois pixels classiques; RGB(255,0,0), RGB(0,255,0)Et RGB(0,0,255).

spécification

• Représentation
  • Chaque quixel est représenté par un tableau de 3 entiers compris entre 0 et 255 r, get brespectivement.
• Super positions
  • Chaque QUIXEL est dans une position super entre le rouge, bleu et vert états représentés par R, Get Brespectivement.
• Observation
  • Lorsque chaque quixel est observé, il s'effondre dans l'un des trois états. La probabilité de chaque état classique est R = (r + 1) / (r + g + b +3), G = (g + 1) / (r + g + b + 3) et B = (b + 1) / (r + g + b + 3). De cette façon, chaque état classique a toujours une probabilité d’apparition différente de zéro.
• Contribution
  • La fonction ou le programme doit prendre une image de quixels. Comment cela fonctionne-t-il? Un nom de fichier, en utilisant un tableau multi-dimensionnel, etc. sont tous acceptables.
• Sortie
  • La fonction ou le programme doit produire une image de pixels classiques. La structure de données pour cette image produite est également flexible. Notez que tous les pixels devraient être l' un de ces trois: RGB(255,0,0), RGB(0,255,0)etRGB(0,0,255)
  • Le résultat ne devrait pas être déterministe ; ce sont des pixels quantiques ! La même entrée devrait donner des sorties différentes.
  • Si votre langue n'a aucun moyen de générer un nombre aléatoire, vous pouvez utiliser des octets aléatoires en tant qu'entrée.
• Notation
  • C’est du code-golf, si peu d’octets gagnent.

Images

Mona Lisa de Leonardo da Vinci

Nuit étoilée de Vincent van Gogh

La persistance de la mémoire par Salvador Dali

Teddy Roosevelt VS. Bigfoot par SharpWriter

Dyalog APL , 23 21 19 octets

Prend la table de triplés (R, G, B).

Inspiré par l'algorithme de miles

Renvoie la table des index en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}. Horriblement inutile.

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

(
 ?∘≢index aléatoire
 ⊃sélectionne
 ⊢de
)¨chacun des

(
 ⊂l'ensemble des
 ⍳3trois premiers indices
)/¨⍨répliqués par chacun des

1+⊢ les triplets incrémentés

TryAPL!

Ancienne version

Renvoie une table d'indices basés sur 0 en {(255, 0, 0), (0, 255, 0), (0, 0, 255)}

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

{... }¨ pour chaque quixel du tableau, trouvez le:

 +/ la somme de (nombre de vérités de)

 (?0)≥ un aléatoire 0 <nombre <1 étant supérieur ou égal à

 +\ la somme cumulée de

 (1+⍵)÷ les valeurs RVB incrémentées divisées par

 3+ trois plus

 +/⍵ la somme du quixel

Remarque: Dyalog APL vous permet de choisir entre le générateur de congruence linéaire de Lehmer , le Twister de Mersenne et le RNG ¹ ² du système d'exploitation .

Par exemple, l'image:

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

peut donner

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

Notez comment les trois "purs" quixels se sont effondrés à leurs couleurs respectives.

TryAPL en ligne!

Mathematica, 53 octets

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

Fonction anonyme. Prend Mathematica Imageen entrée et renvoie un Imageen sortie. Notez que l'image d'entrée doit avoir un espace colorimétrique RVB.

C #, 366 243 octets

Un grand merci à @TheLethalCoder pour avoir joué au 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;};

Idée basique:

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

Exemples:

Mona Lisa

Nuit étoilée

La persistance de la mémoire

Teddy Roosevelt VS. Bigfoot

Voici un album imgur mis à jour avec quelques exemples supplémentaires, pour montrer que c'est non déterministe.

Python 2, 172 166 162 octets

Les deuxième et troisième niveaux de retrait sont un onglet brut et un onglet brut plus un espace, respectivement; cela joue vraiment mal avec Markdown, donc les onglets ont été remplacés par deux espaces.

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

Utilise un format d'entrée / sortie similaire à la réponse APL d' Adám . L'entrée est un tableau 2D de n-uplets RVB; la sortie est un tableau 2D de 0, 1ou 2représentant respectivement le rouge, le vert et le bleu. Par exemple:

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

Vous trouverez ci-dessous ma réponse plus ancienne à Python 3 en utilisant PIL.

Python 3 + PIL, 271 250 245 243 octets

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

Itère sur chaque pixel et lui applique la fonction quixel. Prend le nom de fichier en entrée et enregistre sa sortie dans o.png.

Voici quelques résultats:

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

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

Entrée se compose de trois vecteurs numériques tenue à r, get brespectivement.

Nous n'avons pas besoin de normaliser les probabilités pour faire une somme de 1, cela se produit automatiquement en rmultinom.

La sortie est de la forme

     [,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

Où il y en a un 1dans chaque colonne. Le 1est dans la première ligne pour "R" pixels, la deuxième ligne pour "G" et la troisième ligne pour "B".

Pyth - 11 à 10 octets

Prend bitmap RVB 2D et génère une image bitmap avec une couleur indexée 3 bits.

mLOs.emkbk

Ce niveau de nidification me fait mal à la tête.

Essayez-le en ligne ici .

J, 20 18 17 octets

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

L’image est entrée sous forme de tableau de dimensions h x w x 3 représentant les valeurs RVB sous forme d’entiers compris entre 0 et 255. La sortie est un tableau de dimensions h x w où 1 est une valeur rgb de (255, 0, 0 ), 2 est (0, 255, 0) et 3 est (0, 0, 255).

Explication

Le ()"1représente que ce verbe doit être appliqué à chaque tableau de rang 1 dans l'entrée, ce qui signifie qu'il s'appliquera à chaque 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

Gelée , 8 7 octets

Jx‘Xµ€€

L'entrée est une liste 3D de dimensions h x w x 3. La sortie est une liste 2D de dimensions h x w, où 1 représente la valeur de la valeur de référence (255, 0, 0), 2 la valeur (0, 255, 0) et 3 est (0, 0, 255).

L'échantillon ci-dessous est la région 4 x 4 en haut à gauche de l'image Mona Lisa.

Essayez-le en ligne!

Explication

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 octets

Où mest l'entrée prise comme un tableau 2D de pixels où chaque pixel est une liste de la forme [r,g,b]. À la position de chaque pixel, revient 0,1,2à représenter (250,0,0), (0,250,0), and (0,0,250)respectivement.

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]