在源内编码图像

10

高尔夫挑战是在源文件中编码和压缩以下图像。

图片

为此，您需要编写3个函数：red，green和blue，它们接受图像的x / y坐标并返回0-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 ++编写的，但是我删除了这些限制。话虽如此，我仍然建议您使用它们。

code-golf  kolmogorov-complexity  graphical-output 
— 普比
source
4
如果没有特定原因，强烈建议不要将问题固定为特定语言。为什么一定不能使用其他语言的原因是什么？
— FUZxxl 2012年
3
如果解决方案不太有趣，请不要投票。通过独占语言来禁止“ lam回”解决方案是过大的。
— FUZxxl 2012年
2
如果您已经将字符集限制为ASCII（我认为绝对可以），那么我们如何使用Unicode hacks？对于base 64，您可以在标准C以及任何其他语言中执行此操作，它仅使用不同数量的包装器代码。-但我喜欢这项任务。
— 于
1
嗯，ASCII控制字符0-31（和127）呢？从技术上讲，它们是ASCII的一部分，但是可以使用吗？如果不是，我希望至少对LF字符（10），也许还有CR（13）和TAB（9）有所例外？
— Ilmari Karonen 2012年
1
嗯...所以，从字面上看您的新版本，所有解决方案都必须在一行上，因为不允许使用未经转义的换行符。那真的是你想要的吗？
— Ilmari Karonen 2012年

Answers:

6

C，796 754 712 703 692 685 682 670 666 662 656 648个字符

变更日志：

  • 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现在是（32,16,8,4,2,1,0），而不是（5,4,3,2,1,0）。DC，Gotcha;）
  • 682-> 670：拆分p[]并h[]转换h[]为char*-awwww，里面有只昏昏欲睡的小猫^<+_=>-
  • 670-> 666：while=> for，l=l*2+...=>l+=l+...
  • 666-> 662：m=m>9?...=>c[n++]=m>9?...
  • 662-> 656：中的位顺序b[]相反，因此我们可以映射到64-127而不是0-63，并且不再需要位索引k。谢谢@Piotr Tarsa。用替换?:（GCC扩展名）||。谢谢@JamesB
  • 656-> 648：谢尔文（Shelwien）的无耻复制:)（的多字符常量p[]）

使用霍夫曼编码将图像转换为类似Base64的字符串（ASCII 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;}

从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;}
— 施纳德
source
非常好，不能相信我没有考虑过使用base64。不过，我认为您仍然可以保存很多字符，尤其是在该循环中。在VS2008顺便说一句工作正常。
— 斯科特·洛根
我认为您可以int从参数列表中删除，以删除更多字节。
— FUZxxl 2012年
怎么样m=m>9?c[n-1]:m;的if(m>9)m=c[n-1];？
— FUZxxl 2012年
并且：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 2012年
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]

由于此挑战现已向所有人开放，为什么不呢！这是熟悉的zlib-> base64编码路径，为此我深表歉意。希望具有一些独创性的条目会更短！

这是一个类似于原始内容的测试代码段：

for y in range(32):
    for x in range(32):
        print red(x,y), blue(x,y), green(x,y)
— 狄龙·考尔（Dillon Cower）
source
您也应该尝试添加特殊颜色以重复之前的像素值。588个字符的base64远比我的答案中的字符串（365个字符）大得多，尽管zLib在这里过分杀人，但它应该给出类似的结果，因此这种方式总计应大约500个字符。
— schnaader 2012年
4

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

SO以某种方式吃掉了7F代码，所以我不得不将其更新为base = 95

— 谢尔文
source
3

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，表示colout t [0]出现在下一个3每次调用红色时都会计算实际的像素数组（c），然后将数组中的值右移并根据需要进行“与”运算以获取正确的分量。

通过从数组中定义出更多的模式，我大概可以节省更多的字符（〜50）。

编辑1-将char数组的d数组更改为每个值都偏移48，这意味着我可以将其表示为节省大量逗号的字符串。

编辑2-在define语句中使用了大部分功能。

— 斯科特·洛根（Scott Logan）
source
为什么不使用C？在C中，有可能从一个declaratrion移除类型名称，如果它是int（这样int f(int x,int y)成为f(x,y)。
— FUZxxl
@FUzxxl，是的，C几乎总是比C ++短，但是我并不是每天都真正使用C，也不真正知道可以用来减少长度的所有细微差别。无论如何我都不会为赢得胜利而烦恼，我只是想击败任何其他C ++答案。
— 斯科特·洛根
3

Javascript，696694个字符

感谢schnaader的696-> 694。

我想出了一种不同的编码格式，本质上是带有颜色查找表的行程编码。它的效果非常好，因为少于16种颜色并且它们连续出现少于16次。因此每个像素定义（包括长度）都适合一个字节。我将颜色放在字节的高位部分，将计数放在低位部分。

最后，结果证明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));
    }
}

我认为示例结果实际上是红色，绿色，蓝色的输出（而不是原始测试代码中的红色，蓝色，绿色）；反正它对我也一样。

— 复制
source
尝试将调色板数组更改为[0,16354410,4671418,6379596,7783255,5295994,5390379,3435360,9975021,5131894]-这样可以节省1个字符，并且是GBR顺序而不是RGB。
— schnaader 2012年
@schnaader谢谢。我喜欢这些微优化：-)编辑：它甚至节省了2个字符，因为我在原始来源中两次使用了蓝色
— 复制
2

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包含图像的十种不同颜色的RGB值。 E包含图片数据，其中每个元素都E[i]编码重复计数E[i]/10和颜色索引E[i]%10。

— 基思·兰德尔
source
+1您可以在循环中
— 删除
1
如果将解决方案重命名为C（无需更改代码）并将定义变成没有类型名称（如int red(x,y){R Q(x+32*y)[0]}(only ＃define` return）的函数，则可能可以剃除更多字符。
— FUZxxl 2012年
1
不知何故，这是作弊的，因为红色，蓝色和绿色不是功能而是宏。
— FUZxxl 2012年
1
这实现了一个功能并且更短（1339字节）。请注意，该程序可能仅在普通的旧C语言中有效：hpaste.org/65584
— FUZxxl 2012年
我从源代码中删除了所有类型信息。它仍然有效C.
— FUZxxl 2012年
1

Python 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的解决方案

— AMK
source
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));
    }
}

图像数据本身的压缩效果很好，但是用于检索RGB值的功能占用了代码的1/4。

我正在使用自定义的base70 +运行长度编码机制。

  1. 有10种独特的颜色
  2. 颜色的游程长度在1到14之间（使用了12种）。
  3. 有120种可能的组合。
  4. 实际仅使用70种独特的运行/颜色组合。

编码的图像数据引用RLE的数组索引，而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是个bit子，但无法访问常量上的字符索引。
  3. 使用颜色索引排序进行试验，以查看是否可以通过较长的数字顺序运行来减小RLE映射大小
  4. 潜在的64位色彩优化图？（r0 << 56 | r1 << 48 | ...）？
  5. 使用垂直RLE进行试验，以查看它是否可以产生更紧凑的编码集。
  6. 区域编码？
— 利
source
1

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)}
— 腹肌
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.