हमारे सितारों में रंग


90

एक प्रोग्राम लिखें जो एक स्ट्रिंग या टेक्स्ट फ़ाइल में लेता है जिसकी पहली पंक्ति में फॉर्म है

width height

और प्रत्येक बाद की रेखा का रूप है

x y intensity red green blue

कहाँ पे:

  • widthऔर heightकोई भी सकारात्मक पूर्णांक हो सकता है।
  • xऔर yकोई भी पूर्णांक हो सकता है।
  • intensity कोई भी गैर-नकारात्मक पूर्णांक हो सकता है।
  • red, greenऔर blue0 से 255 तक कोई भी पूर्णांक हो सकता है।

आपका कार्यक्रम होगा उत्पादन एक TrueColor किसी भी आम दोषरहित छवि फ़ाइल स्वरूप जिसका आयाम हैं में छवि widthसे height। प्रत्येक x y intensity red green blueपंक्ति एक रंगीन स्टार या ऑर्ब का प्रतिनिधित्व करती है जिसे छवि पर खींचा जाना चाहिए। इसमें किसी भी संख्या में तारे हो सकते हैं, जिनमें 0. आप मान सकते हैं कि स्ट्रिंग या फ़ाइल में अनुगामी न्यूलाइन है।

चित्र बनाने के लिए एल्गोरिथ्म इस प्रकार है, हालाँकि आप इसे किसी भी तरह से लागू कर सकते हैं जब तक कि परिणाम समान हो।

छवि के प्रत्येक पिक्सेल ( X , Y ) के लिए (जहाँ X सबसे बाईं ओर 0 और दाईं ओर के किनारे चौड़ाई -1 है , और Y शीर्ष किनारे पर 0 है और नीचे के किनारे पर ऊँचाई -1 है ), रंग चैनल C value { लाल , हरा , नीला } (मान 0 से 255 के बीच पिन किया गया) समीकरण द्वारा दिया गया है:

रंग चैनल समीकरण

जहाँ डिस्टर्ब फंक्शन या तो यूक्लिडियन दूरी है :

यूक्लिडियन दूरी समीकरण

या मैनहट्टन दूरी :

मैनहट्टन दूरी समीकरण

गोल्फबिलिटी या सौंदर्यशास्त्र के आधार पर, आप जो भी पसंद करते हैं, उसे चुनें।

इनपुट में प्रत्येक पंक्तियों के अलावा पहला स्टार्स सेट का एक तत्व है । तो, उदाहरण के लिए, एस एक्स का प्रतिनिधित्व करता है xइनपुट लाइनों में से एक पर मूल्य, और एस सी या तो का प्रतिनिधित्व करता है 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

आउटपुट होना चाहिए

उदाहरण सी, यूक्लिडियन

यदि आप यूक्लिडियन दूरी का उपयोग कर रहे हैं, और

उदाहरण सी, मैनहट्टन

यदि आप मैनहट्टन दूरी का उपयोग कर रहे हैं।

उदाहरण डी

अगर इनपुट है

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

फिर आउटपुट 1 पिक्सेल लंबा छवि द्वारा 100 पिक्सेल चौड़ा होना चाहिए जो पूरी तरह से काला है।

टिप्पणियाँ

  • इनपुट स्ट्रिंग या एक टेक्स्ट फ़ाइल का नाम लें जिसमें इसे स्टडिन या कमांड लाइन से लिया गया है, या आप एक फ़ंक्शन लिख सकते हैं जो एक स्ट्रिंग में लेता है।
  • "आउटपुट" छवि का अर्थ है:
    • अपनी पसंद के नाम वाली फ़ाइल में सहेजना।
    • स्टडआउट के लिए कच्ची छवि फ़ाइल डेटा प्रिंट करना।
    • इस तरह के साथ के रूप में छवि, प्रदर्शित जनहित याचिका की image.show()
  • मैं जाँच नहीं करूंगा कि आपकी छवियां पिक्सेल परफेक्ट हैं (स्टैक एक्सचेंज हानिपूर्ण रूप से वैसे भी छवियों को संकुचित करता है) लेकिन मुझे बहुत संदेह होगा यदि मैं नेत्रहीन रूप से कोई अंतर बता सकता हूं।
  • आप ग्राफिक्स / छवि पुस्तकालयों का उपयोग कर सकते हैं।

जीतना

