14

MATLAB में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं, जिन्हें सामान्य रूप से MATLAB के लिए कम से कम कुछ विशिष्ट कोड गोल्फ समस्याओं पर लागू किया जा सकता है (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)। कृपया प्रति उत्तर एक टिप पोस्ट करें।

code-golf tips matlab

— राम
स्रोत

3

संबंधित, लेकिन डुप्लिकेट नहीं: ऑक्टेव में गोल्फ के लिए टिप्स

— डेनिस जहरुद्दीन

MatLab में ज्ञापन कार्य

— mbomb007

10

गोल्फ शुरू करने से पहले कुछ ऐसा जानना चाहिए:

MATLAB गणना में एक चरित्र अपने ascii कोड के समान व्यवहार करता है।

'abc' - 'a'  % Returns: [0 1 2]
'123' - '0'  % Returns: [1 2 3]
'“' == 8220  % Returns: 1 (logical)
'a':'e'==100 % Returns: [0 0 0 1 0] (logical)

— डेनिस जहरुद्दीन
स्रोत

9

संपत्ति के नाम को छोटा करना

MATLAB में, गुणों की पहचान करने वाले तारों को तब तक छोटा किया जा सकता है जब तक कि इसमें अस्पष्टता न हो।

plot(X,'C','k') % Ambiguous property found.
plot(X,'Co','k') % Expands to Color  (black)

यह वास्तव में मुझे एक चुनौती मिली :)

— Sanchises
स्रोत

2

बहुत अच्छा, हालांकि उत्तर सही है मैं इस बात पर जोर देना चाहता हूं कि यह name, valueजोड़े के नाम पर लागू होता है जैसा कि ऊपर दिखाया गया है। (इसलिए चीजों की तरह नहीं sort(rand(4,1),'descend'))

— डेनिस जहरुद्दीन

1

यह उन चीजों में से कुछ पर भी लागू होता है, जैसे conv(1:5,[1 1],'s')किconv(1:5,[1 1],'same')

— लुइस मेंडो

6

चार के रूप में कास्टिंग एक चर के साथ संगति द्वारा किया जा सकता है:

x='a'+magic(5) % Array with character codes of several letters

char(x) % The standard way
['' x] % The compact way

हालांकि यह केवल एक चार बचाता है, यह काफी अक्सर इस्तेमाल किया जा सकता है।

— डेनिस जहरुद्दीन
स्रोत

5

स्ट्रिंग्स सिर्फ चरित्र पंक्ति वैक्टर हैं। इसका मतलब है कि इसके बजाय

for i=numel(str)
    a=str(i)
    ...
end

आप बस लिख सकते हैं

for(a=str)
    ...
end

पहली बार मैंने इसका इस्तेमाल किया: /codegolf//a/58387/32352

— Sanchises
स्रोत

4

असतत फूरियर रूपांतरण के माध्यम से एकता की जड़ें

एक सकारात्मक पूर्णांक को देखते हुए n, मानक तरीका उत्पन्न करने के लिए nमई के जड़ों की एकता है

exp(2j*pi*(0:n-1)/n)

इससे जड़ें शुरू होती हैं 1और सकारात्मक कोणीय दिशा में चलती हैं। यदि ऑर्डर मायने नहीं रखता है, तो इसे छोटा किया जा सकता है

exp(2j*pi*(1:n)/n)

चूँकि exp(2j*pi/4)काल्पनिक इकाई ( j) के बराबर है , इसे इस प्रकार और अधिक संक्षेप में लिखा जा सकता है ( @flawr के कारण चाल ):

j.^(4*(0:n-1)/n)

या

j.^(4*(1:n)/n)

लेकिन असतत फूरियर रूपांतरण एक और भी छोटा रास्ता प्रदान करता है (दो अनावश्यक कोष्ठक हटाने के लिए @flawr के लिए धन्यवाद):

fft(1:n==n)

जो 1सकारात्मक कोणीय दिशा में शुरू और आगे बढ़ने वाली जड़ें देता है ; या

fft(1:n==2)

जो 1नकारात्मक कोणीय दिशा में शुरू और आगे बढ़ता है।

उपरोक्त सभी यहाँ आज़माएँ ।

— लुइस मेंडो
स्रोत

महान चाल! तुम भी इसे नीचे गोल्फ कर सकते हैंfft(1:n==2)

— दोष

@flawr मैं पूर्ववर्ती नियमों को कभी नहीं जानता ... धन्यवाद!

— लुइस मेंडो

