Напишіть програму, яка містить рядок або текстовий файл, перший рядок якого має форму

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 в крайньому лівому краю, а ширина - 1 в нижньому правому краю, а Y - 0 у верхньому краї, а висота - 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 або командного рядка, або ви можете написати функцію, яка займає рядок.
• "Виведення" зображення означає або:
  • Збережіть його у файл із вибраним вами іменем.
  • Друк необроблених даних файлу зображень до stdout.
  • Відображення зображення, наприклад, з PIL 's image.show().
• Я не буду перевіряти, чи є ваші зображення ідеальними для пікселів (Stack Exchange все одно втрачає зображення), але буду дуже підозрілим, якщо зможу візуально визначити будь-яку різницю.
• Ви можете використовувати графіки / бібліотеки зображень.

Перемога

Виграє найкоротше подання в байтах. У разі зв'язань виграє найдавніше подання.

Веселий бонус: надайте вклад для дійсно вражаючого вихідного зображення.

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

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

Повна 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

Пітон 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(), а насправді, здається, це те, що роблять оригінальні зображення - ви можете ледве викреслити деякі смуги в темних бахромах зіркового світіння, яких немає строго правильних код. Однак, цей код слід за описом, а не за зображеннями.

Негольфікована версія та мій оригінальний гольф перед численними оптимізаціями, на які вказували інші чи які я натрапив на себе, є у цій суті .

EDIT: Я врятував 7 байт, переміщаючи for xі for yв одну print(або oфункцію), але це робить ПСМ файл з дуже довгою лінією, яка може або не може викликати деякі проблеми.

EDIT 2: Мальтісен врятував мене ще 20 байт. Дякую!

ЗНО ЗНО: Тепер, коли існує лише одне print, oпсевдонім - це відповідальність, а не економія. Ще 4 байти вимкнено.

РЕДАКТИРУЙТЕ ще трохи: Sp3000 врятував мене ще 2 байти. Тим часом, згладжування , mapщоб mнічого не було порятунку, так і в інтересах удобочитаемости (!) Я розширив його знову. Зараз хороший раунд 2 ⁸ байт.

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

EDIT, перезавантаження Голлівуду: наступна пропозиція Sp3000 знищила 5 байт.

EDIT, нерозумно названий продовження: 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 недавно, і у мене виникають проблеми з перевстановленням Подушки. PPM, певно, буде ще коротшим, але мені подобається PIL.

Для задоволення я спробував застосувати алгоритм, як це є в кольоровому просторі L * a * b * , думаючи, що це дозволить краще поєднати кольори (особливо у прикладі B). На жаль, алгоритм Кальвіна дозволяє каналам переходити свої максимальні значення, завдяки чому зображення виглядають трохи менш приголомшливо, ніж я сподівався ...

Математика, 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.; це змушує числові обчислення замість символічних.

Безголовки:

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()

Ось повний набір тестів, який запускає приклади від А до Е з питання, для обох показників відстані:

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. Жодна бібліотека зовнішніх зображень не використовується, виводиться на stdout у форматі PPM. Здійснює введення на 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}/

Хоча це може виглядати досить довго для мови гольфу, я вважаю, що рішення, розміщені на даний момент, це найкоротший, який не використовує функцію виведення зображення. Це створює файл PPM у формі ASCII. Зображення нижче перетворено з PPM в PNG за допомогою GIMP.

Я не рекомендую запускати код в онлайн-інтерпретаторі CJam. Принаймні, не для повнорозмірних зображень. Мій браузер заблокований, швидше за все, через використання пам'яті. Він доповнює зображення 400х400 у другому діапазоні офлайн-версією.

Пояснення:

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

Якщо хтось має пропозиції скоротити його, сміливо повідомте мене.

Пітон, 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. Спробуйте в Інтернеті

Слід вичавити ще кілька байт, але я не хочу витрачати занадто багато часу.