बाइट्स में सबसे कम सबमिशन जीतता है। संबंधों के मामले में, सबसे पहला सबमिशन जीत जाता है।

मजेदार बोनस: वास्तव में शानदार आउटपुट छवि के लिए इनपुट दें।


38
+1 वाह। यह शानदार है। (और पोस्टिंग के लिए एक उपयुक्त समय, जैसा कि हम एक स्वस्थ न्यू होराइजंस अंतरिक्ष यान से शब्द सुनते हैं!)
ब्रेनसैट

क्या इनपुट को उस अंतरिक्ष से अलग किए गए प्रारूप में होना चाहिए, या क्या इसे अल्पविराम से अलग किया जा सकता है? वैसे भी, +1।
माल्टसेन

1
@ मैलेटेन स्पेस अलग हो गया। (मुझे पता है कि यह कंजूस है, लेकिन एक दर्जन इनपुट वेरिएंट की अनुमति देने की तुलना में यह आसान है।)
केल्विन के शौक

4
मैं तय नहीं कर सकती कि गहने या तारे अधिक सुंदर हैं या नहीं।
ट्राइकोप्लाक्स

पिक्सेल-पूर्णता के लिए आप बिटमैप के हैश की तुलना कर सकते हैं
टोबियास किन्ज़लर

जवाबों:


26

पायथ - 46 बाइट्स

यह मजेदार था! मुझे अंततः पाइथ की छवि I / O सुविधाओं का उपयोग करने के लिए मिला। क्या गोल्फ के कारण यूक्लिडियन दूरी है, हालांकि मैनहट्टन सिर्फ एक छोटा बदलाव है।

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

यह सिर्फ सूत्र के साथ सभी पिक्सेल के माध्यम से लूप करता है, हालांकि यह पिक्सेल लूप को एक लूप में divmodसम्मिलित करता है और उपयोग करता है क्योंकि पायथ केवल 3 नेस्टेड मैप्स का समर्थन करता है और गणना दो (आरजीबी के लिए एक और सितारों के लिए एक) लेती है।

के रूप में छवि बचाता है o.png। बहुत धीमी गति से, पहले 2 परीक्षण <2 मिनट में करता है, लेकिन अन्य 2 आधे घंटे के आदेश पर लेते हैं।

इसमें एक बग है, .wजिस पर किसी ने ध्यान नहीं दिया क्योंकि कोई भी इसका उपयोग नहीं करता है;) लेकिन मैंने एक पुल अनुरोध में डाला ताकि परीक्षण के लिए मेरे कांटे का उपयोग करें यदि जल्द ही विलय नहीं हुआ है। विलय होना!

उदाहरण आउटपुट

उदाहरण ए

उदाहरण ए

उदाहरण बी

उदाहरण बी

उदाहरण सी

उदाहरण सी

उदाहरण डी

उदाहरण डी


7
वाह, पता नहीं था कि पायथ ऐसा कर सकता है। एक दिन हम Pyth में बिजनेस सॉफ्टवेयर लिखना समाप्त कर सकते हैं। यह लिखने के लिए कम कोड है, इसलिए इसे रिफ्लेक्टर के लिए तेज और आसान होना चाहिए। : डी
क्रिस्टियन लुपस्कु

7
@ w0lf "प्रोग्रामर का समय निष्पादन के समय से अधिक महत्वपूर्ण है" और हम सभी जानते हैं कि पायथन प्रोग्रामर समय को कम करने में मदद करता है :) हाल ही में पायथन को चित्रमय आउटपुट चुनौती से बाहर निकलने के बाद छवि I / O को जोड़ा गया था। यह आंतरिक रूप से पिलो का उपयोग करता है।
माल्टसेन

11
@ निट बिल्कुल। यह भी लिखने के लिए कितनी तेजी से कुछ नहीं करना है। मेरी पिछली टिप्पणी एक मजाक थी।
क्रिस्टियन लुपस्कू

2
आप लोग एक महत्वपूर्ण बात भूल गए - इसका डिबग करना भी आसान है, क्योंकि कोड कम है;)
ऑप्टिमाइज़र

14
प्रोग्रामर के समय को कम करने से आपका मतलब है "वे कोड गोल्फ खेल रहे हैं और इसलिए" वास्तविक 'कोड लिखने के लिए कम समय है?

42

जावास्क्रिप्ट 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 ​​सेकंड लेता है)।

