Vous devez simplement prendre cette image et ajouter une couleur à chaque chiffre hexadécimal. Par exemple, #49de5fdeviendrait #5aef60(avec le 9bouclage vers un aet le fbouclage vers un 0.)

Cela signifierait également que tout le blanc ( #ffffff) deviendrait noir ( #000000) car toutes les fboucles reviennent à 0, mais tout le noir deviendra une teinte plus claire du noir ( #111111).

La notation est basée sur le moins d'octets utilisés, car il s'agit d'une question de code-golf .

Utilisez l'image ci-dessous comme image d'entrée pour votre code et mettez l'image de sortie de votre code dans votre réponse.

Si vous le souhaitez, vous pouvez également utiliser cette autre image arc-en-ciel:

Pyke, 17 13 octets

.Fh16j%ijcjs 8{

Essayez-le ici!

.F            - for i in deep_for(input):
  h16%        -    (i+1)%16
          +   -   ^+V
      i16+    -    (i+16)
           8{ -  unset_bit(8, ^)

Prend les entrées sous forme de tableau de nombres entiers 3D de pixels et les sorties au même format

Mathematica, 78 octets

Image@Apply[16#+#2&,Mod[IntegerDigits[#~ImageData~"Byte",16,2]+1,16]/255,{3}]&

Prend et renvoie un objet image (pour créer un objet image, collez simplement l'image dans Mathematica).

Résultat pour le cas de test:

En prenant l'entrée et en renvoyant la sortie sous la forme d'un tableau 3D de valeurs de canaux entiers, cela se réduit à 51 octets :

Apply[16#+#2&,Mod[IntegerDigits[#,16,2]+1,16],{3}]&

Mais ces méta-publications n'ont pas encore un support écrasant, donc je vais pour le moment avec la version 78 octets.

Verilog, 220 octets:

• Les programmes peuvent prendre en entrée un tableau de valeurs de pixels RVB avec des dimensions
• Les programmes peuvent sortir via un tableau de valeurs de pixels RVB avec des dimensions

Actuellement, il n'est pas clair comment les dimensions doivent être fournies et si le tableau doit être diffusé ou fourni en même temps. Je vais le diffuser 8 bits à la fois en utilisant un signal d'horloge (avec un indicateur de données valides qui devient faible après que toute l'image a été traitée) et entrer / sortir les dimensions sous forme d'entiers 32 bits:

module a(input[31:0]w,input[31:0]h,input[7:0]d,input c,output[31:0]W,output[31:0]H,output reg[7:0]D,output reg v=0);assign W=w;assign H=h;reg[65:0]p=1;always@(posedge c) begin v<=(p<3*w*h); p<=p+v; D<=d+17; end endmodule

Python, 226 octets

Maintenant, c'est valable!

Utilisez la bibliothèque Pillow.

from PIL import Image
m=Image.open(input()).convert("RGB")
for y in range(m.size[1]):
 for x in range(m.size[0]):
    t=m.getpixel((x,y))
    h=t[0]+(t[1]<<8)+(t[2]<<16)+1118481
    m.putpixel((x,y),(h&255,h>>8&255,h>>16&255))
m.show()

Sortie:

Merci à @TuukkaX pour avoir économisé 9 octets!
Merci à @ mbomb007 pour avoir économisé 18 octets!

Dyalog APL , 21 15 octets

Les programmes peuvent sortir sous forme de matrice de valeurs de pixels RVB

Je suppose que la sortie peut être au même format.

Une nouvelle solution prend une matrice de valeurs [[ r , g , b , r , g , b ], [ r , g , b ,…

16⊥16|1+16 16⊤⎕

Explication

⎕obtenir une entrée numérique
16 16⊤convertir en base à 2 chiffres 16
1+ajouter 1, c'est-à-dire 0 → 1, 1 → 2, 15 → 16
16|module 16, c'est-à-dire 16 → 0
16⊥convertir de la base 16

Exemple

      ⊢m←2 6⍴90 239 96 255 255 255 0 0 0 239 239 239
90 239 96 255 255 255
 0   0  0 239 239 239
      16⊥16|1+⎕⊤⍨2/16
⎕:
      m
107 240 113   0   0   0
 17  17  17 240 240 240

L'ancienne solution de 21 octets prend la matrice de [["RRGGBB", "RRGGBB"], ["RRGGBB",…

{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨

Besoins ⎕IO←0, qui est par défaut sur de nombreux systèmes.

Explication

{… }¨Pour chaque chaîne RVB de 6 caractères, représentez-la comme ⍵suit:
n←⎕D,⎕Aaffectez «0… 9A… Z» à n
⍵⍳⍨ trouver les index des caractères individuels en n
1+ ajoutez-en un à l'index, soit 0 → 1, 1 → 2, 15 → 16
16|module 16, soit 16 → 0
n[… ]utilisez-le pour indexer en n

Exemple

      f←{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨ 
      ⊢p←2 2⍴'5AEF60' 'FFFFFF' '000000' 'EFEFEF'
┌──────┬──────┐
│5AEF60│FFFFFF│
├──────┼──────┤
│000000│EFEFEF│
└──────┴──────┘
      f p           
┌──────┬──────┐
│6BF071│000000│
├──────┼──────┤
│111111│F0F0F0│
└──────┴──────┘

C - 114 113 70 66 61 72 67 octets

Voici le code (avec prise en charge du cas de test de Martin Ender (sans 60b)):

main(c,b){for(;~(b=getchar());putchar(c++<54?b:b+16&240|b+1&15));}

Et voici la version moins brouillée:

main( c, b ) //Defaults to int
{
    //Get characters until EOF occurs
    //Copy first 54 bytes of header, later add 1 to each hexadecimal digit
    for ( ; ~( b = getchar( ) ); putchar( c++ < 54 ? b: b + 16 & 240 | b + 1 & 15 ) ); 
}

Compiler et exécuter avec gcc -o color colorgolf.c && cat a.bmp | ./color > b.bmp

Ce code prend en charge les travaux avec les bitmaps . Pour convertir des pngfichiers en bmp, j'ai utilisé la commande suivante:convert -flatten -alpha off png.png a.bmp

Le code suppose que cet en- bmptête fait 54 octets de long - dans ce cas, cela fonctionne, mais je ne suis pas sûr de ne pas casser quelque chose discrètement.

C'est aussi l'arc-en-ciel:

Java 142 octets

public BufferedImage translateColor(BufferedImage image){
  for(int i=-1;++i<image.getWidth();)
    for(int j=-1;++<image.getHeight();)
      image.setRGB(i,j,image.getRGB(i,j)+1118481);
  return image;
}

Golfé:

BufferedImage t(BufferedImage i){for(int x=-1;++x<i.getWidth();)for(int y=-1;++y<i.getHeight();)i.setRGB(x,y,i.getRGB(x,y)+1118481);return i;}

R, 302 octets

Loin d'être parfait, mais voici:

a<-as.raster(imager::load.image(file.choose()));l=letters;n=as.numeric;d=a;f=function(x){if(suppressWarnings(is.na(n(x)))){if(x=="F")"0" else{l[match(x,toupper(l))+1]}}else{if(x==9)"A" else as.character(n(x)+1)}};for(o in 1:90){for(g in 1:200){for(h in 2:7){substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))}}}

Explication:

a<-as.raster(imager::load.image(file.choose()));  //chooses file
l=letters;n=as.numeric;d=a;                      //shortens some names and creates
                                                   duplicate variable to modify

f=function(x){                                //creates a function that takes in a
   if(suppressWarnings(is.na(n(x)))){            character type and checks whether it is
      if(x=="F")"0"                              a number or letter.
      else{l[match(x,toupper(l))+1]}}            Returns the converted letter or number.                               
   else{                                   
      if(x==9)"A"                         
      else as.character(n(x)+1)}         
};                                      

for(o in 1:90){                       //loops through every single hex digit and applies
   for(g in 1:200){                     the converting function, modifying the duplicate
      for(h in 2:7){                    variable. Now you have 2 images =D

         substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))

      }
   }
}