3

nnz कभी-कभी आप कुछ बाइट्स बचा सकते हैं:

कल्पना कीजिए कि आप एक तार्किक मैट्रिक्स का योग चाहते हैं A। sum(sum(A))या इसके बजाय sum(A(:)), आप उपयोग कर सकते हैं nnz(a)( nnzसंक्षेप में लागू होता है (:))।
यदि आप किसी सरणी के तत्वों की संख्या जानना चाहते हैं, और आप सुनिश्चित कर सकते हैं कि कोई शून्य नहीं है, तो इसके बजाय numel(x)आप उपयोग कर सकते हैं nnz(x)। यह उदाहरण के लिए लागू होता है यदि xएक स्ट्रिंग है।

— लुइस मेंडो
स्रोत

3

मेट्रिसेस में वैक्टर पर गर्भाधान।

मैट्रिक्स के रूप में वेक्टर के एक सेट को देखते हुए, आप वास्तव में लूप के लिए एकल के माध्यम से उन पर पुनरावृति कर सकते हैं

for v=M
    disp(v);
end

जबकि "परंपरागत रूप से" आप शायद इसे पसंद करेंगे

for k=1:n
    disp(M(:,k));
end

मैंने केवल इस ट्रिक के बारे में सिर्फ इस चुनौती में @Suever से सीखा है ।

— flawr
स्रोत

3

_{संबंधित, लेकिन ऑक्टेव के लिए समान टिप्स नहीं ।}

MATLAB और ऑक्टेव दोनों की एक छोटी ज्ञात और उपयोग की जाने वाली विशेषता यह है कि अधिकांश अंतर्निहित कार्यों को कोष्ठक के बिना कहा जा सकता है, इस मामले में वे इसे एक स्ट्रिंग के रूप में जो भी व्यवहार करेंगे (जब तक कि इसमें रिक्त स्थान नहीं होते)। यदि इसमें ऐसे स्थान हैं जिन्हें आपको उद्धरण चिह्नों की आवश्यकता है। इसका उपयोग करते समय बाइट को बचाने के लिए अक्सर किया जा सकता है disp:

disp('Hello, World!')
disp 'Hello, World!'

अन्य, कम उपयोगी उदाहरणों में शामिल हैं:

nnz PPCG
ans = 4

size PPCG
ans = 1  4

str2num 12
ans = 12

मैंने वास्तव में इसे दो बार "कितना उच्च आप गिन सकते हैं?" -चुनौती:

strchr sssssssssssssst t

strchr('sssssssssssssst','t')और रिटर्न के बराबर है 15।

nnz nnnnnnnnnnnnnn

nnz('nnnnnnnnnnnnnn')और रिटर्न के बराबर है 14।