आप इसे 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 में भी चला सकते हैं ।

विवरण

यह एक सीधा जावास्क्रिप्ट + एचटीएमएल 5 कैनवास कार्यान्वयन है: एक फ़ंक्शन जो स्ट्रिंग तर्क लेता है (रिक्त स्थान / नईलाइन्स के बिना) और डोम में आउटपुट प्रदर्शित करता है। यह यूक्लिडियन दूरी का उपयोग करता है।

यहाँ पठनीय कोड है:

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

मुझे लगता है कि ब्लू एक्लिप्स में एक साथ हलो कैसे चिपके हुए हैं, क्या आप मैनहटन शैली जोड़ सकते हैं?
पीटी राइटर १

1
@PTwr ज़रूर, यहाँ यह है: jsfiddle.net/pjLnazw1
क्रिस्टियन लुपस्कू

बहुत बढ़िया! (7 और जाने के लिए ...
ऊग

@ w0lf आप x और y पुनरावृत्तियों के संयोजन से अपने कार्य से कुछ बाइट्स दाढ़ी कर सकते हैं। jsfiddle
वॉल्फहैमर

@wolfhammer वाह, यह अब सिर्फ "कुछ बाइट्स" है, यह बहुत सुधार है। मैं बाद में उस पर एक नज़र डालूंगा, क्योंकि मेरा मानना ​​है कि अनुक्रमण के बारे में कुछ तय किया जाना है (नमूना छवियों 2, 3 और 4 के लिए बाईं ओर पिक्सेल चारों ओर लपेटने के लिए दिखाई देते हैं)। धन्यवाद!
क्रिस्टियन लुपस्कू

26

जावा - 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 ५०
-15 25 25 255 255 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 चित्र , जो महान नहीं दिखता है ... यदि कोई इसे सुधार सकता है तो वह खुश होगा!


15
सोलर सिस्टम के लिए +1। -1 प्लूटो को छोड़ने के लिए (अब जब हम इसके वास्तविक रंग और आकार को भी जानते हैं)
ऑप्टिमाइज़र

1
इसके अलावा, यह वास्तव में अच्छा होगा यदि एक पूर्ण 1080p वॉलपेपर जुड़ा हुआ है :)
ऑप्टिमाइज़र

@Optimizer मैं प्लूटो जोड़ा;) चलो देखते हैं कि क्या मैं वॉलपेपर के बारे में क्या कर सकते हैं
CommonGuy

1
@ Sp3000 अप्स, तीव्रता को भूल गया जब मैंने प्लूटो को जोड़ा
कॉमनग्यु जूल

2
ध्यान दें कि शनि वलय वाला एकमात्र ग्रह नहीं है। यदि आपको काम करने के लिए छल्ले मिलते हैं, तो आपको उन्हें यूरेनस में भी जोड़ना चाहिए।
mbomb007

20

बैश, 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

आप के साथ एक बाइट बचा सकते हैं $w\x$h
डेल्टब

... और दूसरा साथ o=o.png
डेल्टब

16

पायथन 3, 189 बाइट्स

मैं किसी विशेषज्ञ गोल्फर के बारे में नहीं जानता, लेकिन यहां जाता हूं।

  • इनपुट से आता है stdinऔर पीपीएम प्रारूपstdout में जाता है ।
  • इसे ऐसे चलाएं: 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(), और वास्तव में ऐसा प्रतीत होता है कि मूल छवियां क्या करती हैं - आप स्टार चमक के अंधेरे फ्रिंज में कुछ स्ट्राइक बना सकते हैं जो कड़ाई से सही नहीं हैं कोड। जैसा कि यह खड़ा है, हालांकि, यह कोड विवरण का अनुसरण करता है, न कि छवियों का।

अनगोल्डेड संस्करण, और कई प्रयासों से पहले मेरी मूल गोल्फिंग जो दूसरों ने इंगित की या कि मैं खुद पर ठोकर खाई, इस मुट्ठी में हैं

संपादित करें: मैंने 7 बाइट्स को स्थानांतरित करके for xऔर for yएक एकल print(या o) फ़ंक्शन में सहेजा है , लेकिन यह पीएनएम फ़ाइल को बहुत लंबी लाइन के साथ पैदा करता है, जो कुछ समस्याओं का कारण हो सकता है या नहीं।

