编写一个程序，接受一个字符串或文本文件，其第一行的格式为

width height

然后每行的格式为

x y intensity red green blue

哪里：

• width并且height可以是任何正整数。
• x并且y可以是任何整数。
• intensity 可以是任何非负整数。
• red，green和blue可以是0到255之间的任何整数（包括0和255）。

你的程序必须输出真彩在它的尺寸为任何常见的无损图像文件格式的图像width通过height。每条x y intensity red green blue线代表必须在图像上绘制的彩色星星或球体。可能有任何数量的星形要绘制，包括0。您可以假定字符串或文件末尾有换行符。

绘制图像的算法如下，但是只要结果相同，您可以按照自己喜欢的任何方式实现它：

对于图像中的每个像素（X，Y）（其中X在最左边缘为0，在最右边缘为width-1，Y在顶部边缘为0，在底部边缘height-1），颜色通道C ϵ { 红色， 绿色，蓝色 }（固定在0到255之间的值）由以下公式给出：

其中dist函数为欧几里得距离：

或曼哈顿距离：

根据高尔夫球性或美观性，选择您喜欢的距离功能。

输入中除第一行外的每一行都是“ 星星”集的元素。因此，例如，S _X表示x对输入线中的一个值，和S _Ç表示任一red，green或blue，这取决于当前正在计算色彩通道。

例子

例子A

如果输入是

400 150
-10 30 100 255 128 0

输出应该是

如果您使用的是欧几里德距离，并且

如果您使用的是曼哈顿距离。

例子B

如果输入是

200 200
100 100 10 255 255 255
20 20 40 255 0 0
180 20 40 255 255 0
180 180 40 0 255 0
20 180 40 0 0 255

欧几里得距离和曼哈顿距离的相应输出应为

和。

范例C

如果输入是

400 400
123 231 10 206 119 85
358 316 27 170 47 99
95 317 3 202 42 78
251 269 17 142 150 153
43 120 3 145 75 61
109 376 6 230 231 52
331 78 21 31 81 126
150 330 21 8 142 23
69 155 11 142 251 199
218 335 7 183 248 241
204 237 13 112 253 34
342 89 18 140 11 123

输出应该是

如果您使用的是欧几里德距离，并且

如果您使用的是曼哈顿距离。

例子D

如果输入是

400 400
123 231 5 206 119 85
358 316 5 170 47 99
95 317 5 202 42 78
251 269 5 142 150 153
43 120 5 145 75 61
109 376 5 230 231 52
331 78 5 31 81 126
150 330 5 8 142 23
69 155 5 142 251 199
218 335 5 183 248 241
204 237 5 112 253 34
342 89 5 140 11 123

输出应该是

如果您使用的是欧几里德距离，并且

如果您使用的是曼哈顿距离。

例E

如果输入是

100 1

那么输出应为100像素宽乘1像素高的全黑图像。

笔记

• 从stdin或命令行获取输入字符串或包含该字符串的文本文件的名称，或者可以编写一个包含字符串的函数。
• “输出”图像意味着：
  • 用您选择的名称将其保存到文件中。
  • 将原始图像文件数据打印到stdout。
  • 显示图像，例如使用PIL的image.show()。
• 我不会检查您的图像是否是像素完美的（无论如何，Stack Exchange都会有损压缩图像），但是如果我能从视觉上分辨出任何区别，我将非常怀疑。
• 您可以使用图形/图像库。

获奖

以字节为单位的最短提交获胜。如果有平局，则最早提交者获胜。

有趣的奖金：提供输入以获得真正壮观的输出图像。

Pyth-46个字节

真有趣！我终于使用了Pyth的图像I / O功能。尽管高尔夫运动只是短暂的改变，但由于高尔夫运动的原因，欧氏距离是否很大。

