21

तुम एक दिया n-दर-मीटर पूर्णांकों, जहां की मैट्रिक्स n, m> 3 । आपका कार्य 3-बाय -3 सब-मैट्रिक्स को खोजना है जिसका सबसे कम मतलब है, और इस मूल्य को आउटपुट करता है।

नियम और स्पष्टीकरण:

पूर्णांक गैर-नकारात्मक होंगे
वैकल्पिक इनपुट और आउटपुट प्रारूप
आउटपुट कम से कम 2 दशमलव पॉइंट तक सटीक होना चाहिए (यदि यह नॉन-पूर्णांक है)
उप-पंक्तियों को लगातार पंक्तियों और स्तंभों से बना होना चाहिए

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

35    1    6   26   19   24
 3   32    7   21   23   25
31    9    2   22   27   20
 8   28   33   17   10   15
30    5   34   12   14   16
 4   36   29   13   18   11 

Minimum mean: 14

100    65     2    93
  3    11    31    89
 93    15    95    65
 77    96    72    34

Minimum mean: 46.111

1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1

Minimum mean: 1

4   0   0   5   4
4   5   8   4   1
1   4   9   3   1
0   0   1   3   9
0   3   2   4   8
4   9   5   9   6
1   8   7   2   7
2   1   3   7   9

Minimum mean: 2.2222

यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है। मैं लोगों को उन भाषाओं में उत्तर पोस्ट करने के लिए प्रोत्साहित करता हूं जो पहले से ही उपयोग की जाती हैं, भले ही वह पहले से कम न हो।

code-golf math matrix

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

यह भी दिलचस्प होगा कि जरूरी नहीं कि सन्निहित पंक्तियों और स्तंभों के साथ एक चुनौती हो

— लुइस मेंडो

नहीं, खुद आगे बढ़ें :-)

— लुइस मेंडो

क्या आप गणितीय या डेटा प्रकार के अर्थ में पूर्णांक का मतलब है, हम अभिन्न फ़्लोट्स का एक मैट्रिक्स ले सकते हैं?

— डेनिस

गणितीय अर्थ। क्या यह एक बात है जो मैंने यहां सीखी है, वह यह है कि आप विभिन्न भाषाओं में डेटा प्रकारों के बारे में धारणा बना सकते हैं ...

— स्टिव ग्रिफिन

मीठा, कि एक बाइट बचाता है। स्पष्टीकरण देने के लिए धन्यवाद।

— डेनिस

12

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

@(A)min(mean(im2col(A,[3,3])))

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

— rahnema1
स्रोत

11

जेली , 11 9 बाइट्स

+3\⁺€F÷9Ṃ

@ डेनिस को 2 बाइट्स थैंक्स दिए ।

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

व्याख्या

+3\⁺€F÷9Ṃ  Main link. Input: 2d matrix
+3\        Reduce overlapping sublists of size 3 by addition
   ⁺€      Repeat previous except over each row
     F     Flatten
      ÷9   Divide by 9
        Ṃ  Minimum

— मील की दूरी पर
स्रोत

1

ओह,> _ <बेशक: डी

— जोनाथन एलन

मुझे जेली के एक अनगुल्ड संस्करण में दिलचस्पी होगी, क्योंकि इसमें बहुत सारे उपयोगी कार्य हैं।

— J Atkin

1

+3\⁺€F÷9Ṃबाइट्स के एक जोड़े को बचाता है।

— डेनिस

@ डेनिस वाह, क्या वास्तव में +3\पहले प्रसंस्करण और डुप्लिकेट के रूप में है +3\€? ऐसा होने की उम्मीद नहीं थी

— मील

1

पार्सर अनिवार्य रूप से स्टैक-आधारित है; \पॉप्स 3और +क्विकलिंक को धक्का देता है, क्विकलिंक +3\को ⁺पॉप करता है और दो प्रतियों को धक्का देता है, फिर €सबसे ऊपर की कॉपी को पॉप करता है और मैपिंग संस्करण को धक्का देता है।

— डेनिस

8

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

@(M)min(conv2(M,ones(3)/9,'valid')(:))

— रेनर पी।
स्रोत

8

Matl , 13 9 बाइट्स

3thYCYmX<

@ Rahnema1 के उत्तर का पोर्ट ।

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

यह काम किस प्रकार करता है

इनपुट पर विचार करें

[100 65  2 93;
   3 11 31 89;
  93 15 95 65;
  77 96 72 34]

उदहारण के लिए।

3th   % Push [3 3]
      % STACK: [3 3]