EDIT 2: माल्टसेन ने मुझे एक और 20 बाइट्स से बचाया। धन्यवाद!

फिर से संपादित करें: अब जबकि केवल एक ही है print, oउपनाम एक दायित्व है, बचत नहीं। 4 और बाइट्स बंद।

कुछ और संपादित करें: Sp3000 ने मुझे 2 और बाइट्स से बचाया। इस बीच उपघटन mapको mपठनीयता (!) के हित में कुछ भी बचत नहीं कर रहा था, तो मैं इसे फिर से विस्तार किया है। अब यह एक अच्छा दौर है 2 8 बाइट्स।

अंतिम (!) संपादित करें: अब यूक्लिडियन दूरी समर्थन के साथ - और जटिल संख्याओं का दुरुपयोग करते हुए, मैंने इसे बिल्कुल बाइट्स में किया!

EDIT, हॉलीवुड रिबूट: Sp3000 के अगले सुझाव में 5 बाइट्स ने दस्तक दी।

संपादित करें, मूर्खतापूर्ण नाम अगली कड़ी: 6 बाइट्स छंटनी की, एक सुझाव के लिए धन्यवाद माल्टीसेन ने कहा कि मैं समझ नहीं पाया जब तक कि Sp3000 ने इसे दोहराया नहीं ... फिर दुरुपयोग से एक और 8 बाइट्स %। और बातचीत में यह एक अभूतपूर्व बात है2126 बाइट्स। मैं दीन हूँ।


@ माल्टीसेन: काफी सही। 20 बाइट बच गई!
टिम पैडरिक

कुछ और: के साथ कि जटिल sys.stdin सामान के बजाय EOFरों आप उपयोग कर सकते iter()प्रहरी मूल्यों के साथ: docs.python.org/2/library/functions.html#iter के रूप में iter(raw_input,''), यह भी डाल w,h,Sविस्तारित unpacking के साथ एक ही लाइन पर।
माल्टसेन

@ माल्टीसेन: मुझे यकीन नहीं है कि काम करेगा। मैं लगभग बिल्कुल पहले से ही कर रहा था, लेकिन यह हिट करता है EOFError(और इसलिए मुझे एक tryब्लॉक की आवश्यकता थी ), क्योंकि इनपुट फ़ाइल में कोई खाली लाइन नहीं है और मुझे यकीन नहीं है कि चुनौती मुझे जोड़ने की अनुमति देती है। या क्या मैं कुछ न कुछ भूल रहा हूं?
टिम पैडरिक

मुझे लगता है कि अगर आप प्रहरी मूल्य की बात करते हैं, तो आप फ़ाइल को फीड करने के लिए एक रिक्त लाइन बनाम समाप्त कर सकते हैं, हालाँकि, हाँ, फ़ाइल चीज़ काम नहीं करेगी।
माल्टसेन

@ Sp3000: हैरानी की बात है, हाँ! मैं यह शिकायत करने के लिए उम्मीद कर रहा था कि stdinयह एक पुनरावृत्ति नहीं था।
टिम पैडरिक

10

सी ++, 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" नाम की फ़ाइल पर इनपुट लेता है ।

उदाहरण D:

यहाँ छवि विवरण दर्ज करें


यहाँ छवि विवरण दर्ज करें


यहाँ छवि विवरण दर्ज करें


1
मुझे PCGछवि पसंद है :) (हालांकि PPCGमेरा पसंदीदा संक्षिप्त नाम है;)
केल्विन के

8

पायथन 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()

मैनहट्टन दूरी का उपयोग करता है। यह शायद पायथन 3 में भी छोटा होगा, लेकिन मैंने हाल ही में अपने पायथन पैकेज को गड़बड़ कर दिया है और मुझे तकिया को फिर से स्थापित करने में परेशानी हो रही है। पीपीएम शायद और भी छोटा होगा, लेकिन मुझे पीआईएल पसंद है।

मज़े के लिए, मैंने एल्गोरिथ्म को लागू करने की कोशिश की जैसा कि एल * बी * रंग अंतरिक्ष में है , यह सोचकर कि यह बेहतर रंग सम्मिश्रण देगा (विशेष रूप से उदाहरण बी में)। दुर्भाग्य से, केल्विन की एल्गोरिथ्म चैनलों को उनके अधिकतम मूल्यों पर जाने देता है, जिससे चित्र मुझे उम्मीद की तुलना में थोड़ा कम भयानक लगते हैं ...

