Напишите программу, которая принимает строку или текстовый файл, первая строка которого имеет вид

width height

и каждая последующая строка имеет вид

x y intensity red green blue

где:

• widthи heightмогут быть любые натуральные числа.
• xи yмогут быть любые целые числа.
• intensity может быть любым неотрицательным целым числом.
• red, greenи blueмогут быть любыми целыми числами от 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значение на одной из входных линий, а S _C представляет собой либо red, greenили blue, в зависимости от того, какого цвета канал в настоящее время рассчитывается.

Примеры

Пример А

Если вход

400 150
-10 30 100 255 128 0

выход должен быть

если вы используете евклидово расстояние, и

если вы используете расстояние Манхэттен.

Пример Б

Если вход

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

соответствующие выходы для евклидова и манхэттенского расстояния должны быть

и .

Пример С

Если вход

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

выход должен быть

если вы используете евклидово расстояние, и

если вы используете расстояние Манхэттен.

Пример Е

Если вход

100 1

тогда вывод должен быть полностью черным изображением шириной 100 на 1 пиксель.

Примечания

• Возьмите входную строку или имя текстового файла, который содержит его, из stdin или командной строки, или вы можете написать функцию, которая принимает строку.
• «Вывод» изображения означает либо:
  • Сохранение в файл с именем по вашему выбору.
  • Печать необработанных данных файла изображения в стандартный вывод.
  • Отображение изображения, например, с PIL «ы image.show().
• Я не буду проверять, чтобы ваши изображения были идеальными по пикселям (Stack Exchange в любом случае сжимает изображения с потерями), но я буду очень подозрительным, если смогу визуально отличить их.
• Вы можете использовать графические / графические библиотеки.

выигрыш

Самая короткая подача в байтах побеждает. В случае галстуков выигрывает самая ранняя подача.

Fun Bonus: Дайте вклад для действительно впечатляющего выходного изображения.

Pyth - 46 байт

Это было весело! Наконец-то я получил возможность использовать функции ввода / вывода Pyth. Есть евклидово расстояние из-за игры в гольф, хотя Манхэттен - только короткое изменение.

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

Это просто перебирает все пиксели с формулой, хотя он конденсирует пиксельный цикл в один цикл и использует, divmodтак как Pyth поддерживает только 3 вложенные карты, а вычисления занимают два (один для RGB и один для звезд).

Сохраняет изображение как o.png. Довольно медленно, первые 2 теста проходят менее чем за 2 минуты, а остальные 2 занимают порядка получаса.

Есть ошибка в .wтом, что никто не заметил, потому что никто не использует ее;), но я вставил запрос на извлечение, так что используйте мой форк, чтобы проверить, не скоро ли слится. Объединенное!

Примеры Выходы

Пример А

Пример Б

Пример С

Пример 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);}

Изменить: значительно сократить код, применяя удивительные предложения волкхаммера .

Контрольная работа

Примечание. Подождите несколько секунд, пока фрагмент кода будет показан ниже (на моем компьютере это займет ~ 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: функция, которая принимает строковый аргумент (без конечных пробелов и переносов) и отображает вывод в 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);
};

Ява - 627 байт

Ява действительно один из лучших языков для игры в гольф :)

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 10 245 222 179
475 25 7 245 245 220
942 25 6 0 250 150
1464 25 6 0 0 255
1920 25 1 255 245 238

Изображение в формате Full HD , которое выглядит не очень хорошо ... Был бы рад, если бы кто-то смог улучшить его!

Баш, 147 145 байт

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 версия, и моя оригинальная игра в гольф до многих оптимизаций , что другие указывали , или что я споткнулся на себя, в этом суть .

РЕДАКТИРОВАТЬ: я сохранил 7 байтов путем перемещения for xи for yв одну print(или o) функцию, но это создает файл PNM с очень длинной строкой, что может вызвать или не вызвать некоторые проблемы.

РЕДАКТИРОВАТЬ 2: Maltysen спас мне еще 20 байтов. Спасибо!

РЕДАКТИРОВАТЬ еще раз: теперь, когда есть только один print, oпсевдоним является обязательством, а не экономия. Еще 4 байта.

РЕДАКТИРОВАТЬ еще немного: Sp3000 сэкономил мне еще 2 байта. Между тем, псевдоним mapдля mничего не спасал, поэтому в интересах читабельности (!) Я снова расширил его. Теперь это хороший раунд 2 ⁸ байтов.

РЕДАКТИРУЙТЕ последний (?): Теперь с евклидовой дистанционной поддержкой - и злоупотребляя комплексными числами, я сделал это в точно таком же количестве байтов!

РЕДАКТИРОВАТЬ, перезагрузка Голливуда: следующее предложение Sp3000 сбило 5 байтов.

РЕДАКТИРОВАТЬ, глупо названное продолжение: 6 байтов обрезано, благодаря предложению, которое Мальтисен сделал, что я не понял, пока 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, выводит в файл с именем «a» в текущем каталоге в формате PNG.

Пример 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"&

Чистая функция, принимающая строку. Для того, чтобы запустить его в разумном количестве времени, замените 1ин 1+#~ManhattanDistance...с 1.; это вызывает числовые вычисления вместо символических.

Ungolfed:

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 «s модуля Image . Использует манхэттенское расстояние.

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. Принимает вход на стандартный ввод. Использует манхэттенское расстояние для игры в гольф.

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

Хотя это может выглядеть довольно долго для языка игры в гольф, я считаю, что из представленных решений, это самое короткое, которое не использует функцию вывода изображения. Это создает файл PPM в форме ASCII. Изображение ниже было преобразовано из PPM в PNG с использованием GIMP.

Я не рекомендую запускать код в онлайн-интерпретаторе 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 и прошел путь до Манхэттена. Привет Мальтисену, который помог мне с итераторами, уменьшил общий размер почти до половины!

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. Попробуйте онлайн

Должно быть возможно сжать еще несколько байтов, но я не хочу тратить слишком много времени.