एक छवि में हर रंग के लिए "एक जोड़ें"

Question

आप बस इस छवि को लेंगे और हर रंग को हर हेक्साडेसिमल अंक में जोड़ देंगे। उदाहरण के लिए, #49de5fबन जाएगा #5aef60( 9एक करने के लिए लूपिंग के साथ a, और एक के लिए fपाशन 0।)

इसका मतलब यह भी होगा कि सभी सफेद ( #ffffff) काले हो जाएंगे ( #000000) क्योंकि सभी fछोरों पर वापस आते हैं 0, लेकिन सभी काले काले ( #111111) का हल्का शेड बन जाएंगे ।

स्कोरिंग का उपयोग कम से कम बाइट्स पर आधारित है, क्योंकि यह एक कोड-गोल्फ प्रश्न है।

अपने कोड के लिए इनपुट छवि के रूप में नीचे की छवि का उपयोग करें, और अपने उत्तर में अपने कोड की आउटपुट छवि डालें।

यदि आप चाहते हैं, तो आप इस अन्य इंद्रधनुष छवि का भी उपयोग कर सकते हैं:

Comments

यदि हम इनपुट / आउटपुट प्रारूप पर क्या धारणा बना सकते हैं, अगर हम हार्डवेयर / FPGA डिजाइन के लिए डिज़ाइन की गई प्रोग्रामिंग भाषा का उपयोग करना चाहते हैं?

— मोनिका को बहाल करना - Jun--

@hexafraction मुझे लगता है कि डिफ़ॉल्ट रूप से आप एक फ़ाइल के रूप में या हेक्स कोड iirc के रूप में ले सकते हैं।

— R

@hexafraction meta.codegolf.stackexchange.com/q/9093/8478

— मार्टिन

@ मूंगफली, टेस्ट केस होना अच्छा होता है जिसमें efबाइट्स भी शामिल होते हैं (जो f0कि विरोध करना चाहिए 00जो तब होता है जब आप सिर्फ 17 जोड़ते हैं और मॉड 256 लेते हैं)।

— मार्टिन एंडर

आपको नमूना इनपुट प्रदान करने के बजाय नमूना आउटपुट के लिए एक छवि पोस्ट करनी चाहिए। इसके अलावा, यह एक बहुत अच्छी पहली पोस्ट है! साइट पर आपका स्वागत है!

— DJMcMayhem

Answer 1

पाइके, 17 13 बाइट्स

.Fh16j%ijcjs 8{

यहाँ यह कोशिश करो!

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

एक ही प्रारूप में पिक्सल और आउटपुट के 3 डी पूर्णांक सरणी के रूप में इनपुट लेता है

Comments

क्या आप आउटपुट छवि प्रदान कर सकते हैं?

— हयकम

Answer 2

गणितज्ञ, 78 बाइट्स

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

एक छवि ऑब्जेक्ट लेता है और लौटाता है (एक छवि ऑब्जेक्ट बनाने के लिए, बस चित्र को Mathematica में पेस्ट करें)।

परीक्षण मामले के लिए परिणाम:

पूर्णांक चैनल मानों के 3D सरणी के रूप में इनपुट और रिटर्निंग आउटपुट लेते हुए , यह 51 बाइट्स तक कम हो जाता है :

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

लेकिन उन मेटा पोस्टों के पास अभी तक समर्थन की अधिक मात्रा नहीं है, इसलिए मैं अभी के लिए 78-बाइट संस्करण के साथ जा रहा हूं।

Answer 3

वेरिलोग, 220 बाइट्स:

• कार्यक्रम आयामों के साथ आरजीबी पिक्सेल मूल्यों की एक सरणी के रूप में इनपुट ले सकते हैं
• आयामों के साथ आरजीबी पिक्सेल मूल्यों की एक सरणी के माध्यम से कार्यक्रम आउटपुट हो सकते हैं

यह वर्तमान में स्पष्ट नहीं है कि आयाम कैसे प्रदान किए जाने हैं और यदि सरणी को एक साथ स्ट्रीम करना है या प्रदान करना है। मैं एक घड़ी सिग्नल का उपयोग करके एक बार में इसे 8 बिट्स स्ट्रीम करने जा रहा हूं (एक वैध-डेटा ध्वज के साथ जो पूरी छवि संसाधित होने के बाद कम हो जाता है) और इनपुट / आउटपुट 32-बिट पूर्णांक के रूप में आयाम:

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

Answer 4

पायथन, 226 बाइट्स

अब, यह वैध है!

पिलो लाइब्रेरी का उपयोग करें।

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

आउटपुट:

9 बाइट बचाने के लिए @TuukkaX को धन्यवाद!
18 बाइट बचाने के लिए @ mbomb007 को धन्यवाद!

Comments

क्या इसके 0xFFबजाय उपयोग करना आवश्यक है 255?

— यति

@TuukkaX Woops मैंने गौर नहीं किया है कि धन्यवाद

— TuxCrafting

वहाँ एक और 0xFFभी है: D

— Yytsi

मुझे लगता है कि आप कहकर अधिक बाइट बचा सकते हैं from PIL import*। मुझे भी लगता है कि उसके बाद Image.openही इसे बदला जा सकता openहै।

— यति

@TuukkaX हाँ, इसे बदला जा सकता है from PIL import*, लेकिन मैं नहीं बदल सकताImage.open

— TuxCrafting

Answer 5

दिल्लोग एपीएल , 21 15 बाइट्स

कार्यक्रम आरजीबी पिक्सेल मूल्यों के मैट्रिक्स के रूप में आउटपुट कर सकते हैं

मुझे लगता है कि आउटपुट एक ही प्रारूप में हो सकता है।

नया समाधान मूल्यों का मैट्रिक्स लेता है [[ r , g , b , r , g , b ], [ r , g , b ,…

16⊥16|1+16 16⊤⎕

व्याख्या

⎕संख्यात्मक इनपुट
16 16⊤को 2-अंकीय बेस में
1+जोड़ें 16 जोड़ें 1, अर्थात 0 → 1, 1 → 2, 15 → 16
16|मापांक 16, अर्थात 16 → 0
16⊥आधार 16 से परिवर्तित करें

उदाहरण

      ⊢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

---

पुराने 21 बाइट के घोल में [["RRGGBB", "RRGGBB"], ["RRGGBB",…

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

जरूरत है ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है।

व्याख्या

{... }¨प्रत्येक आरजीबी 6-चार स्ट्रिंग के लिए, के रूप में यह प्रतिनिधित्व करते हैं ⍵: और ऐसा
n←⎕D,⎕Aकरने के लिए असाइन "0 ... 9 ए ... जेड" n
⍵⍳⍨ में अलग-अलग पात्रों के सूचकांकों को खोजने n
1+ सूचकांक करने के लिए एक जोड़ने के लिए, यानी 0 → 1, 1 → 2, 15 → 16
16|मापांक 16, यानी 16 → 0
n[... ]कि n में अनुक्रमित करने के लिए उपयोग करें

उदाहरण

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

Answer 6

सी - 114 113 70 66 61 72 67 बाइट्स

यहाँ कोड है ( मार्टिन एंडर के परीक्षण के मामले के लिए समर्थन के साथ (यह 60 बी के बिना)):

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

और यहाँ कम मोटे संस्करण है:

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

संकलित करें और साथ चलाएं gcc -o color colorgolf.c && cat a.bmp | ./color > b.bmp

यह कोड बिटमैप्स के साथ काम करता है । pngफ़ाइलों को परिवर्तित करने के लिए bmp, मैंने निम्नलिखित कमांड का उपयोग किया:convert -flatten -alpha off png.png a.bmp

कोड मानता है, कि bmpहेडर 54 बाइट्स लंबा है - इस मामले में यह काम करता है, लेकिन मुझे यकीन नहीं है कि अगर मैं विवेकपूर्ण रूप से कुछ नहीं तोड़ रहा हूं।

इसके अलावा, यह इंद्रधनुष है:

Answer 7

जावा 142 बाइट्स

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

golfed:

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

Comments

सबसे पहले PPCG में आपका स्वागत है! आपका कोड-गोल्फ कोड iपैरामीटर के रूप में और फॉर-लूप दोनों का उपयोग करता है , इसलिए मैं पैरामीटर को कुछ और जैसे बदल दूंगा a। इसके अलावा, आप इसे int सामने से हटाकर jऔर इसे जोड़कर कुछ और गोल्फ कर सकते हैं int i। तो इस तरह से BufferedImage t(BufferedImage a){for(int i=-1,j;++i<a.getWidth();)for(j=-1;++j<a.getHeight();)a.setRGB(i,j,a.getRGB(i,j)+1118481);return a;}:। इसके अलावा, इस पोस्ट पर एक नज़र डालें: जावा में गोल्फिंग के लिए टिप्स । :)

— केविन क्रूज़सेन

आप रंगों को सही ढंग से सेट नहीं कर रहे हैं। RGB मानों में 0x111111 जोड़कर, आप एक हेक्साडेसिमल स्थान से अगले तक अतिप्रवाह की संभावना रखते हैं। उदाहरण के लिए, # 49de5f # 5aef60 माना जाता है, # 5aef70 नहीं।

— kamoroso94

Answer 8

आर, 302 बाइट्स

बिल्कुल सही, लेकिन यहाँ जाता है:

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

स्पष्टीकरण:

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

      }
   }
}