यहाँ छवि विवरण दर्ज करें


6

गणितज्ञ, 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"]&

6

पायथन 2, 287 251 बाइट्स

छवियों को उत्पन्न करने के लिए मैंने मूल कोड का एक गोल्फ संस्करण का उपयोग किया। शायद थोड़ा अधिक गोल्फ किया जा सकता है (मेरे मुकाबले एक बेहतर गोल्फर)। यह एक फ़ंक्शन है जो पूर्ण इनपुट स्ट्रिंग में लेता है। छवि प्रसंस्करण पीआईएल के छवि मॉड्यूल के साथ किया जाता है । मैनहट्टन दूरी का उपयोग करता है।

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

वे सभी अविवेकी दिखते हैं। बड़े लोगों को चलाने में कुछ सेकंड लग सकते हैं।


मेरा मानना है कि आप को बदलने के द्वारा बाइट्स के एक झुंड को बचा सकता है for x in r(I[0]):...for y in r(I[1]):करने के लिए इसे बदल कर for x in r(I[0]*I[1]):। फिर आप प्रत्येक इंडेंट स्तर को 1 से नीचे ले जा सकते हैं, और उसके xसाथ x/I[1]और yसाथ बदल सकते हैं y%I[1]
केड

आप की जगह 5 बाइट्स बचा सकता है from PIL import Imageके लिएfrom PIL import*
sagiksp

6

सी, 247 बाइट्स

जीतने के लिए नहीं जा रहा है, लेकिन मैं सी। में गोल्फ को पसंद करता हूं। कोई बाहरी छवि पुस्तकालय का उपयोग नहीं करता है, पीपीएम प्रारूप में stdout को आउटपुट करता है। स्टड पर इनपुट लेता है। गोल्फ के लिए मैनहट्टन दूरी का उपयोग करता है।

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

6

सीजेएम, 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.

5

सी # 718 बाइट्स

मुझे पता है कि सी # गोल्फिंग के लिए भयानक है, लेकिन यहां मेरा प्रयास 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;}}}

अगर किसी के पास इसे छोटा करने के लिए कोई सुझाव है, तो बेझिझक मुझे बताएं।


आपने Color.FromArgb (int, int, int) अधिभार को याद किया है। बचाएंगे 4 बाइट्स ...
मेल्विन

इसके अलावा, आप शायद का उपयोग करना चाहिए। के बजाय। गति ()। एक बाइट कम, और अधिक कुशल। और वैसे भी, आप C # 6 के नए एक्सप्रेशन-बॉडी वाले सदस्यों का उपयोग करके बहुत अधिक बाइट्स बचा सकते हैं, यदि आप चाहते हैं।
मेल्विन

लंबाई और अधिभार दोनों पर अच्छे अंक, अब समायोजन। और अभिव्यक्ति-प्रधान सदस्यों में देख रहे हैं। उन लोगों को पहले नहीं देखा था। साभार
एलन हार्पर

4

पायथन, 259 बाइट्स

आख़िरकार हो गया! पहला कोड गोल्फ मैंने कोशिश की, पायथन का उपयोग करने का फैसला किया और मैनहट्टन दूरी के साथ चला गया। माल्टर्सन को चिल्लाते हुए मेरी मदद करने के लिए, कुल आकार को लगभग आधा कर दिया!

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

मुझे पता है कि उन सभी के लिए एक गणना करने का एक तरीका होना चाहिए, लेकिन मैं ईमानदारी से अजगर को अच्छी तरह से नहीं जानता हूं।
निकोलस सिप्लिस


आपकी अभी भी ठीक से काम नहीं करता है, k[0]और k[1]गणना में स्विच करना है ।
माल्टीसेन

मुझे यह महसूस करने में 10 मिनट का समय लगा कि यह मेरी मशीन पर क्यों काम कर रहा था, पता चला कि मैंने उन्हें उल्टा कर दिया था लेकिन इसे यहाँ बदलना भूल गया।
निकोलस सिप्लिस

2

सीजेएम, 70 बाइट्स

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

यूक्लिडियन दूरी, एएससीआईआई पीपीएम आउटपुट। इसे ऑनलाइन आज़माएं

कुछ और बाइट्स को निचोड़ना संभव होना चाहिए, लेकिन मैं बहुत अधिक समय खर्च नहीं करना चाहता।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.