स्रोत के अंदर एक छवि एनकोड करें

10

गोल्फ चुनौती एक स्रोत फ़ाइल के अंदर निम्न छवि को एन्कोड और संपीड़ित करने के लिए है।

छवि

ऐसा करने के लिए आप 3 कार्यों लिखने के लिए की जरूरत है: red, green, और blueजो छवि का x / y निर्देशांक स्वीकार करते हैं और 0-255 के बीच इसी आर / जी / बी पिक्सेल मान।

यहाँ C / C ++ टेस्ट कोड दिया गया है:

#include <stdio.h>
#include "your_file"
int main() {
  int x, y;
  for(y = 0; y < 32; ++y)
  for(x = 0; x < 32; ++x)
    printf("%i %i %i\n", red(x, y), blue(x, y), green(x, y));
}

और आउटपुट: http://pastebin.com/A770ckxL (आप अपनी छवि डेटा उत्पन्न करने के लिए इसका उपयोग कर सकते हैं)

नियम और विवरण:

  • यह एक गोल्फ है
  • केवल आपका कोड / फ़ाइल गोल्फ है - परीक्षण कोड अलग है
  • उपयोग किया गया वर्ण ASCII है, हालांकि तार में नियंत्रण वर्ण केवल तभी उपयोग किए जा सकते हैं जब बच गए हों (जैसे '\ n' और '\ r', आदि)
  • सब कुछ स्रोत के अंदर समाहित होना चाहिए - कोई फ़ाइल लोडिंग नहीं
  • आपके आउटपुट को उदाहरण आउटपुट से मेल खाना चाहिए। इसका मतलब है कि लॉसलेस कम्प्रेशन।

भाषाएँ:

समस्या को सी / सी ++ को ध्यान में रखकर लिखा गया था, लेकिन मैं उन प्रतिबंधों को हटा रहा हूं। उस के साथ, मैं अभी भी उन्हें इस्तेमाल करने की सलाह दूंगा।

code-golf  kolmogorov-complexity  graphical-output 
— Pubby
स्रोत
4
यदि ऐसा करने के लिए कोई विशेष कारण नहीं है, तो एक विशिष्ट भाषा के लिए एक प्रश्न को ठीक करना बहुत हतोत्साहित करता है। क्या कारण है कि किसी को अन्य भाषाओं का उपयोग नहीं करना चाहिए?
— फ़ूजएक्सएक्सएल
3
यदि कोई समाधान कम दिलचस्प है, तो उसे वोट न करें। भाषाओं को बहिष्कृत करने के लिए "लंगड़ा" समाधान मना है।
— फ्यूजएक्सएक्सएल
2
यदि आपने पहले से ही ASCII (जिसे मैं बिल्कुल ठीक मानता हूं) के लिए सेट कैरेक्टर को सीमित कर दिया है, तो हम यूनिकोड हैक का उपयोग कैसे कर सकते हैं? बेस 64 के लिए, आप ऐसा कर सकते हैं कि मानक सी के साथ-साथ किसी भी अन्य भाषा में, यह केवल अलग-अलग मात्रा में आवरण कोड है। - लेकिन मुझे यह काम पसंद है।
— को चालू करना बंद कर दिया
1
हम्म, एएससीआईआई नियंत्रण पात्रों के बारे में 0-31 (और 127) क्या है? तकनीकी रूप से, वे ASCII का हिस्सा हैं, लेकिन क्या उन्हें अनुमति है? और यदि नहीं, तो मुझे उम्मीद है कि कम से कम एलएफ चरित्र (10), और शायद सीआर (13) और टीएबी (9) के लिए भी एक अपवाद है?
— इल्मरी करोनें
1
उम ... इसलिए, आपके नए संस्करण को शाब्दिक रूप से पढ़ते हुए, सभी समाधान एक पंक्ति में होने चाहिए, क्योंकि अनपेक्षित पंक्ति फ़ीड की अनुमति नहीं है। क्या वास्तव में आपका इरादा है?
— इल्मरी करोनें

जवाबों:

6

C, 796 754 712 703 692 685 682 670 666 662 656 648 char

बदलाव का:

  • 754-> 712: जोड़ा गया returnके लिए #defineजगह, ifसाथ ?हटाने, बयान (धन्यवाद @FUZxxl) intसूची पैरामीटर कार्यों से।
  • 712-> 703: फिर से बनी से नकल रहित :) पूरी छवि निर्माण में चला गया #define
  • 703-> 692: विलय p[]और h[], कुछ और ?:सुधार
  • ६ ९ २-> ६-५: वृद्धि bइसलिए अब iऔर नहीं चाहिए। m=bके बजाय m=11और के n<2e3बजाय i<356- ये अपरिभाषित व्यवहार / स्मृति भ्रष्टाचार के करीब हैं, लेकिन ऐसा लगता है कि मैं भाग्यशाली हूं :)
  • 685-> 682: k(5,4,3,2,1,0) के बजाय अब (32,16,8,4,2,1,0) है। गोत्चा, डीसी;)
  • 682-> 670: स्प्लिट p[]और h[], h[]a char*- awwww में परिवर्तित , इसमें एक नींद किट्टी है^<+_=>-
  • 670-> 666: while=> for, l=l*2+...=>l+=l+...
  • 666-> 662: m=m>9?...=>c[n++]=m>9?...
  • ६६२-> ६५६: उल्टे बिट क्रम में b[], इसलिए हम ०.६३ के बजाय ६४-१२ of पर मैप कर सकते हैं और kअब बिट इंडेक्स की आवश्यकता नहीं है। धन्यवाद @Piotr टारसा । के साथ प्रतिस्थापित ?:(जीसीसी विस्तार) ||। धन्यवाद @JamesB
  • 656-> 648: शेल्विन से बेशर्म कॉपी :) (के लिए बहु-चरित्र स्थिरांक p[])

