골프 과제는 다음 이미지를 소스 파일로 인코딩하고 압축하는 것입니다.

이를 위해서는 3 개 함수를 작성해야 red, green그리고 blue되는 이미지의 X / Y 좌표를 적용하고 255의 대응 R / G / B의 화소 값을 반환한다.

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'등)
• 모든 것이 소스 내부에 포함되어 있어야합니다-파일로드 없음
• 출력은 예제 출력과 일치해야합니다. 이것은 무손실 압축을 의미합니다.

언어 :

이 문제는 C / C ++를 염두에두고 작성되었지만 이러한 제한을 제거하고 있습니다. 그렇게 말하면서도 여전히 사용하는 것이 좋습니다.

C, 79675471270368928585670670666662656648 문자

변경 로그:

• 754-> 712 : 추가 return받는 #define대체 if와 ?제거 제표 (감사 @FUZxxl) int목록 매개 변수 기능에서.
• 712-> 703 : bunnit에서 뻔뻔한 사본 :) 전체 이미지 생성을 #define
• 703-> 692 : 병합 p[]및 h[]일부 추가 ?:개선
• 692-> 685은 : 증가 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)입니다. Gotcha, DC;)
• 682-> 670 : 분할 p[]하고 h[], 변환 h[]A와 char*- 아 ...., 그 안에 졸린 키티있다^<+_=>-
• 670-> 666 : while=> for, l=l*2+...=>l+=l+...
• 666-> 662 : m=m>9?...=>c[n++]=m>9?...
• 662-> 656 :에서 비트 순서를 반대로 b[]하여 0-63 대신 64-127로 매핑 할 수 있으며 k더 이상 비트 인덱스가 필요하지 않습니다 . 감사합니다 @Piotr Tarsa . ?:(GCC 확장자)가 (으) 로 대체 되었습니다 ||. 감사합니다 @JamesB
• 656-> 648 : Shelwien의 뻔뻔한 사본 :) (에 대한 다중 문자 상수 p[])

허프만 코딩을 사용하여 3-6 비트를 사용하여 색상 0-9를 인코딩하고 1 비트 만 사용하는 특수 색상 10 (픽셀은 이전 색상과 동일)을 사용하여 이미지를 Base64와 유사한 문자열 (ASCII 37-100)로 변환합니다.

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

bunnit의 대답에서 두 가지를 복사의 #define전체 이미지가 완전히 때마다 디코딩되고 red/ green/ blue라고합니다. 추가 개선의 여지가 있으므로 업데이트를 기대하십시오. :) 코드 준수에 대해 확신하지 못하고 GCC 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;}

파이썬 ( 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]

이 도전은 이제 모두에게 열려 있기 때문에 왜 안 되겠습니까! 익숙한 zlib-> base64 인코딩 경로이므로 이에 대해 사과드립니다. 바라건대 독창적 인 항목이 더 짧을 것입니다!

다음은 원본과 유사한 테스트 스 니펫입니다.

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

C ++, 631 자; C-613

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

base-95 데이터와 산술 코딩 + 적응 통계 모델이 포함 된 항목 만 포함합니다.
schnaader의 코드는 데이터에 ~ 438 개의 문자를 사용하며 318 개 (마스킹없이 311 개) 만 사용합니다.
그러나 예상대로 산술 코딩은 이와 같은 작은 샘플에는 너무 복잡합니다.

(이것은 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)

테스트 (이전 base-96 버전부터) :
http://codepad.org/qrwuV3Oy
http://ideone.com/ATngC

어떻게 든 7F 코드를 먹으므로 base = 95로 업데이트해야했습니다.

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

가능한 모든 색상을 단일 정수로 저장하는 배열 z를 생성했습니다 (r << 16 | g << 8 | b). {amount, value}를 저장하는 배열 d를 만들었습니다. 값은 배열 z의 위치이며, 그 양은 해당 값을 가진 연속 픽셀 수입니다 (예 : 3,0, 콜 아웃 t [0]은 다음 3 그런 다음 실제 픽셀 배열 (c)은 빨간색이 호출 될 때마다 계산 된 다음 배열의 값이 오른쪽으로 이동되고 올바른 구성 요소를 얻는 데 필요한만큼 AND됩니다.

정의 된대로 배열에서 더 많은 패턴을 가져 와서 더 많은 문자 (~ 50)를 절약 할 수 있습니다.

편집 1- 각 값 오프셋이 48 인 char 배열의 d 배열을 변경 했으므로 쉼표로드를 저장하는 문자열로 나타낼 수 있습니다.

편집 2 -define 문에서 더 많은 기능을 사용했습니다.

자바 스크립트, 696 694 자

696-> 694의 schnaader에게 감사합니다.

다른 인코딩 형식을 찾았습니다. 기본적 으로 색상 조회 테이블을 사용하는 Run-length 인코딩 입니다. 16 개 미만의 색상이 있고 연속으로 16 배 미만으로 작기 때문에 아주 잘 작동합니다. 따라서 길이를 포함한 모든 픽셀 정의는 1 바이트에 맞습니다. 나는 바이트의 높은 부분에 색상을 넣고 낮은 부분에 카운트를 넣습니다.

결국 base64 문자열은 예상보다 길었던 것으로 나타 났지만 (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));
    }
}

예제 결과는 실제로 빨간색, 녹색, 파란색의 출력이라고 생각합니다 (원래 테스트 코드에서와 같이 빨간색, 파란색, 녹색이 아님). 어쨌든 그것은 나를 위해 작동합니다.

C ++, 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이미지의 10 가지 색상에 대한 RGB 값을 포함합니다. E그림의 데이터를 포함합니다. 여기서 각 요소 E[i]는 반복 횟수 E[i]/10와 색상 인덱스를 모두 인코딩합니다 E[i]%10.

파이썬 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))

Dillon Cower의 솔루션을 기반으로

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

이미지 데이터 자체의 압축은 꽤 좋지만 RGB 값을 검색하는 기능은 코드의 1/4을 차지합니다.

사용자 정의 base70 + 실행 길이 인코딩 메커니즘을 사용하고 있습니다.

1. 10 가지 독특한 색상이 있습니다
2. 색상의 길이는 1에서 14 사이입니다 (12 사용).
3. 가능한 조합은 120 가지입니다.
4. 실제로 사용 된 70 가지의 고유 한 런 / 컬러 조합이 있습니다.

인코딩 된 이미지 데이터는 RLE의 배열 인덱스를 참조하여 색상 배열을 인덱스합니다. 이것이 색상을 직접 참조하는 것보다 얼마나 많은 오버 헤드가 추가되거나 제거되는지 확실하지 않습니다.

사인은 10 가지 색상 (0 ~ 9)이 있으며 RLE은로 저장됩니다 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. 지역 인코딩?

C (gcc) , 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)}