YC    % Input matrix implicitly. Convert 3x3 sliding blocks into columns
      % STACK: [100   3  65  11;
                  3  93  11  15;
                 93  77  15  96;
                 65  11   2  31;
                 11  15  31  95;
                 15  96  95  72;
                  2  31  93  89;
                 31  95  89  65;
                 95  72  65  34]
Ym    % Mean of each column
      % STACK: [46.1111 54.7778 51.7778 56.4444]
X<    % Minimum of vector. Display implicitly
      % STACK: [46.1111]

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

7

गणितज्ञ, ३ 37 ३५ बाइट्स

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

Min@BlockMap[Mean@*Mean,#,{3,3},1]&

व्याख्या

Min@BlockMap[Mean@*Mean,#,{3,3},1]&
    BlockMap[                    ]&  (* BlockMap function *)
                        #            (* Divide the input *)
                          {3,3}      (* Into 3x3 matrices *)
                                1    (* With offset 1 *)
             Mean@*Mean              (* And apply the Mean function twice to
                                        each submatrix *)
Min                                  (* Find the minimum value *)

— जंगहवान मिन
स्रोत

बहुत बहुत चालाक!

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

5

पायथन 2 , 93 81 80 79 बाइट्स

f=lambda M:M[2:]and min(sum(sum(zip(*M[:3])[:3],()))/9,f(M[1:]),f(zip(*M)[1:]))

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

यह काम किस प्रकार करता है

च एक पुनरावर्ती समारोह है कि tuples की एक सूची लेता है (या किसी अन्य इंडेक्सेबल 2 डी iterable कि एक मैट्रिक्स का प्रतिनिधित्व करता है एम ) और रिकर्सिवली का मतलब की न्यूनतम गणना करता है 3 × 3 ऊपरी बाएँ कोने में submatrix और च के लिए रिकर्सिवली लागू किया एम के बिना इसकी पहली पंक्ति और इसके पहले कॉलम के बिना एम ।

f(M) निम्नलिखित करता है।

अगर एम कम से कम तीन पंक्तियां हैं, M[2:]एक खाली सूची है, जो च रिटर्न।

ध्यान दें कि, पहले रन में n> 3 के बाद से , प्रारंभिक एक खाली सूची नहीं लौटा सकता है।
यदि M की तीन पंक्तियाँ या अधिक हैं, M[2:]तो गैर-रिक्त है और इस प्रकार सत्य है, इसलिए कोड के andनिष्पादन के अधिकार को तीन निम्न मानों में से न्यूनतम लौटाता है।
```
min(sum(sum(zip(*M[:3])[:3],()))/9
```
M[:3]एम की पहली तीन पंक्तियों को पैदावार देता है , zip(*...)पंक्तियों और स्तंभों (ट्यूपल्स की एक सूची को उत्पन्न करता है) को स्थानांतरित sum(...,())करता है , सभी ट्यूपल्स को समेटता है (यह काम करता है क्योंकि +संघनन है), और sum(...)/9नौ एंगलर्स की परिणामी सूची के माध्य की गणना करता है।
```
f(M[1:])
```
रिकर्सिवली लागू होता है f करने के लिए एम अपनी पहली पंक्ति को हटा दिया है।
```
f(zip(*M)[1:])
```
transposes पंक्तियों और स्तंभों, परिणाम की पहली पंक्ति (ताकि के पहले कॉलम को हटा एम , और रिकर्सिवली लागू होता है च परिणाम के लिए।

ध्यान दें कि एक पुनरावर्ती कॉल में पहले से हटाई गई परत हमेशा एक पंक्ति होगी, इसलिए यदि एम पर्याप्त पंक्तियाँ हैं तो परीक्षण हमेशा पर्याप्त होगा।

अंत में, कोई यह उम्मीद कर सकता है कि कुछ पुनरावर्ती कॉल लौट रहे हैं [] समस्या होगी। हालांकि, पायथन में 2 , जब भी n एक संख्या है और एक एक iterable, तुलना है n < Aरिटर्न यह सच है , तो एक या अधिक संख्या और एक या अधिक iterables की न्यूनतम कंप्यूटिंग हमेशा सबसे कम संख्या वापस आ जाएगी।

— डेनिस
स्रोत

3

जे , 21 बाइट्स

[:<./@,9%~3+/\3+/\"1]

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

जम्मू में उपश्रेणियों पर काम करने का उचित तरीका _3कट के तीसरे ( ) रूप का उपयोग करना है ;.जहां x (u;._3) yक्रिया को लागू करना हैux सरणी के आकार के प्रत्येक पूर्ण उपप्रकार परy । इसका उपयोग करने वाला एक समाधान केवल 1 और बाइट की आवश्यकता है, लेकिन बड़े सरणियों पर अधिक कुशल होगा।

[:<./@,9%~3 3+/@,;._3]

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

व्याख्या

[:<./@,9%~3+/\3+/\"1]  Input: 2d array M
                    ]  Identity. Get M
                  "1   For each row
              3  \       For each overlapping sublist of size 3
               +/          Reduce by addition
          3  \         For each overlapping 2d array of height 3
           +/            Reduce by addition
       9%~             Divide by 9
[:    ,                Flatten it
  <./@                 Reduce by minimum

— मील की दूरी पर
स्रोत

1

मुझे पसंद है कि []जैसे वे कैसे मेल खाते हैं, लेकिन वे वास्तव में नहीं हैं।

— लिन

1

@ लिन एक सेकंड रुको, यह सही नहीं है। J को कई असंतुलित कोष्ठक के साथ दर्शकों को विचलित करना है। प्रयुक्त एक होना चाहिए [या |:)

— मील की दूरी पर

2

जेली , १, बाइट्स

चाल को याद किया, जैसा कि उनके उत्तर में मीलों से इस्तेमाल किया गया था , इसके अलावा एक n- वार संचयी कमी का उपयोग करके - पूरी पहली पंक्ति को +3\11 के साथ प्रतिस्थापित किया जा सकता है ।

ẆµL=3µÐfS€
ÇÇ€FṂ÷9

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

सभी सन्निहित उपनिवेशवादियों का पता लगाता है, केवल 3 की लंबाई रखने के लिए फ़िल्टर करता है और (जो सदिश करता है) फिर प्रत्येक परिणामी सूची के लिए दोहराता है, सभी 3 के योगों को 3 उप-मेट्रीज़ द्वारा प्राप्त करता है और अंत में उन लोगों को एक सूची में समतल करता है, न्यूनतम और लेता है 9 से विभाजित करता है (इस न्यूनतम राशि बनाने वाले तत्वों की संख्या)।

— जोनाथन एलन
स्रोत

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

— मील

2

पायथ, 19 बाइट्स

chSsMsMs.:R3C.:R3Q9

एक प्रोग्राम जो सूची की सूची का इनपुट लेता है और परिणाम प्रिंट करता है।

परीक्षण सूट

यह काम किस प्रकार करता है

[स्पष्टीकरण बाद में आ रहा है]

— TheBikingViking
स्रोत

1

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

lambda m,r=range:min(sum(sum(m[y+i][x:x+3])for i in r(3))/9for x in r(len(m[0])-3)for y in r(len(m)-3))

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

— OVS
स्रोत

1

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

h=lambda a:[map(sum,zip(*s))for s in zip(a,a[1:],a[2:])]
lambda a:min(map(min,h(zip(*h(a)))))/9.

रेप्लिट पर परीक्षण के मामले

एक अनाम फ़ंक्शन सूची की सूची ले रहा है, a- मैट्रिक्स की पंक्तियाँ।

सहायक कार्य h तीन आसन्न स्लाइस के माध्यम से ज़िप , और zip(*s)प्रत्येक के पारगमन में योग फ़ंक्शन को मैप करता है । यह एकल कॉलम के सभी ऊंचाई तीन स्लाइस को समेटता है।

अनाम फ़ंक्शन सहायक फ़ंक्शन को कॉल करता है, परिणाम पर फिर से सहायक फ़ंक्शन को स्थानांतरित करता है और कॉल करता है, फिर प्रत्येक का न्यूनतम और परिणाम का न्यूनतम पाता है, जिसे वह तब 9.औसत से प्राप्त करने के लिए विभाजित करता है ।

— जोनाथन एलन
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 107 98 96 बाइट्स

एक फ़ंक्शन जो पंक्तियों के ऊपर ट्रिपल के योगों की गणना करता है और फिर कॉलम के ऊपर एक ही काम करने के लिए खुद को कॉल करता है, न्यूनतम मूल्य का ट्रैक रखता है M।

f=m=>m.map((r,y)=>r.map((v,x)=>M=(z[x<<9|y]=v+=r[x+1]+r[x+2])<M?v:M),z=[M=1/0])&&m[1]?f([z]):M/9

जेएस उस तरह के सामान के लिए एक बिट क्रिया है और एक देशी का अभाव है zip() विधि । एक अधिक भोली दृष्टिकोण पर सिर्फ एक दर्जन बाइट्स को बचाने के लिए मुझे काफी समय लगा। (फिर भी, एक छोटी विधि शायद मौजूद है।)

गैर-पुनरावर्ती संस्करण, 103 बाइट्स

नील की मदद से 2 बाइट्स को बचाया

m=>m.map((r,y)=>y>1?r.map((v,x)=>[..."12345678"].map(i=>v+=m[y-i%3][x+i/3|0])&&(M=v<M?v:M)):M=1/0)&&M/9

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

कोड स्निपेट दिखाएं

f=m=>m.map((r,y)=>r.map((v,x)=>M=(z[x<<9|y]=v+=r[x+1]+r[x+2])<M?v:M),z=[M=1/0])&&m[1]?f([z]):M/9

console.log(f([
  [ 35,  1,  6, 26, 19, 24 ],
  [  3, 32,  7, 21, 23, 25 ],
  [ 31,  9,  2, 22, 27, 20 ],
  [  8, 28, 33, 17, 10, 15 ],
  [ 30,  5, 34, 12, 14, 16 ],
  [  4, 36, 29, 13, 18, 11 ]
]));

console.log(f([
  [ 100, 65,  2, 93 ],
  [   3, 11, 31, 89 ],
  [  93, 15, 95, 65 ],
  [  77, 96, 72, 34 ]
]));

console.log(f([
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ]
]));

console.log(f([
  [ 4, 0, 0, 5, 4 ],
  [ 4, 5, 8, 4, 1 ],
  [ 1, 4, 9, 3, 1 ],
  [ 0, 0, 1, 3, 9 ],
  [ 0, 3, 2, 4, 8 ],
  [ 4, 9, 5, 9, 6 ],
  [ 1, 8, 7, 2, 7 ],
  [ 2, 1, 3, 7, 9 ]
]));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

मुझे आपके तथाकथित भोले दृष्टिकोण में कुछ दिलचस्पी है, क्योंकि सबसे अच्छा मैं एक उचित शुद्ध दृष्टिकोण के साथ 113 बाइट्स कर सकता था:(a,b=a.map(g=a=>a.slice(2).map((e,i)=>a[i]+a[i+1]+e)))=>eval(`Math.min(${b[0].map((_,i)=>g(b.map(a=>a[i])))})`)/9

— नील

@ मुझे लगता है कि यह कुछ करीब था m=>m.map((r,y)=>r.map((v,x)=>[..."12345678"].map(i=>v+=(m[y+i/3|0]||[])[x+i%3])&&(M=v<M?v:M)),M=1/0)&&M/9, हालांकि मुझे लगता है कि मेरा पहला प्रयास वास्तव में इससे बड़ा था।

— अरनुलद

हालांकि, मैं एक बाइट दाढ़ी बनाने में सक्षम था m=>m.map((r,y)=>y>1&&r.map((v,x)=>[..."12345678"].map(i=>v+=m[y-i%3][x+i/3|0])&&(M=v<M?v:M)),M=1/0)&&M/9:।

— नील

@ नील कूल। यह एक और बाइट को बचाने की अनुमति देता हैm=>m.map((r,y)=>y>1?r.map((v,x)=>[..."12345678"].map(i=>v+=m[y-i%3][x+i/3|0])&&(M=v<M?v:M)):M=1/0)&&M/9

— Arnauld

1

05AB1E , 21 16 बाइट्स

2FvyŒ3ùO})ø}˜9/W

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

व्याख्या

2F         }       # 2 times do:
  v     }          # for each row in the matrix
   yŒ3ù            # get all sublists of size 3
       O           # reduce by addition
         )ø        # transpose matrix
            ˜      # flatten the matrix to a list
             9/    # divide each by 9
               W   # get the minimum

— Emigna
स्रोत

1

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

import Data.List
t(a:b:c:d)=a+b+c:t(b:c:d);t _=[]
s=(/9).minimum.(t=<<).transpose.map t

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

— रोमन Czyborra
स्रोत

सबसे छोटे माध्य के साथ सबमेट्रिक्स का पता लगाएं

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

जेली , 11 9 बाइट्स

व्याख्या

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

Matl , 13 9 बाइट्स

यह काम किस प्रकार करता है

गणितज्ञ, ३ 37 ३५ बाइट्स

पायथन 2 , 93 81 80 79 बाइट्स

यह काम किस प्रकार करता है

जे , 21 बाइट्स

व्याख्या

जेली , १, बाइट्स

पायथ, 19 बाइट्स

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

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

जावास्क्रिप्ट (ईएस 6), 107 98 96 बाइट्स

गैर-पुनरावर्ती संस्करण, 103 बाइट्स

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

05AB1E , 21 16 बाइट्स

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