छवि को बेस64-जैसे स्ट्रिंग (एएससीआईआई 37-100) में बदल दिया गया है, हफ़मैन कोडिंग का उपयोग करते हुए रंगों को 3-6 बिट्स का उपयोग कर 0-9 एन्कोड किया जाता है और केवल 1 बिट का उपयोग करके एक विशेष रंग 10 (पिक्सेल पिछले एक जैसा है)।

#define P (x,y){for(;n<2e3;j/=2){j>1||(j=*b+++27);l+=l+(j&1);for(m=0;m<11;m++)l-h[m]+32||(c[n++]=m>9?c[n-1]:m,l=0,m=b);}return 255&p[c[x+y*32]]
char*h="$^<+_=>-,* ",*b="F0(%A=A=%SE&?AEVF1E01IN8X&WA=%S+E+A-(,+IZZM&=%]U5;SK;cM84%WE*cAZ7dJT3R.H1I2@;a^/2DIK&=&>^X/2U*0%'0E+;VC<-0c>&YU'%],;]70R=.[1U4EZ:Y=6[0WU4%SQARE0=-XDcXd_WW*UAF&cFZJJ0EV*(a(P05S3IXA>51cH:S5SAE6+W%/[]7SF(153UM]4U()(53DA+J:]&5+5KX,L6>*4I,/UMBcML9WKLa9%UYIHKWW(9-*):(-ZW(9%T'N&9;C,C/Ea/Y7(JJ\\6CD9E,2%J*,ac]NIW8(M=VFac)/^)?IS-;W&45^%*N7>V,,C-4N35FMQaF,EaWX&*EJ4'";p[]={0,'R@+','aXL',7783255,'4k`',16354410,'NNv',5295994,4671418,9975021},c[1024],j,l,m,n;red P;}blue P>>16;}green P>>8;}

बन्नीट के उत्तर से दो चीजें कॉपी की गईं, #defineऔर पूरी छवि को हर बार पूरी तरह से डिकोड किया गया red/ green/ blueकहा जाता है। अतिरिक्त सुधार के लिए कुछ जगह है, इसलिए कुछ अपडेट की उम्मीद करें :) मुझे कोड अनुपालन के बारे में निश्चित नहीं है, संकलन और परीक्षण के लिए जीसीसी 4.6.1 का उपयोग किया गया है।

संपीड़न-वार, मुझे लगता है कि अंकगणित कोडिंग से मदद मिलेगी क्योंकि वितरण बहुत कम है, लेकिन शायद कोड ओवरहेड इस मामले में बहुत भारी होगा। LZW को भी बहुत अच्छा काम करना चाहिए। रंग काफी स्थानीय हैं, इसलिए अनुकूली कोडिंग एक विचार हो सकता है।

कुछ टिप्पणियों के साथ अधिक पठनीय 754 चरित्र संस्करण:

#define P 255&p[c[x+y*32]]
// Base64 coded image bitstream, ASCII 37-100
// Huffman codes: 100, 111110, 11100, 1011, 111111, 11101, 11110, 1101, 1100, 1010, 0
char b[]="FYU%3+3+%B&E;3&HF1&Y1.JWXE83+%B=&=3)U]=.PP*E+%,('?B>?D*Wa%8&MD3P7dNbARIV1.Q[?4L9Qc.>E+EKLX9Q(MY%5Y&=?HC_)YDKE0(5%,]?,7YR+I@1(a&PO0+G@Y8(a%B23R&Y+)XcDXd<88M(3FEDFPNNY&HMU4UZY'BA.X3K'1DVOB'B3&G=8%9@,7BFU1'A(*,a(U-U'Ac3=NO,E'='>X]^GKMa.]9(*SD*^/8>^4/%(0.V>88U/)M-OU)P8U/%b5JE/?C]C9&4907UNN`GCc/&]Q%NM]4D,J.8WU*+HF4D-9L-;.B)?8Ea'L%MJ7KH]]C)aJA'F*24F]&48XEM&Na5";
// Colors, order GBR (one char shorter than all the others)
p[]={0,5390379,6379596,7783255,3435360,16354410,5131894,5295994,4671418,9975021};
// Huffman codes for colors 0-10
h[]={4,62,28,11,63,29,30,13,12,10,0};
// Array for image data
c[1024];
i,j,k,l,m,n;
red(int x,int y){
  while(i<356){
    k--;
    if (k<0) {
      j=b[i++]-37;
      k=5;
    }
    l*=2;
    if (j&(1<<k)) l++;
    for(m=0;m<11;m++){
      if(l==h[m]){
        if (m>9) m=c[n-1];
        c[n++]=m;
        l=0;
        m=12;
      }
    }
  }
  return P;
}
blue(int x,int y){return P>>16;}
green(int x,int y){return P>>8;}
— schnaader
स्रोत
बहुत अच्छा, विश्वास नहीं कर सकता कि मैंने आधार 64 का उपयोग करने के बारे में नहीं सोचा था। मुझे लगता है कि आप अभी भी काफी कुछ अक्षर बचा सकते हैं, खासकर उस पाश में। VS2008 btw में ठीक काम करता है।
— स्कॉट लोगान
मुझे लगता है कि आप intकुछ और बाइट्स निकालने के लिए उस पैरामीटर सूची से निकाल सकते हैं।
— FUZxxl
कैसे के m=m>9?c[n-1]:m;लिए if(m>9)m=c[n-1];?
— FUZxxl
और यह भी: if(k<0){j=b[i++]-37;k=5;}क्यों नहीं k>=0?:(j=b[i++]-37,k=5);? (यह कोड gcc के C एक्सटेंशन का उपयोग करता है , इस अंतर x=a?:bके समान है x=a?a:b, जिसका मूल्यांकन केवल एक बार किया जाता है।
— FUZxxl
red(x,y){while(i<356){--k>=0?:(j=b[i++]-37,k=5);l*=2;if(j&(1<<k))l++;for(m=0;m<11;m++)l!=h[m]?:(m=m<=9?:c[n-1],c[n++]=m,l=0,m=12);}return P;}
— FUZxxl
4

पायथन ( 684 592 अक्षर)

red,blue,green=[lambda x,y,i=i:[15570996,2839104,7010700,5732035,6304875,0,12207943,8016079,7753294,5005656][int('eJxtkgGSxSAIQ6+kaLTe/2JLImj7Z9MZ6/gMIgjAzMbVWisGySRNm2ut5Hhx/2M0JMfHH5PWwo9x4mNO8pb6JkFM3hpqrR4+qY6eVK1mjlsFeSOBjPyCMy3348aXVRtq9X8czovMIwA5FeXKtGOcvfcf/lbvyW0n2BTOh122HiIH0g/uNrx47zupzMxuuTv808pZd3K7deJ/+PiH61AztmaNwPAsOnNGYovWIxswRill6vnAL4HgxDF17jFcjwRk/5b3Q1x1flLI9n64CIci8bmQe7NL8XoKliu+Jk/AR9rnjkwAYaDka8OXu/a+5NvvNzkcmqifL47H04kAz9M+9slKkDMGuOHi5PR7GZwv7MeApkz5JOSPHFVW3QTbzDJtzDIczkuWjeupLbckLyU5/gByftMg'.decode('base64').decode('zip')[32*y+x])]>>i&255 for i in 16,8,0]

चूंकि यह चुनौती अब सभी के लिए खुली है, क्यों नहीं! यह परिचित ज़ालिब -> बेस 64 एनकोडिंग मार्ग है, इसलिए मैं इसके लिए माफी माँगता हूँ। उम्मीद है कि सरलता के कुछ झलक के साथ एक प्रविष्टि कम होगी!

यहाँ मूल के अनुरूप एक परीक्षण स्निपेट है:

for y in range(32):
    for x in range(32):
        print red(x,y), blue(x,y), green(x,y)
— डिलन कॉवर
स्रोत
आपको पिछले पिक्सेल मान को दोहराने के लिए एक विशेष रंग जोड़ने की कोशिश करनी चाहिए। 588 chars base64 मेरे उत्तर (365 वर्ण) में स्ट्रिंग की तुलना में बहुत बड़ा है और यद्यपि zLib यहां ओवरकिल है, इसे एक समान परिणाम देना चाहिए, इसलिए कुल मिलाकर लगभग 500 चार्ट इस तरह से संभव होना चाहिए।
— श्नाडर
4

सी ++, 631 चर; सी - 613

आधार -92 यूनियरी mtf कोडर, C ++, 631 वर्ण:

#define A(Z)int Z(int X,int Y){char*s="xdGe*V+KHSBBGM`'WcN^NAw[,;ZQ@bbZVjCyMww=71xK1)zn>]8b#3&PX>cyqy@6iL?68nF]k?bv/,Q`{i)n[2Df1zR}w0yIez+%^M)Diye{TC]dEY\\0,dU]s'0Z?+bo;7;$c~W;tvFl%2ruqWk$Rj0N[uP)fSjk?Tnpn_:7?`VbJ%r@7*MQDFCDo3)l#ln<kuRzzHTwCg&gYgSXtv\\m_Eb}zRK7JK<AZzOe}UX{Crk)SyBn;;gdDv=.j*O{^/q6)`lHm*YYrdM/O8dg{sKW#B3BLMiI8@-Zo-EsgE.R#viYL$-<EU*~u5pe$r:`b)^dgXOJtf4";int*v,B=92,R=1,C=0,w[]={0,16354410,4671418,'aXL',7783255,5295994,'R@+','4k`',9975021,'NNv'};for(X+=Y*32+1;X--;)for(v=w;;){for(Y=*v++;R<B*B*B;C=C%R*B+*s++-35)R*=B;if(R/=2,C>=R){for(C-=R;--v>w;*v=v[-1]);*v=Y;break;}}return 255&Y
A(red);}A(blue)>>16;}A(green)>>8;}

और ऊपर का C संस्करण (613 वर्ण):

