एक गाऊसी मैट्रिक्स का निर्माण

Question

गॉसियन ब्लर एक ऐसी विधि है जिसका उपयोग छवियों को सुचारू रूप से धुंधला करने के लिए किया जाता है। इसमें एक मैट्रिक्स बनाना शामिल है जिसका उपयोग किसी छवि के पिक्सेल के साथ इसे करने के लिए किया जाएगा। इस चुनौती में, आपका कार्य उस मैट्रिक्स का निर्माण करना है जिसका उपयोग गॉसियन ब्लर में किया जाता है। आपके पास कोई इनपुट ले जाएगा r जो कलंक की त्रिज्या और एक इनपुट किया जाएगा σ जो आदेश आयामों के साथ एक मैट्रिक्स का निर्माण करने में मानक विचलन हो जाएगा (2 आर + 1 × 2 आर +1)। उस मैट्रिक्स के प्रत्येक मूल्य का एक ( x , y ) मान होगा जो केंद्र से प्रत्येक दिशा में इसकी पूर्ण दूरी पर निर्भर करता है और इसका उपयोग जी ( x , y ) जहां सूत्र की गणना करने के लिए किया जाएगाजी है

उदाहरण के लिए, यदि r = 2, हम 5 x 5 मैट्रिक्स उत्पन्न करना चाहते हैं। सबसे पहले, ( x , y ) मानों का मैट्रिक्स है

(2, 2) (1, 2) (0, 2) (1, 2) (2, 2)
(2, 1) (1, 1) (0, 1) (1, 1) (2, 1)
(2, 0) (1, 0) (0, 0) (1, 0) (2, 0)
(2, 1) (1, 1) (0, 1) (1, 1) (2, 1)
(2, 2) (1, 2) (0, 2) (1, 2) (2, 2)

फिर, चलो σ = 1.5 और लागू जी से प्रत्येक के लिए ( एक्स , वाई )

0.0119552 0.0232856 0.0290802 0.0232856 0.0119552
0.0232856 0.0453542 0.0566406 0.0453542 0.0232856
0.0290802 0.0566406 0.0707355 0.0566406 0.0290802
0.0232856 0.0453542 0.0566406 0.0453542 0.0232856
0.0119552 0.0232856 0.0290802 0.0232856 0.0119552

आम तौर पर छवि धुंधला में, इस मैट्रिक्स को उस मैट्रिक्स में सभी मूल्यों का योग लेने और इसके द्वारा विभाजित करके सामान्य किया जाएगा। इस चुनौती के लिए, यह आवश्यक नहीं है और सूत्र द्वारा गणना किए गए कच्चे मूल्यों का आउटपुट क्या होना चाहिए।

नियम

• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।
• इनपुट आर गैर नकारात्मक पूर्णांक हो जाएगा और σ एक सकारात्मक वास्तविक संख्या होगी।
• आउटपुट को मैट्रिक्स का प्रतिनिधित्व करना चाहिए। यह एक 2d सरणी के रूप में स्वरूपित किया जा सकता है, एक स्ट्रिंग 2d सरणी का प्रतिनिधित्व करता है, या कुछ इसी तरह का।
• फ्लोटिंग-पॉइंट अशुद्धि को आपके खिलाफ नहीं गिना जाएगा।

परीक्षण के मामलों

(r, σ) = (0, 0.25)
2.54648

(1, 7)
0.00318244 0.00321509 0.00318244
0.00321509 0.00324806 0.00321509
0.00318244 0.00321509 0.00318244

(3, 2.5)
0.00603332 0.00900065 0.0114421  0.012395 0.0114421 0.00900065 0.00603332
0.00900065  0.0134274 0.0170696 0.0184912 0.0170696  0.0134274 0.00900065
 0.0114421  0.0170696 0.0216997  0.023507 0.0216997  0.0170696  0.0114421
  0.012395  0.0184912  0.023507 0.0254648  0.023507  0.0184912   0.012395
 0.0114421  0.0170696 0.0216997  0.023507 0.0216997  0.0170696  0.0114421
