Nehmen Sie einfach dieses Bild und fügen Sie jeder hexadezimalen Ziffer eine Farbe hinzu. Zum Beispiel #49de5fwürde #5aef60(mit der 9Schleife zu einem a, und die fSchleife zu einem 0.)

Dies würde auch bedeuten, dass alles Weiße ( #ffffff) zu Schwarz ( #000000) wird, da alle fSchleifen zurück zu 0, aber alles Schwarze wird zu einem helleren Schwarzton ( #111111).

Die Bewertung basiert auf der geringsten Anzahl verwendeter Bytes, da dies eine Code-Golf- Frage ist.

Verwenden Sie das folgende Bild als Eingabebild für Ihren Code und geben Sie das Ausgabebild Ihres Codes in Ihre Antwort ein.

Wenn Sie möchten, können Sie auch dieses andere Regenbogenbild verwenden:

Pyke, 17 13 Bytes

.Fh16j%ijcjs 8{

Probieren Sie es hier aus!

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

Übernimmt Eingaben als ein ganzzahliges 3D-Array von Pixeln und Ausgaben im gleichen Format

Mathematica, 78 Bytes

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

Nimmt ein Bildobjekt auf und gibt es zurück (um ein Bildobjekt zu erstellen, fügen Sie das Bild einfach in Mathematica ein).

Ergebnis für den Testfall:

Die Eingabe und Rückgabe der Ausgabe als 3D-Array von ganzzahligen Kanalwerten reduziert sich auf 51 Byte :

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

Aber diese Meta-Posts haben noch keinen überwältigenden Support, deshalb werde ich vorerst die 78-Byte-Version verwenden.

Verilog, 220 Byte:

• Programme können Eingaben als Array von RGB-Pixelwerten mit Abmessungen annehmen
• Programme können über ein Array von RGB-Pixelwerten mit Abmessungen ausgegeben werden

Derzeit ist nicht klar, wie die Dimensionen bereitgestellt werden sollen und ob das Array auf einmal gestreamt oder bereitgestellt werden soll. Ich streame es 8 Bit auf einmal mit einem Taktsignal (mit einem Valid-Data-Flag, das nach der Verarbeitung des gesamten Bildes auf LOW geht) und gebe die Dimensionen als 32-Bit-Ganzzahlen ein / aus:

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 Bytes

Jetzt ist es gültig!

Verwenden Sie die Pillow-Bibliothek.

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

Ausgabe:

Vielen Dank an @TuukkaX für das Speichern von 9 Bytes!
Vielen Dank an @ mbomb007 für das Speichern von 18 Bytes!

Dyalog APL , 21 15 Bytes

Programme können als Matrix von RGB-Pixelwerten ausgegeben werden

Ich gehe davon aus, dass die Ausgabe im selben Format erfolgen kann.

Neue Lösung nimmt Wertematrix [[ r , g , b , r , g , b ], [ r , g , b ,…

16⊥16|1+16 16⊤⎕

Erläuterung

⎕numerische Eingabe
16 16⊤in zweistellige Basis 16 umwandeln lassen
1+1 addieren, dh 0 → 1, 1 → 2, 15 → 16
16|Modul 16, dh 16 → 0
16⊥von Basis 16 umwandeln

Beispiel

      ⊢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

Die alte 21-Byte-Lösung verwendet eine Matrix aus [["RRGGBB", "RRGGBB"], ["RRGGBB", ...].

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

Needs ⎕IO←0, was bei vielen Systemen Standard ist.

Erläuterung

{… }¨Für jeden RGB-String mit 6 Zeichen stellen Sie ihn wie ⍵folgt dar:
n←⎕D,⎕AWeisen Sie n
⍵⍳⍨ Suchindizes der einzelnen Zeichen in n "0… 9A… Z" zu , und
1+fügen Sie dem Index einen hinzu, dh 0 → 1, 1 → 2, 15 → 16
16|Modul 16, dh 16 → 0
n[… ]verwenden Sie das, um in n zu indexieren

Beispiel

      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 Bytes

Hier ist der Code (mit Unterstützung für Martin Enders Testfall (ohne 60b)):

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

Und hier ist weniger verschleierte Version:

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

Kompilieren und ausführen mit gcc -o color colorgolf.c && cat a.bmp | ./color > b.bmp

Dieser Code unterstützt die Arbeit mit Bitmaps . Um pngDateien zu konvertieren bmp, habe ich folgenden Befehl verwendet:convert -flatten -alpha off png.png a.bmp

Der Code geht davon aus, dass der bmpHeader 54 Byte lang ist - in diesem Fall funktioniert das, aber ich bin mir nicht sicher, ob ich nicht diskret etwas kaputt mache.

Auch das ist der Regenbogen:

Java 142 Bytes

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 gespielt:

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 Bytes

Bei weitem nicht perfekt, aber hier geht:

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

Erläuterung:

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

      }
   }
}