Krz7.wcmmsm/*@b+3k@b2h.a,<b2_.DdhKrR7.zU3*FKhK

尽管divmodPyth仅支持3个嵌套贴图，并且计算需要两个（RGB用于一个，星形用于一个），但这仅用公式将所有像素循环成一个循环并使用。

将图像另存为o.png。相当慢，在不到2分钟的时间内进行了前2个测试，而其他2个测试则耗时半小时。

有一个错误，.w就是没有人注意到它，因为没有人使用它；）但是我提出了一个pull请求，所以请使用我的fork来测试是否很快就合并了。合并！

示例输出

例子A

例子B

范例C

例子D

JavaScript的394 344

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

编辑：通过应用Wolfhammer的出色建议，大大缩短了代码。

测试

注意：请等待几秒钟，以渲染以下代码段（在我的计算机上大约需要4秒钟）。

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

var start = Date.now();

X("400 150\n" +
  "-10 30 100 255 128 0");

X("200 200\n" +
  "100 100 10 255 255 255\n" +
  "20 20 40 255 0 0\n" +
  "180 20 40 255 255 0\n" +
  "180 180 40 0 255 0\n" +
  "20 180 40 0 0 255");

X("400 400\n" +
  "123 231 10 206 119 85\n" +
  "358 316 27 170 47 99\n" +
  "95 317 3 202 42 78\n" +
  "251 269 17 142 150 153\n" +
  "43 120 3 145 75 61\n" +
  "109 376 6 230 231 52\n" +
  "331 78 21 31 81 126\n" +
  "150 330 21 8 142 23\n" +
  "69 155 11 142 251 199\n" +
  "218 335 7 183 248 241\n" +
  "204 237 13 112 253 34\n" +
  "342 89 18 140 11 123");

X("400 400\n" +
  "123 231 5 206 119 85\n" +
  "358 316 5 170 47 99\n" +
  "95 317 5 202 42 78\n" +
  "251 269 5 142 150 153\n" +
  "43 120 5 145 75 61\n" +
  "109 376 5 230 231 52\n" +
  "331 78 5 31 81 126\n" +
  "150 330 5 8 142 23\n" +
  "69 155 5 142 251 199\n" +
  "218 335 5 183 248 241\n" +
  "204 237 5 112 253 34\n" +
  "342 89 5 140 11 123");

var end = Date.now();

console.log('Done in ' + (end - start)/1000 + 's.');

canvas {
  display: block;
  padding: 10px;
}

您也可以在JSFiddle中运行它。

奖励：蓝色蚀

function X(a){for(l=a.match(/\d+/g),h=document,v=h.body.appendChild(h.createElement("canvas")),v.width=W=l[0],v.height=H=l[1],w=v.getContext("2d"),e=w.createImageData(W,H),d=e.data,N=W*H;N--;)for(i=2,c=N*4,d[c+3]=255;i<l.length;)for(x=N%W-l[i++],y=~~(N/W)-l[i++],k=l[i++],q=0;q<3;)d[c+q++]+=k*l[i++]/-~Math.sqrt(x*x+y*y);w.putImageData(e,0,0);}

var j = 0;
var renderFrame = function () {
  if(window.h && window.v){h.body.removeChild(v);} // clear prev frame
  X("225 150\n" +
    (70 + j) + " " + (120 - j) + " 170 135 56 0\n" + 
    j * 5 + " " + j * 3 + " 64 0 50 205");       
  if(++j < 50) { setTimeout(renderFrame, 1); } else { console.log('done!'); }
};
setTimeout(renderFrame, 10);

您也可以在JSFiddle中运行它。

描述

这是一个简单的JavaScript + HTML5 canvas实现：该函数接受一个字符串参数（不带尾随空格/换行符）并在DOM中显示输出。它使用欧几里得距离。

这是可读的代码：

X = function (str) {
  var lines = str.split("\n");  
  var canvas = document.createElement('canvas');
  var z = lines[0].split(u=' ');
  var width = z[0], height = z[1];

  canvas.width = width;
  canvas.height = height;
  document.body.appendChild(canvas);

  var ctx = canvas.getContext("2d");
  var imageData = ctx.createImageData(width, height);

  for(var y = 0; y < height; y++){
    for(var x=0; x < width; x++){
      var coord = (y * width + x) * 4;

      for(i=1; i < lines.length;i++){
        var t = lines[i].split(u);

        var 
          dx = x - t[0], 
          dy = y - t[1];

        var distance = Math.sqrt(dx * dx + dy * dy);

        for(var channel = 0; channel < 3; channel++) {
          var channelIndex = coord + channel;
          imageData.data[channelIndex] += t[2] * t[3 + channel] / (distance + 1);
        }
      }

      var alphaIndex = coord + 3;
      imageData.data[alphaIndex] = 255;
    }
  }

  ctx.putImageData(imageData, 0, 0);
};

Java-627字节

Java确实是最好的高尔夫语言之一：）

import java.awt.image.*;class M{void f(String n)throws Exception{String[]p=n.split("\n");int[]b=s(p[0]);BufferedImage o=new BufferedImage(b[0],b[1],2);for(int i=0;i<b[0];i++)for(int j=0;j<b[1];j++){int[]c=new int[3];for(int l=1;l<p.length;l++){int[]r=s(p[l]);for(int k=0;k<3;k++){c[k]+=r[2]*r[3+k]/(Math.sqrt(Math.pow(i-r[0],2)+Math.pow(j-r[1],2))+1);if(c[k]>255)c[k]=255;}}o.setRGB(i,j,new java.awt.Color(c[0],c[1],c[2]).getRGB());}javax.imageio.ImageIO.write(o,"png",new java.io.File("o.png"));}int[]s(String s){String[]a=s.split(" ");int[]r=new int[a.length];for(int i=0;i<a.length;i++)r[i]=Integer.valueOf(a[i]);return r;}}

使用下面的输入，您可以创建一个有点逼真的太阳系模型（某些行星的大小是错误的，但是它们之间的距离应该准确）。我试图给土星戒指，但没有成功... 来源

1950年50
-15 25 25 255 255 0
39 25 1 255 0 0
55 25 3 255 140 0
68 25 4 0 191 255
92 25 2 255 0 0
269 25 10245222179
475 25 7 245 245 220
942 25 6 0 250150
1464 25 6 0 0 255
1920 25 1255245238

全高清图片，看起来效果不佳...如果有人可以改善它，将非常高兴！

Bash，147145字节

ImageMagick用于处理图像。使用欧几里得距离。

read w h
o=o.png
convert -size $w\x$h canvas:black $o
while read x y i r g b
do
convert $o -fx "u+$i*rgb($r,$g,$b)/(hypot(i-$x,j-$y)+1)" $o
done

Python 3，189个字节

我没有一个专业高尔夫球手的主意，但这是可行的。

• 输入来自stdin并且去stdout在PPM格式。
• 像这样运行它： python3 codegolf_stars_golfed.py < starfield.txt > starfield.pnm

一，曼哈顿距离：

import sys
(w,h),*S=[list(map(int,l.split()))for l in sys.stdin]
print('P3',w,h,255,*(min(int(sum((I*C[z%3]/(abs(X-z//3%h)+abs(Y-z//3//h)+1))for
X,Y,I,*C in S)),255)for z in range(h*w*3)))

其次，欧几里得距离：

import sys
(w,h),*S=[list(map(int,l.split()))for l in sys.stdin]
print('P3',w,h,255,*(min(int(sum((I*C[z%3]/(abs(X-z//3%h+(Y-z//3//h)*1j)+1))for
X,Y,I,*C in S)),255)for z in range(h*w*3)))

我可以使用整数除法来代替，以节省四个字节int()，实际上，这似乎就是原始图像所做的工作-您几乎无法分辨出星光中暗条纹中的某些条纹，而这些条纹并不是严格正确的码。就目前情况而言，此代码遵循说明而不是图像。

该ungolfed版本，和我的许多的优化，其他人指出，或者说，我偶然发现了自己原来之前打高尔夫球，在这个要点。

编辑：通过移动for x并for y进入一个print（或o）函数，我节省了7个字节，但是这会生成带有很长一行的PNM文件，这可能会或可能不会引起一些问题。

编辑2：马尔蒂森为我节省了另外20个字节。谢谢！

再次编辑：现在只有一个print，o别名是负债，而不是储蓄。关闭4个字节。

编辑更多： Sp3000为我节省了2个字节。同时，混叠map到m不可读性（！）的利益节约任何东西，所以我又扩大了。现在是一个不错的2 ⁸个字节的回合。

编辑last（？）：现在有了欧几里得距离支持-并且通过滥用复数，我用完全相同的字节数来完成它！

编辑，好莱坞重新启动： Sp3000的下一个建议取消了5个字节。

编辑，愚蠢地命名为续集：减少了 6个字节，这是由于Maltysen提出的一个建议，直到Sp3000重复它，我才掌握了这一点……然后又从滥用中获得了 8个字节%。并在聊天中说出了惊人的效果2126个字节 我很谦虚

C ++，272字节

#include<png.hpp>
#define G(a)i>>C;for(x=0;x<w*h;++x){auto&p=img[x%h][x/h];c=p.a+I*C/(abs(x/h-X)+abs(x%h-Y)+1);p.a=c>255?255:c;}
auto&i=std::cin;main(){int w,h,x,X,Y,I,c,C;i>>w>>h;png::image<png::rgb_pixel>img(w,h);while(i>>X>>Y>>I){G(red)G(green)G(blue)}img.write("a");}

需要一个宽松的C ++ 11编译器（对GCC 4.9.2的要求不高）和png ++库，后者本身就需要libpng。使用的曼哈顿距离。在上输入stdin，以PNG格式输出到当前目录中名为“ a”的文件。

范例D：

Python 2中，240个 232 228字节

from PIL.Image import*
def f(S):
 L=map(int,S.split());t=a,b=L[:2];I=new("RGB",t)
 for k in range(a*b):I.load()[k/a,k%a]=tuple(sum(x[2]*x[c]/(abs(x[0]-k/a)-~abs(x[1]-k%a))for x in zip(*[iter(L[2:])]*6))for c in(3,4,5))
 I.show()

使用曼哈顿距离。在Python 3中，这可能会更短一些，但是最近我弄乱了我的Python包，并且在重新安装Pillow时遇到了麻烦。PPM可能会更短，但是我喜欢PIL。

为了好玩，我尝试按原样在L * a * b *颜色空间中应用该算法，以为它可以提供更好的颜色混合效果（尤其是在示例B中）。不幸的是，卡尔文（Calvin）的算法允许通道超过其最大值，这使得图像看起来比我希望的要差一些。

Mathematica，146个字节

Image@Table[Total[#3{##4}/255&@@@{##2}/(1+#~ManhattanDistance~{x,y}&/@({#1,#2}&@@@{##2}))],{y,0,Last@#-1},{x,0,#&@@#-1}]&@@#~ImportString~"Table"&

接受字符串的纯函数。要在合理的时间内运行它，请将1in 替换1+#~ManhattanDistance...为1.;。这将强制进行数字计算而不是符号计算。

取消高尔夫：

Image[
    Table[
        Total[
        (#3 * {##4} / 255 & @@@ {##2})
            / (1 + ManhattanDistance[#, {x, y}]& /@ ({#1, #2}& @@@ {##2}) )
        ], {y, 0, Last[#]-1}, {x, 0, First[#]-1}
    ] (* Header is #, data is {##2} *)
]& @@ ImportString[#, "Table"]&

Python 2中，287个 251字节

我用来生成图像的原始代码的高尔夫球版本。可能会打更多的高尔夫球（比我更好的高尔夫球手）。这个函数接受完整的输入字符串。用PIL的图像模块完成图像处理。使用曼哈顿距离。

from PIL import Image
def S(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1.+abs(I[i]-z%w)+abs(I[i+1]-z/w))for i in r(2,len(I),6)))for j in r(3))
 M.show()

使用欧几里得距离要长5个字节（256个字节）：

from PIL import Image
def O(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1+((I[i]-z%w)**2+(I[i+1]-z/w)**2)**.5)for i in r(2,len(I),6)))for j in r(3))
 M.show()

这是一个完整的测试套件，它针对两个距离指标运行问题中的示例A至E：

from PIL import Image
def S(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1.+abs(I[i]-z%w)+abs(I[i+1]-z/w))for i in r(2,len(I),6)))for j in r(3))
 M.show()

def O(I,r=range):
 I=map(int,I.split());w,h=I[:2];M=Image.new('RGB',(w,h));P=M.load()
 for z in r(w*h):
  P[z%w,z/w]=tuple(int(sum(I[i+2]*I[i+j+3]/(1+((I[i]-z%w)**2+(I[i+1]-z/w)**2)**.5)for i in r(2,len(I),6)))for j in r(3))
 M.show()

A = """400 150
-10 30 100 255 128 0"""
B = """200 200
100 100 10 255 255 255
20 20 40 255 0 0
180 20 40 255 255 0
180 180 40 0 255 0
20 180 40 0 0 255"""
C = """400 400
123 231 10 206 119 85
358 316 27 170 47 99
95 317 3 202 42 78
251 269 17 142 150 153
43 120 3 145 75 61
109 376 6 230 231 52
331 78 21 31 81 126
150 330 21 8 142 23
69 155 11 142 251 199
218 335 7 183 248 241
204 237 13 112 253 34
342 89 18 140 11 123"""
D = """400 400
123 231 5 206 119 85
358 316 5 170 47 99
95 317 5 202 42 78
251 269 5 142 150 153
43 120 5 145 75 61
109 376 5 230 231 52
331 78 5 31 81 126
150 330 5 8 142 23
69 155 5 142 251 199
218 335 5 183 248 241
204 237 5 112 253 34
342 89 5 140 11 123"""
E = """100 1"""
for i in (A, B, C, D, E):
    S(i) #S for Star
    O(i) #O for Orb

它们看起来都没有区别。较大的可能需要几秒钟才能运行。

C，247字节

不会赢，但是我喜欢打C。没有使用外部图像库，输出到PPM格式的stdout。在stdin上接受输入。使用曼哈顿距离进行高尔夫球运动。

j,w,h,k,*b,t[6];main(){scanf("%d %d",&w,&h);b=calloc(w*h,24);for(;~scanf("%d",t+j++%6);)for(k=0;j%6?0:k<3*w*h;k++)b[k]=fmin(b[k]+t[2]*t[3+k%3]/(abs(k/3%w-*t)+abs(k/3/w-t[1])+1),255);printf("P6\n%d %d\n255\n",w,h);for(k=0;k<3*w*h;putchar(b[k++]));}

这是欧几里德距离的变体（257字节）：

j,w,h,k,*b,t[6];main(){scanf("%d %d",&w,&h);b=calloc(w*h,24);for(;~scanf("%d",t+j++%6);)for(k=0;j%6?0:k<3*w*h;k++)b[k]=fmin(b[k]+t[2]*t[3+k%3]/(sqrt(pow(k/3%w-*t,2)+pow(k/3/w-t[1],2))+1),255);printf("P6\n%d %d\n255\n",w,h);for(k=0;k<3*w*h;putchar(b[k++]));}

CJam，86个字节

q~]"P3 "\_2>:T;2<_S*" 255 "@:,~\m*{(+0a3*T6/{_2<3$.-:z~+)d\2>(f*\f/.+}/:i255fe<\;S*S}/

尽管这对于高尔夫语言来说似乎有点冗长，但我相信到目前为止发布的解决方案中，这是最短的不使用图像输出功能的解决方案。这将产生ASCII格式的PPM文件。下图是使用GIMP从PPM转换为PNG的。

我不建议在在线CJam解释器中运行代码。至少不是完整尺寸的图像。我的浏览器被锁定，很可能是因为内存占用。它将使用脱机版本完成第二个范围内的400x400图像。

说明：

q~      Read and parse input.
]       Wrap it in an array.
"P3 "   Output start of PPM header.
\       Swap input to top.
_2>     Slice off first two values, leaving the star descriptors.
:T;     Store star descriptors in variable T.
2<      Get first two values in input, which is the image size.
_S*     Leave a copy of the size in the output for the PPM header.
" 255 " Rest of PPM header, range of color values.
@       Pop sizes to top.
:,      Expand sizes to ranges.
~       Unwrap size ranges into separate stack elements.
\       Swap ranges, since we need x-range second for Cartesian product.
m*      Generate all coordinate pairs with Cartesian product.
{       Loop over pixel coordinate pairs.
  (+      Swap values in coordinate pair to get x-coordinate first again.
  0a3*    Generate [0 0 0] array. Will be used to sum up colors from stars.
  T       Get list of stars.
  6/      Split into sub-lists with 6 values for each star.
  {       Loop over the stars.
    _2<     Get the first two values (position) of the star.
    3$      Pull current pixel coordinates to top of stack.
    .-      Subtract pixel coordinates from star position.
    :z      Absolute value of difference.
    ~+      Unpack differences and add them to get Manhattan distance.
    )d      Add 1 and convert to double to get denominator of formula.
    \       Swap star values to top.
    2>      Slice off first two values, leaving intensity and color.
    (       Pop off intensity.
    f*      Multiply it with color values.
    \       Swap denominator to top.
    f/      Perform division of color components by denominator.
    .+      Add it to sum of colors.
  }/      End loop over stars.
  :i      Convert double values for colors to integer.
  255fe<  Cap color components at 255.
  \;      Swap pixel coordinate to top and pop it.
  S*S     Join color components with space, and add another space.
}/      End loop over coordinate pairs.

C＃718字节

我意识到C＃对于打高尔夫球非常糟糕，但这是我尝试718字节时的尝试

namespace System{using Collections.Generic;using Drawing;using Linq;using O=Convert;class P{int j,i;List<S> s=new List<S>();Image G(string t){var l=t.Replace("\r","").Split('\n');var w=O.ToInt32(l[0].Split(' ')[0]);var h=O.ToInt32(l[0].Split(' ')[1]);for(i=1;i < l.Length;i++){var p=l[i].Split(' ');s.Add(new S{X=O.ToInt32(p[0]),Y=O.ToInt32(p[1]),I=O.ToSingle(p[2]),R=O.ToByte(p[3]),G=O.ToByte(p[4]),B=O.ToByte(p[5])});}var b=new Bitmap(w,h);for(j=0;j<h;j++)for(i=0;i<w;i++)b.SetPixel(i,j,C());return b;}Color C(){return Color.FromArgb(X(x=>x.R),X(x=>x.G),X(x=>x.B));}int X(Func<S,float>f){return(int)Math.Min(s.Sum(x=>x.I*f(x)/(Math.Sqrt((x.X-i)*(x.X-i)+(x.Y-j)*(x.Y-j))+1)),255);}class S{public float X,Y,R,G,B,I;}}}

如果有人有任何缩短建议，请随时告诉我。

Python，259个字节

终于完成了！我尝试过的第一个代码高尔夫，决定使用Python，并选择了曼哈顿距离。向Maltysen致谢，以帮助我使用迭代器，将总大小减少到几乎一半！

from PIL.Image import new
N,*s=[list(map(int,i.split()))for i in iter(input,'')]
q,m=new("RGB",(N[0],N[1])),[]
[m.append(tuple(sum(k[2]*k[i]//(abs(k[1]-x)+abs(k[0]-y)+1)for k in s)for i in(3,4,5)))for x in range(N[1])for y in range(N[0])]
q.show(q.putdata(m))

CJam，70个字节

"P3"l_~\:W*255\,[q~]6Te]6/f{\[Wmd\]f{.-Z/~\)\~mh)/f*}:.+{i255e<}/}~]S*

欧氏距离，ASCII PPM输出。在线尝试

应该可以再压缩几个字节，但是我不想花太多时间。