0.00900065  0.0134274 0.0170696 0.0184912 0.0170696  0.0134274 0.00900065
0.00603332 0.00900065 0.0114421  0.012395 0.0114421 0.00900065 0.00603332

(4, 3.33)
0.00339074 0.00464913 0.00582484 0.00666854 0.00697611 0.00666854 0.00582484 0.00464913 0.00339074
0.00464913 0.00637454 0.00798657  0.0091434 0.00956511  0.0091434 0.00798657 0.00637454 0.00464913
0.00582484 0.00798657  0.0100063  0.0114556   0.011984  0.0114556  0.0100063 0.00798657 0.00582484
0.00666854  0.0091434  0.0114556   0.013115  0.0137198   0.013115  0.0114556  0.0091434 0.00666854
0.00697611 0.00956511   0.011984  0.0137198  0.0143526  0.0137198   0.011984 0.00956511 0.00697611
0.00666854  0.0091434  0.0114556   0.013115  0.0137198   0.013115  0.0114556  0.0091434 0.00666854
0.00582484 0.00798657  0.0100063  0.0114556   0.011984  0.0114556  0.0100063 0.00798657 0.00582484
0.00464913 0.00637454 0.00798657  0.0091434 0.00956511  0.0091434 0.00798657 0.00637454 0.00464913
0.00339074 0.00464913 0.00582484 0.00666854 0.00697611 0.00666854 0.00582484 0.00464913 0.00339074

Comments

हमें पी और ई होने की कितनी सही आवश्यकता है?

— xnor

@xnor अच्छा सवाल। यदि आपकी भाषा अनुमति देती है, तो आप मान सकते हैं कि वे मान पहले से ही चर या कुछ इसी तरह संग्रहीत हैं। यदि नहीं, तो आप pi = 3.14 और e = 2.72 बनाने वाले दो दशमलव स्थानों पर मानों का उपयोग कर सकते हैं, जहाँ आप उनमें से प्रत्येक मान को एक बाइट के रूप में गिन सकते हैं। बेशक, अंतिम जवाब में गलतियाँ आपके खिलाफ फिर से नहीं गिना जाएगा।

— मील

क्या आउटपुट में दशमलव संख्या होनी चाहिए, या उनमें स्थिरांक के साथ सटीक संख्या हो सकती है?

— जुंगह्वान मिन

@JungHwanMin सटीक संख्याएँ, जैसे कि गणितज्ञ, ठीक हैं।

— मील

@ मीलों मुझे लगता है कि यह आसान होगा यदि आप केवल एक निश्चित परिशुद्धता (जैसे 3 दशमलव स्थानों) को अनिवार्य करते हैं।

— orlp

Answer 1

मैथेमेटिका, 60 54 50 बाइट्स

4 बाइट्स के लिए @GregMartin धन्यवाद!