#define A (X,Y){char*s="xdGe*V+KHSBBGM`'WcN^NAw[,;ZQ@bbZVjCyMww=71xK1)zn>]8b#3&PX>cyqy@6iL?68nF]k?bv/,Q`{i)n[2Df1zR}w0yIez+%^M)Diye{TC]dEY\\0,dU]s'0Z?+bo;7;$c~W;tvFl%2ruqWk$Rj0N[uP)fSjk?Tnpn_:7?`VbJ%r@7*MQDFCDo3)l#ln<kuRzzHTwCg&gYgSXtv\\m_Eb}zRK7JK<AZzOe}UX{Crk)SyBn;;gdDv=.j*O{^/q6)`lHm*YYrdM/O8dg{sKW#B3BLMiI8@-Zo-EsgE.R#viYL$-<EU*~u5pe$r:`b)^dgXOJtf4";int*v,B=92,R=1,C=0,w[]={0,16354410,4671418,'aXL',7783255,5295994,'R@+','4k`',9975021,'NNv'};for(X+=Y*32+1;X--;)for(v=w;;){for(Y=*v++;R<B*B*B;C=C%R*B+*s++-35)R*=B;if(R/=2,C>=R){for(C-=R;--v>w;*v=v[-1]);*v=Y;break;}}return 255&Y
red A;}blue A>>16;}green A>>8;}

बस बेस -95 डेटा और अंकगणित कोडिंग + अनुकूली सांख्यिकीय मॉडल के साथ एक प्रविष्टि शामिल करने के लिए।
schnaader का कोड डेटा के लिए ~ 438 चार्ट का उपयोग करता है, और मेरा केवल 318 (311 w / o मास्किंग) है।
लेकिन उम्मीद के मुताबिक, इस तरह के एक छोटे से नमूने के लिए अंकगणित कोडिंग बहुत जटिल है।

(यह 844 वर्ण है)

char* q="q^<A\">7T~pUN1 adz824K$5a>C@kC8<;3DlnF!z8@nD|9D(OpBdE#C7{yDaz9s;{gF[Dxad'[oyg\\,j69MGuFcka?LClkYFh=:q\\\\W(*zhf:x)`O7ZWKLPJsP&wd?cEu9hj 6(lg0wt\\g[Wn:5l]}_NUmgs]-&Hs'IT[ Z2+oS^=lwO(FEYWgtx),)>kjJSIP#Y?&.tx-3xxuqgrI2/m~fw \\?~SV={EL2FVrDD=1/^<r*2{{mIukR:]Fy=Bl.'pLz?*2a? #=b>n]F~99Rt?6&*;%d7Uh3SpLjI)_abGG$t~m{N=ino@N:";
#define I int
#define F(N) for(i=0;i<N;i++)
#define Z C=(C%T)*B+(*q++)-32
enum{B=95,H=1024,T=B*B*B};I p[B],v[B+H],n=3,*m=&v[B],R=T*B,C,i,j,y,c,x,w;void D(I P){w=(R>>11)*P;(y=C>=w)?R-=w,C-=w:R=w;while(R<T)R*=B,Z;}struct u{u(){F(4)Z;F(B)p[i]=H,v[i]=0;F(H){v[0]=m[i-1];v[1]=m[i-32];j=i;F(n){I&P=p[i];D(P);if(y){P-=P>>4;c=v[i];goto t;}else P+=H+H-P>>4;}c<<=7;for(x=-255;x<0;x+=x+y)D(H);v[n++]=c=x;t:m[i=j]=c;}}}d;I red(I x,I y,I z=0){return m[y*32+x]>>z&255;}
#define blue(x,y) red(x,y,8)
#define green(x,y) red(x,y,16)

टेस्ट (पहले आधार -96 संस्करण से):
http://codepad.org/qrwuV3Oy
http://ideone.com/ATngC

किसी तरह SO 7F कोड खाता है, इसलिए मुझे इसे आधार = 95 पर अपडेट करना पड़ा

— Shelwien
स्रोत
3

सी ++ - 1525 1004 964 चार्ट

#define e (int x,int y){for(i=g=0;i<702;i=i+2)for(j=48;j<d[i];++j)c[g++]=d[i+1]-48;return 255&z[c[x+y*32]]
int i,g,j,z[]={0,7010700,12207943,5005656,5732035,8016079,2839104,6304875,15570996,7753294},c[1024];
char*d="3031;23322337261524453223310625132101214103453101233722172643310323342102521229492333210352112241036141014821042552621241014161016141024121022103210151015104526211034361034726510352625107441:530855425201511551045378554>55755312410242035201510528725212044451015411032:73135216561321012171017101725313581125152572531358122415257257110213310131231422022172025105110315322103210623815203110113053521053223817506920721013361322282530991062101213361322282520491049682224133614121028101510291029;812341023342835694810582018841018356978194810842835193329781019482410542835192310193668399428454319362928102829843845331019263028101330441014382035104369285338101810284536334910291018534820283546891019102943883536";
int red e>>16;}
int blue e>>8;}
int green e;}