की तरह सामान gt r sभी काम करता है (के बराबर 'r'>'s'या gt('r','s')।

— स्टीवी ग्रिफिन
स्रोत

2

अंतर्निहित onesऔर zerosआमतौर पर अंतरिक्ष की बर्बादी हैं। आप समान परिणाम को केवल एक सरणी / मैट्रिक्स (वांछित आकार के) को 0 से गुणा करके (आउटपुट प्राप्त करने के लिए zeros) कर सकते हैं और यदि आप आउटपुट चाहते हैं तो 1 जोड़ सकते हैं ones।

d = rand(5,2);

%// Using zeros
z = zeros(size(d));

%// Not using zeros
z = d*0;

%// Using ones
o = ones(size(d));

%// Not using ones
o = 1+d*0

यह भी काम करता है यदि आप शून्य या किसी वेक्टर के एक आयाम के आकार का एक पंक्ति वेक्टर बनाना चाहते हैं।

p = rand(5,2);

z = zeros(size(p,1), 1);
z = 0*p(:,1);

o = ones(size(p, 1), 1);
o = 1+0*p(:,1);

यदि आप एक विशिष्ट आकार का एक मैट्रिक्स बनाना चाहते हैं, जिसका आप उपयोग कर सकते हैं, zerosलेकिन आप केवल अंतिम तत्व को 0 पर असाइन कर सकते हैं और बाकी में MATLAB भर सकते हैं।

%// This
z = zeros(2,3);

%// vs. This
z(2,3) = 0;

— Suever
स्रोत

2

मुझे ~(1:n)1-डी शून्य वैक्टर के लिए उपयोग करना पसंद है ।

— सिंटेक्स

2

2 डी कन्वेंशन गुठली

यह शायद एक आला विषय है, लेकिन जाहिर है कुछ लोग यहां विभिन्न चीजों के लिए कन्वेंशन का उपयोग करना पसंद करते हैं। ^{[प्रशस्ति पत्र की जरूरत]}

2 डी में निम्नलिखित गुठली अक्सर आवश्यक होती है:

0 1 0
1 1 1
0 1 0

इसका उपयोग करके प्राप्त किया जा सकता है

v=[1,2,1];v'*v>1 %logical
v=[1,0,1];1-v'*v  %as numbers

जो इससे छोटा है

[0,1,0;1,1,1;0,1,0]

एक और कर्नेल अक्सर इस्तेमाल किया जाता है

0 1 0
1 0 1
0 1 0

जिसका उपयोग करके छोटा किया जा सकता है

v=[1,-1,1];v'*v<0   % logical
[0,1,0;1,0,1;0,1,0] % naive verison

— flawr
स्रोत

संख्या के रूप में दूसरा कर्नेल, समान बाइट गिनती:toeplitz([0 1 0])

— लुइस मेंडो

2

मैं अक्सर स्वयं का उपयोग करता हुआ पाता हूं meshgridया ndgrid, मान लीजिए कि हम एक मांडेलब्रोट छवि की गणना करना चाहते हैं, तो हम उदाहरण के लिए आरंभ करते हैं

[x,y]=meshgrid(-2:1e-2:1,-1:1e-2,1)

अब मैंडलब्रॉट सेट के लिए हम एक और मैट्रिक्स की जरूरत cके आकार की xऔर yलेकिन शून्य से प्रारंभ। इसे आसानी से लिखकर किया जा सकता है:

c=x*0;

आप इसे दूसरे मूल्य पर भी आरंभ कर सकते हैं:

c=x*0+3;

लेकिन आप वास्तव में सिर्फ एक और आयाम जोड़कर कुछ बाइट्स बचा सकते हैं meshgrid/ndgrid:

[x,y,c]=meshgrid(-2:1e-2:1,-1:1e_2,1, 0); %or for the value 3
[x,y,c]=meshgrid(-2:1e-2:1,-1:1e_2,1, 3);

और आप इसे जितनी बार चाहें उतनी बार कर सकते हैं:

[x,y,c1,c2,c3,c4,c5]=meshgrid(-2:1e-2:1,-1:1e_2,1, 1,pi,exp(3),1e5,-3i)

— flawr
स्रोत

ध्यान दें कि इस बीच में स्वचालित प्रसारण है: कई मामलों में पहले उदाहरण को प्रतिस्थापित किया जा सकता है x=-2:1d-2:1;y=x'।

— दोष

0

कार्यों के अनुक्रम का योग

कार्यों के संक्षेपण के लिए f (x_n) जहां n लगातार पूर्णांक का एक वेक्टर है, समसामयिकी की बजाय सामंजस्य की सलाह दी जाती है।
```
Syms x;symsum(f(x),x,1,n);
Sum(feval(@(x)f(x),1:n));
```
ध्यान दें कि जोड़ीदार बाइनरी ऑपरेशन के बजाय एक प्राथमिक ऑपरेशन .*और ./आवश्यक है *और/
यदि फ़ंक्शन को सरलता से लिखा जा सकता है, तो अंतिम तरीकों में से कोई भी उपयुक्त नहीं है।

उदाहरण के लिए यदि फ़ंक्शन है logतो आप बस यह कर सकते हैं: sum(log(1:n))जो प्रतिनिधित्व करता है:
```
Sum(f(1:n));
```
log(n)/x^nआप कर सकते हैं अपेक्षाकृत परिष्कृत कार्यों के लिए:
```
Sum(log(1:n)./5.^(1:n))
```
और कुछ मामलों में कम जब एक समारोह लंबा है f(x)=e^x+sin(x)*log(x)/x...।
```
Sum(feval(@(y)e.^(y)+sin(y).*log(y)./y,1:n))
```
यह उल्लेखनीय रूप से कम है sum(feval(@(y)e.^(1:n)+sin(1:n).*log(1:n)./(1:n),1:n))

नोट: इस चाल को अन्य समावेशी ऑपरेटरों के लिए लागू किया जा सकता है prodयाmean

— Abr001am
स्रोत

MATLAB में गोल्फ के लिए युक्तियाँ

असतत फूरियर रूपांतरण के माध्यम से एकता की जड़ें

2 डी कन्वेंशन गुठली

कार्यों के अनुक्रम का योग