Array[s=2#2^2;E^(-{##}.{##}/s)/π/s&,1+2{#,#},-#]&

आर और सिग्मा को इनपुट के रूप में लेता है, मैट्रिक्स (सटीक संख्या) लौटाता है।

निर्मित संस्करण (58 बाइट्स)

GaussianMatrix[{##},Standardized->1<0,Method->"Gaussian"]&

बेशक, गणितज्ञ के पास इसके लिए एक अंतर्निर्मित है, लेकिन यह बहुत लंबा है।

Comments

आप की जगह ले सकता -lद्वारा -#अंत में ( Arrayकि थ्रेड जाएगा आप के लिए दोनों आयामों पर); यह परिभाषित करने की आवश्यकता को दूर करता है l, 4 बाइट्स की बचत करता है ।

— ग्रेग मार्टिन

Answer 2

MATL , 20 बाइट्स

_G&:U&+iUE/_Ze5MYP*/

इसे ऑनलाइन आज़माएं!

व्याख्या

_     % Take input r implicitly. Negate
G     % Push r again
&:    % Binary range: [-r -r+1 ... r]
U     % Square, elementwise
&+    % Matrix of all pairwise additions
i     % Take input σ
U     % Square
E     % Multiply by 2. Gives 2σ^2
/     % Divide
_     % Negate
Ze    % Exponential
5M    % Push 2σ^2 again
YP    % Push pi
*     % Multiply
/     % Divide. Display implicitly

Answer 3

ऑक्टेव, 45 बाइट्स

@(r,s)exp((x=-(-r:r).^2/2/s^2)+x')/2/s^2/pi

Answer 4

ऑक्टेव, 49 बाइट्स

@(r,q)1./((Q=2*q^2)*pi*e.^(((x=(-r:r).^2)+x')/Q))

यह ऑनलाइन की कोशिश करो!

Answer 5

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

lambda r,s:[[.5/3.14/s/s/2.72**((x*x+y*y)/2/s/s)for x in range(-r,r+1)]for y in range(-r,r+1)]

उस नियम का उपयोग करता है जहाँ आप 1 बाइट लागत पर 3.14 और 2.72 हार्डकोड कर सकते हैं।

Answer 6

पर्ल 6 , 71 बाइट्स

->\r,\σ{map ->\y{map ->\x{exp((x*x+y*y)/-2/σ/σ)/2/pi/σ/σ},-r..r},-r..r}

तकनीकी रूप से यह 71 बाइट्स से अधिक हो सकता है यदि एन्कोड किया गया है और किसी फ़ाइल में सहेजा गया है, लेकिन मैं एक वास्तविक ग्रीक सिग्मा के साथ "सिग्मा" इनपुट के नामकरण का विरोध नहीं कर सकता। यदि कोई चाहे तो किसी भी सादे-ASCII पत्र में इसका नाम बदला जा सकता है।

Answer 7

एसएएस मैक्रो भाषा, 296 बाइट्स

शायद यह करने के लिए एक बहुत अधिक कुशल तरीका है, लेकिन यह काम करता है :)

यह कोड परिणामी डेटासेट को प्रिंट करता है।

%macro G(r,s);%let l=%eval(2*&r+1);%let pi=%sysfunc(constant(pi));data w;array a[*] t1-t&l;%do i=-&r %to &r;%do j=-&r %to &r;%let t=%sysfunc(sum(&j,&r,1));a[&t]=%sysevalf(1/(2*&pi*&s**2)*%sysfunc(exp(-(%sysfunc(abs(&j))**2+%sysfunc(abs(&i))**2)/(2*&s**2))));%end;output;%end;proc print;run;%mend;

Answer 8

हास्केल, 59 बाइट्स

r#s|i<-[-r..r]=[[exp(-(x*x+y*y)/2/s/s)/2/pi/s/s|x<-i]|y<-i]

उपयोग उदाहरण:

1#7

[[3.1824449424224664e-3,3.2150851187016326e-3,3.1824449424224664e-3],
 [3.2150851187016326e-3,3.2480600630999047e-3,3.2150851187016326e-3],
 [3.1824449424224664e-3,3.2150851187016326e-3,3.1824449424224664e-3]]

Answer 9

पायथन 2.7, 167 बाइट्स

एक बहुत ही सरल उपाय:

from __future__ import division;from math import*;r,s=input();s*=2*s;R=range(-r,r+1);print"\n".join("\t".join(str(pow(e,-(x*x+y*y)/s)/(pi*s))[:9]for x in R)for y in R)

यहाँ यह कोशिश करो !

Ungolfed:

from __future__ import division
from math import *
r,s = input()                         # Take input
s *= 2*s                              # Set s = 2*s^2; simplifies the expression
R = range(-r,r+1)                     # Range object; used twice

                                   # G(x,y)             # Stripped
print "\n".join("\t".join(str(pow(e,-(x*x + y*y)/s)/(pi*s))[:9] for x in R) for y in R)

Comments

from __future__ import division, वास्तव में?

— orlp