एक एरे जेड बनाया गया है जो एक पूर्णांक के रूप में सभी संभावित रंगों को संग्रहीत करता है। (r << 16 | g << 8 | b)। एक सरणी d बनाया गया है जो {राशि, मान} को संग्रहीत करता है, मान सरणी z में स्थिति है, राशि उस मान के साथ लगातार पिक्सेल की संख्या है। (यानी 3,0, जिसका अर्थ है कॉलआउट टी [0] अगले 3 प्रकट होता है। पिक्सेल। पिक्सेल की वास्तविक सरणी (c) तब गणना की जाती है, जिसे हर बार लाल कहा जाता है। सरणी में मान तब सही स्थानांतरित किया जाता है और सही घटक प्राप्त करने के लिए आवश्यक के रूप में एंडेड किया जाता है।

मैं शायद कुछ और अक्षर (~ ५०) को परिभाषित कर सकता हूं ताकि परिभाषित के रूप में सरणी से अधिक पैटर्न ले सकें।

संपादित करें 1 - 48 से प्रत्येक मूल्य ऑफसेट के साथ चार सरणी के लिए डी सरणी को बदल दिया, जिसका अर्थ है कि मैं इसे कॉमा के भार को बचाने वाले स्ट्रिंग के रूप में प्रतिनिधित्व कर सकता हूं।

2 संपादित करें - परिभाषित विवरण में कार्यों का एक बड़ा हिस्सा लिया।

— स्कॉट लोगन
स्रोत
आप C का उपयोग क्यों नहीं करते? C में, यदि यह है तो एक डिक्लेरेशन से टाइप-नाम को हटाना संभव है int(ऐसा int f(int x,int y)हो जाता है f(x,y)।
— FUZxxl
@FUzxxl, हाँ C लगभग हमेशा C ++ से कम होगा, लेकिन मैं वास्तव में दिन के आधार पर C का उपयोग नहीं करता हूँ और वास्तव में यह सभी बारीकियों को नहीं जानता है जिनका उपयोग लंबाई को कम करने के लिए किया जा सकता है। मैं वैसे भी जीतने की कोशिश करके परेशान नहीं हूं, मैं बस किसी भी अन्य सी + + जवाब को हरा करने की कोशिश करता हूं।
— स्कॉट लोगन
3

जावास्क्रिप्ट, 696 694 वर्ण

696 -> 694 के लिए श्नाइडर का धन्यवाद।

मुझे एक अलग एन्कोडिंग प्रारूप मिला, जो अनिवार्य रूप से एक रंग देखने की मेज के साथ रन-लंबाई एन्कोडिंग है । यह काफी अच्छा काम करता है, क्योंकि इसमें 16 से कम रंग होते हैं और यह एक पंक्ति में 16 गुना कम होता है; इसलिए लंबाई सहित हर पिक्सेल परिभाषा एक बाइट में फिट होती है। मैंने बाइट के ऊंचे हिस्से में रंग डाला और निचले हिस्से में गिनती की।

अंत में, बेस 64 स्ट्रिंग मेरी अपेक्षा (472 वर्ण) की तुलना में अधिक लंबी हो गई, लेकिन डिकोडिंग कार्यक्रम वास्तव में कम है।

for(b=i=a=[];a&15||(a=atob("AxMrMyIzJxYlRDUiMwEmFSMBIUEBQzUBITMnEidGMwEjMyQBUhIi
SSkzIwFTEiFCAWNBAUEoASRVYhJCAUFhAWFBAUIhASIBIwFRAVEBVGISAUNjAUMnVgFTYlIBRxRaA1hF
UgJREVUBVHNYRV51VRNCAUICUwJRASV4UhICRFQBURQBI3oTUxJWFiMBIXEBcQFxUhNTGCEVJXVSE1MY
IhQldVIXARIzATEhEyQCInECUgEVARM1IgEjASaDUQITAREDNSUBNSKDcQWWAicBMWMxIoJSA5kBJgEh
MWMxIoJSApQBlIYiQjFjQSEBggFRAZIBkoshQwEyQ4JTloQBhQKBSAGBU5aHkYQBSIJTkTOShwGRhEIB
RYJTkTIBkWOGk0mCVDSRY5KCAYKSSINUMwGRYgOCATEDRAFBgwJTATSWgjWDAYEBglRjM5QBkgGBNYQC
glNkmAGRAZI0iFNjAQ==").charCodeAt(i++));b.push([0,16354410,4671418,6379596,77832
55,5295994,5390379,3435360,9975021,5131894][a-- >>4]));green=(red=function(c,d){
return b[32*d+c]>>this&255}).bind(16);blue=red.bind(8)

नोट: मैंने थोड़ी पठनीयता के लिए कोड को विभाजित किया है। इसे चलाने के लिए एक लाइन पर होना चाहिए।

टेस्ट कोड:

for(var y = 0; y < 32; ++y) {
    for(var x = 0; x < 32; ++x) {
        console.log(red(x, y), green(x, y), blue(x, y));
    }
}

मुझे लगता है कि उदाहरण परिणाम वास्तव में लाल, हरा, नीला (मूल परीक्षण कोड की तरह लाल, नीला, हरा नहीं) का उत्पादन है; यह मेरे लिए वैसे भी काम करता है।

— प्रतिलिपि
स्रोत
पैलेट ऐरे को बदलने की कोशिश करें [0,16354410,4671418,6379596,7783255,5295994,5390379,3435360,9975021,5131894]- यह 1 वर्ण बचाता है और RGB के बजाय GBR ऑर्डर है।
— श्नाडर
@schnaader धन्यवाद मुझे उन माइक्रो-ऑप्टिमाइज़ेशन से बहुत प्यार है :-) संपादित करें: इसने 2 वर्णों को भी बचाया क्योंकि मैंने अपने सौम्य स्रोत में दो बार नीले रंग का उपयोग किया था
— कॉपी करें
2

सी ++, 1357 वर्ण

int i,j,C[]={0,0,0,106,249,140,186,71,71,76,97,88,87,118,195,122,80,207,43,82,64,96,52,107,237,152,52,118,78,78},E[]={30,31,112,33,22,33,72,61,52,44,53,22,33,10,62,51,32,10,12,14,10,34,53,10,12,33,72,21,72,64,33,10,32,33,42,10,25,21,22,94,92,33,32,10,35,21,12,24,10,36,14,10,14,82,10,42,55,26,21,24,10,14,16,10,16,14,10,24,12,10,22,10,32,10,15,10,15,10,45,26,21,10,34,36,10,34,72,65,10,35,26,25,10,74,41,105,30,85,54,25,20,15,11,55,10,45,37,85,54,145,57,55,31,24,10,24,20,35,20,15,10,52,87,25,21,20,44,45,10,15,41,10,32,107,31,35,21,65,61,32,10,12,17,10,17,10,17,25,31,35,81,12,51,52,57,25,31,35,81,22,41,52,57,25,71,10,21,33,10,13,12,31,42,20,22,17,20,25,10,51,10,31,53,22,10,32,10,62,38,15,20,31,10,11,30,53,52,10,53,22,38,17,50,69,20,72,10,13,36,13,22,28,25,30,99,10,62,10,12,13,36,13,22,28,25,20,49,10,49,68,22,24,13,36,14,12,10,28,10,15,10,29,10,29,118,12,34,10,23,34,28,35,69,48,10,58,20,18,84,10,18,35,69,78,19,48,10,84,28,35,19,33,29,78,10,19,48,24,10,54,28,35,19,23,10,19,36,68,39,94,28,45,43,19,36,29,28,10,28,29,84,38,45,33,10,19,26,30,28,10,13,30,44,10,14,38,20,35,10,43,69,28,53,38,10,18,10,28,45,36,33,49,10,29,10,18,53,48,20,28,35,46,89,10,19,10,29,43,88,35,36,10};int*Q(int n){for(i=0;1;i++){for(j=0;j<E[i]/10;j++){if(!n)return&C[E[i]%10*3];n--;}}}
#define red(x,y) Q(x+32*y)[0]
#define blue(x,y) Q(x+32*y)[1]
#define green(x,y) Q(x+32*y)[2]

थोड़ा विचलित:

int C[]={0,0,0,106,249,140,186,71,71,76,97,88,87,118,195,122,80,207,43,82,64,96,52,107,237,152,52,118,78,78},
int E[]={30,31,112,33,22,33,72,61,52,44,53,22,33,10,62,51,32,10,12,14,10,34,53,10,12,33,72,21,72,64,33,10,32,33,42,10,25,21,22,94,92,33,32,10,35,21,12,24,10,36,14,10,14,82,10,42,55,26,21,24,10,14,16,10,16,14,10,24,12,10,22,10,32,10,15,10,15,10,45,26,21,10,34,36,10,34,72,65,10,35,26,25,10,74,41,105,30,85,54,25,20,15,11,55,10,45,37,85,54,145,57,55,31,24,10,24,20,35,20,15,10,52,87,25,21,20,44,45,10,15,41,10,32,107,31,35,21,65,61,32,10,12,17,10,17,10,17,25,31,35,81,12,51,52,57,25,31,35,81,22,41,52,57,25,71,10,21,33,10,13,12,31,42,20,22,17,20,25,10,51,10,31,53,22,10,32,10,62,38,15,20,31,10,11,30,53,52,10,53,22,38,17,50,69,20,72,10,13,36,13,22,28,25,30,99,10,62,10,12,13,36,13,22,28,25,20,49,10,49,68,22,24,13,36,14,12,10,28,10,15,10,29,10,29,118,12,34,10,23,34,28,35,69,48,10,58,20,18,84,10,18,35,69,78,19,48,10,84,28,35,19,33,29,78,10,19,48,24,10,54,28,35,19,23,10,19,36,68,39,94,28,45,43,19,36,29,28,10,28,29,84,38,45,33,10,19,26,30,28,10,13,30,44,10,14,38,20,35,10,43,69,28,53,38,10,18,10,28,45,36,33,49,10,29,10,18,53,48,20,28,35,46,89,10,19,10,29,43,88,35,36,10};
int*Q(int n){
  for(int i=0;1;i++){
    for(int j=0;j<E[i]/10;j++){
      if(!n)return&C[E[i]%10*3];
      n--;
    }
  }
}
#define red(x,y) Q(x+32*y)[0]
#define blue(x,y) Q(x+32*y)[1]
#define green(x,y) Q(x+32*y)[2]

Cछवि के दस अलग-अलग रंगों के लिए RGB मान हैं। Eचित्र के लिए डेटा शामिल है, जहां प्रत्येक तत्व E[i]एक दोहराने गिनती E[i]/10और एक रंग सूचकांक दोनों को एन्कोड करता है E[i]%10।

— कीथ रान्डेल
स्रोत
+1: आप कुछ पात्रों को लूप में बंद कर सकते हैं: pastebin.com/2UY8H2qt
— Pubby
1
यदि आप अपने समाधान को C (कोई कोड परिवर्तन आवश्यक नहीं) के रूप में पुनः परिभाषित करते हैं और परिभाषित के कार्यों को whithout int red(x,y){R Q(x+32*y)[0]}(only # नाम की तरह टाइप करते हैं return, तो आप अधिक वर्णों को दाढ़ी बनाने में सक्षम हो सकते हैं।
— दिसंबर को फ़ूजएक्सल
1
किसी तरह, यह धोखा है, क्योंकि लाल, नीले और हरे रंग कार्य नहीं करते हैं, लेकिन मैक्रोज़।
— फ़ूजएक्सल
1
यह एक फ़ंक्शन को लागू करता है और छोटा होता है (1339 बाइट्स)। कृपया ध्यान दें, कि यह कार्यक्रम संभवतः सादे पुराने सी में मान्य है: hpaste.org/65584
— FUZxxl
मैंने स्रोत से सभी प्रकार की जानकारी निकाल दी। यह अभी भी मान्य सी। है
— फ्युजेंकल
1

पायथन 3 (589 वर्ण)

import base64,zlib
red,blue,green=(lambda x,y,i=i:b'\xed\x984+R@j\xf9\x8cWv\xc3`4k\0\0\0\xbaGGzP\xcfvNNLaX'[zlib.decompress(base64.decodebytes(b'eJxtkgGSxSAIQxWN1vtfeEkEbf9sOmMdn0EEAZjZuFprxSCZpGlzrZUcL+5/jIbk+Phj0lr4MU58zEneUt8kiMlbQ63VwyfV0ZOq1cxxqyBvJJCRX3Cm5X7c+LJqQ63+j8N5kXkEIKeiXJl2jLP3/sPf6j257QSbwvmwy9ZD5ED6wd2GF+99J5WZ2S13h39aOetObrdO/A8f/3AdasbWrBEYnkVnzkhs0XpkA8YopUw9H/glEJw4ps49huuRgOzf8n6Iq85PCtneDxfhUCQ+F3JvdileT8FyxdfkCfhI+9yRCSAMlHxt+HLX3pd8+/0mh0MT9fPF8Xg6EeB52sc+WQlyxgA3XJycfi+D84X9GNCUKZ+E/JGjyqqbYJtZpo1ZhsN5ybJxPbXlluSlJMcf++8TIA=='))[32*y+x]*3+i]for i in(0,1,2))

टेस्ट कोड

for y in range(32):
    for x in range(32):
        print(red(x,y), blue(x,y), green(x,y))

डिलन कवर से समाधान के आधार पर

— AMK
स्रोत
1

PHP (5.4) - 822

मैंने ऐसा किया है जानबूझकर किसी भी अंतर्निहित संपीड़न कार्यों का उपयोग नहीं कर रहा है । यह समाधान समाप्त नहीं हुआ है, मुझे यकीन नहीं है कि अगर मैंने छोड़ दिया है, तो मैं सुधार के लिए क्षेत्रों को देख सकता हूं, लेकिन मैं इस समय / इच्छाशक्ति को पूरी बात को फिर से देखने के लिए नहीं पा सकता हूं, इसलिए मैं जो पोस्ट कर रहा हूं वह अब तक है।

822 बाइट्स के लिए हटाए जाने वाले न्यूलाइन्स + टिप्पणियां।

// Colour map
$c=[0,16354410,4671418,6379596,7783255,5295994,5390379,3435360,9975021,5131894];

// Optimised RLE map
$r=array_merge(array_diff(range(10,89),[27,40,47,56,59,60,63,66,67,70,73,75,76,77,79,80,83,86]),[92,94,99,105,107,112,118,145]);

// Image data (base 70)
$e="CDsF<Fd]WPX<F0^VE0240GX02Fd;d_F0EFN0?;<onFE0H;2>0I404h0NZ@;>0460640>20<0E05050Q@;0GI0Gd`0H@?0eMqCjY?:51Z0QJjYu[ZD>0>:H:50Wk?;:PQ05M0ErDH;`]E0270707?DHg2VW[?DHg<MW[?c0;F032DN:<7:?0V0DX<0E0^K5:D01CXW0X<K7Ub:d03I3<A?Cp0^023I3<A?:T0Ta<>3I420A050B0Bt2G0=GAHbS0\:8i08Hbf9S0iAH9FBf09S>0YAH9=09IaLoAQO9IBA0ABiKQF09@CA03CP04K:H0ObAXK080AQIFT0B08XS:AHRm090BOlHI0";

// Expand image data
for($i=0;$i<352;$i++){$b=$r[ord($e[$i])-48];$l=(int)($b/10);while($l--)$d[]=$c[$b%10];}

// Colour retrieval functions
function red($x,$y){global$d;return$d[$x+$y*32]&0xff;}
function green($x,$y){global$d;return$d[$x+$y*32]>>8;}
function blue($x,$y){global$d;return($d[$x+$y*32]>>8)&0xff;}

टेस्ट ठूंठ:

for ($y=0;$y<32;$y++) {
    for ($x=0;$x<32;$x++) {
        printf("%d %d %d\n", red($x, $y), blue($x, $y), green($x, $y));
    }
}

छवि डेटा का संपीड़न स्वयं बहुत अच्छा है, लेकिन आरजीबी मूल्यों को पुनः प्राप्त करने के लिए कार्य कोड का 1/4 हिस्सा लेते हैं।

मैं एक कस्टम base70 + रन लंबाई एन्कोडिंग तंत्र का उपयोग कर रहा हूं।

  1. 10 अनूठे रंग हैं
  2. रंगों की लंबाई 1 और 14 (12 उपयोग की गई) के बीच होती है।
  3. 120 संभावित संयोजन हैं।
  4. वास्तव में उपयोग किए जाने वाले केवल 70 अद्वितीय रन / रंग संयोजन हैं।

एन्कोडेड इमेज डेटा एक RLE के एरे इंडेक्स को संदर्भित करता है, जो बदले में रंगों के एरे को इंडेक्स करता है। मुझे यकीन नहीं है कि रंगों को सीधे संदर्भित करने पर यह कितना उपरि जोड़ता है या घटता है।

साइन 10 रंग हैं (0 से 9), आरएलई के रूप में संग्रहीत किया जाता है run_length * 10 + colour_index। रंग क्रम के आधार पर अनुकूलन के साथ प्रयोग किए बिना 10 और 145 के बीच एनकोडिंग की एक सीमा देना। (यानी मैं 0 से 5, 5 से 9, और 9 से 0 तक के रंगों को घुमाकर 19 से 140 कर सकता हूं - लेकिन इसके अन्य असर हो सकते हैं)

पिछला उत्तर बताता है कि उनका एन्कोडेड डेटा 472 बाइट्स है। मेरा एन्कोडेड इमेज डेटा 352 बाइट्स है, लेकिन मध्यवर्ती RLE / कलर मैप (जो बाइनरी एनकोडेड नहीं है) एक और 129 बाइट्स है, जो कुल 481 पर डाल रहा है। (साथ ही दोनों को जोड़ने के लिए अतिरिक्त ओवरहेड)। हालाँकि मुझे संदेह है कि मेरा तरीका बड़ी छवियों के लिए बेहतर हो सकता है।

करने के लिए:

  1. RLE मैप की बाइनरी एन्कोडिंग की जाँच करें
  2. कार्यों के आकार को कम करने का एक तरीका खोजें। globalएक कुतिया है, लेकिन स्थिरांक पर वर्ण अनुक्रमणिका तक नहीं पहुंच सकती है।
  3. कलर इंडेक्स ऑर्डरिंग के साथ प्रयोग यह देखने के लिए कि क्या RLE मैप का आकार संख्याओं के अधिक अनुक्रमिक रन के साथ कम किया जा सकता है
  4. रंग मानचित्र के संभावित 64 बिट विशिष्ट अनुकूलन? (r0 << 56 | r1 << 48 | ...) |
  5. ऊर्ध्वाधर RLE के साथ प्रयोग करके देखें कि क्या यह एन्कोडिंग के अधिक कॉम्पैक्ट सेट में परिणत होता है।
  6. क्षेत्र एन्कोडिंग?
— लेह
स्रोत
1

सी (जीसीसी) , 602 बाइट्स

P[]={0,6982905,0xba4747,5003361,5751670,8048464,2834514,6318900,0xed3498,7753294},X[1024],*i,r,w;
#define u(d)i=X;for(char*I="56s-8-8_TKCL-8!UJ7!#%!9L!#8_,_W8!78A!0,-us87!:,#/!;%!%i!AN1,/!%'!'%!/#!-!7!&!&!D1,!9;!9_X!:10!a@v&5lM0+&\"N!D<lMvNPN6/!/+:+&!Kn0,+CD!&@!7x(6:,XT7!#(!(!(06:h#JKP06:h-@KP0^!,8!$#6A+-(+0!J!6L-!7!U=&+6!\"5LK!L-=(I\\+_!$;$-305z!U!#$;$-30+H!H[-/$;%#!3!&!4!4y3#9!.93:\\G!Q+)k!):\\e*G!k3:*84e!*G/!M3:*.!*;[>u3DB*;43!34k=D8!*153!$5C!%=+:!B\\3L=!)!3D;8H!4!)LG+3:Ep!*!4Bo:;!";w=*I-33,*I++;)for(r=w/10+1;r--;*i++=P[w%10]>>d&255);x=X[y*32+x];
red(x,y){u(16)}green(x,y){u(8)}blue(x,y){u(0)}

इसे ऑनलाइन आज़माएं!

मंद होना

P[]={...},              The palette. Each entry is an integer on the form `RRGGBB`.
X[1024],                The buffer we unpack things into.
*i,r,w;                 Misc variables.
#define u(d)            Macro taking the number of bits to shift palette entries.
i=X;for(char*I="...";   Start at beginning of X for output, I is the encoded data.
                        Data was packed as ((R - 1) * 10) + P + 33, with R being
                        run-length and P the palette entry.
w=*I-33,*I++;)          Pick up encoded char, and check for end of data.
for(r=w/10+1;r--;       Get run-length from encoded byte.
*i++=P[w%10]>>d&255);   Get palette entry and extract colour given by d to store in X.
x=X[y*32+x];            Implicit return of the value at given coordinates.
red(x,y){u(16)}         The specific functions for each channel, calling u() for the
green(x,y){u(8)}        real work.
blue(x,y){u(0)}
— gastropner
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.