13

पूर्णांक n के इनपुट और धनात्मक पूर्णांक m ₁ , m ₂ , ... की सूची को देखते हुए, पूर्णांक m ₁ ' , m ₂ ' , ... जहाँ m _x ' को m के औसत के रूप में परिभाषित किया गया है m _{x + n के} माध्यम से _xn ।

इन औसतों की गणना करते समय, उन सूचकांकों को अनदेखा करें जो सीमा से बाहर हैं (और समायोजित करें कि आप उस राशि को किस हिसाब से बांट रहे हैं)। n हमेशा will 1 होगी लेकिन कभी भी m की लंबाई (गोल नीचे) या उससे अधिक नहीं होगी। इसका मतलब यह है कि मीटर की न्यूनतम लंबाई 4. है। मीटर में तत्व सकारात्मक पूर्णांक होंगे, लेकिन आउटपुट कम से कम 3 दशमलव स्थानों पर सटीक होना चाहिए।

जो इनपुट / आउटपुट एलिमेंट हैं, वे लिस्ट व्हाट्सएप- / अल्पविराम से अलग किए गए स्ट्रिंग्स या एरे / लिस्ट / आदि हो सकते हैं। इनपुट के लिए, यदि आपका समाधान एक फ़ंक्शन है, तो आप अतिरिक्त रूप से n _x और अतिरिक्त तर्कों का पहला तर्क m _{x के} रूप में ले सकते हैं (यह कमांड लाइन तर्कों पर भी लागू होता है)।

यहाँ एक दृश्य प्रतिनिधित्व है n=1:

1 4 5 7 10
__/ | | |
L avg(1,4) = 2.5
    | | |
\___/ | |
  L avg(1,4,5) = 3.333
      | |
  \___/ |
    L avg(4,5,7) = 5.333
        |
    \___/
      L avg(5,7,10) = 7.333

      \___
        L avg(7,10) = 8.5

Final output: 2.5 3.333 5.333 7.333 8.5

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण मामले ( ये मैन्युअल रूप से किए गए थे; कृपया मुझे किसी भी त्रुटि के बारे में सूचित करें ):

In                             Out
----------------------------------------------------------------------
n=1, m=12 6 3 9                9 7 6 6
n=1, m=1 4 5 7 10              2.5 3.333 5.333 7.333 8.5
n=1, m=1 3 3 7 4 2 4 2         2 2.333 4.333 4.666 4.333 3.333 2.666 3
n=2, m=1 3 5 9 10 14 15 16 23  3 4.5 5.6 8.2 10.6 12.8 15.6 17 18
n=3, m=1 1 1 1 1 1 1 1         1 1 1 1 1 1 1 1
n=3, m=1 2 3 4 5 6 7 8         2.5 3 3.5 4 5 5.5 6 6.5

code-golf arithmetic

— Doorknob
स्रोत

स्पष्ट होने के लिए, यह शून्य से पूर्ववर्ती और आकर्षक है और फिर लंबाई के प्रत्येक सन्निहित प्रत्येक के साधनों की गणना के समान है?

— एल'एंडिया स्ट्रोमैन

@ El'endiaStarman नंबर avg(0,1,2)समान नहीं है avg(1,2)। "एज केस" (हा) के लिए, आपको इनपुट सूची के कई तत्वों के रूप में औसत नहीं होना चाहिए।

— दरवाज़े

आह, ठीक है, मैं अब देखता हूं।

— एल'एंडिया स्ट्रोमैन

अजगर, 20 बाइट्स

m.O:vzeS,0-dQh+dQUvz

परीक्षण सूट

बहुत सीधा, बस सूची से बाहर उपयुक्त खंड टुकड़ा, फिर औसत।

— isaacg
स्रोत

@ThomasKwa मैंने यह कोशिश की, लेकिन ऐसा लगता है कि आपको Eनक्शे के बाहर स्टोर करना होगा क्योंकि यह एक नया मान पढ़ने की कोशिश करता रहेगा यदि यह अंदर है। इससे यह समान संख्या में बाइट लेता है।

— FryAmTheEggman

3

MATL , 30 28 26 24 बाइट्स

2*1+:g2X53$X+1Mbgbb3$X+/

मतलाब और ऑक्टेव पर परीक्षण किया गया। भाषा / संकलक के वर्तमान संस्करण (9.1.0) का उपयोग करता है ।

इनपुट है: पहली संख्या जो विंडो की लंबाई को नियंत्रित करती है, फिर प्रारूप के साथ सरणी [1 4 5 7 10]।

EDIT (20 मई 2016): इसे ऑनलाइन आज़माएं! लिंक में कोड को भाषा के संस्करण 18.0.0 के अनुरूप X+बदल दिया गया Y+है।

उदाहरण

>> matl
 > 2*1+:g2X53$X+1Mbgbb3$X+/
 >
> 1
> [1 4 5 7 10]
2.5 3.333333333333333 5.333333333333333 7.333333333333333               8.5

>> matl
 > 2*1+:g2X53$X+1Mbgbb3$X+/
 >
> 2
> [1 3 5 9 10 14 15 16 23]
3               4.5               5.6 8.199999999999999              10.6               2.8              15.6        17                18

व्याख्या

समतुल्य माटलब कोड होगा

n = 1; %// first input: number controlling window length
x = [1 4 5 7 10]; %// second input: array
result = conv(x,ones(1,2*n+1),'same')./conv(ones(size(x)),ones(1,2*n+1),'same');

MATL कोड अंतर्निहित इनपुट और स्वचालित फ़ंक्शन-इनपुट क्लिपबोर्ड की हाल ही में जोड़ी गई सुविधाओं का उपयोग करता है:

2*1+          % get implicit input "n". Multipliy by 2 and add 1
:g            % create a vector of 2*n+1 "true" values (will act as "one" values)
2X5           % 'same' string literal
3$X+          % get implicit input "x" (array). Convolution using three inputs
1M            % push all three inputs from last function
bgbb          % convert first input to "true" values. Will act as "one" values
3$X+          % convolution using three inputs
/             % divide element-wise. Implicitly print

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

2

CJam, 31 30 बाइट्स

ri_S*l~1$++\2*)ew{S-_:+\,d/}%`

इनपुट प्रारूप है n [m1 m2 ... mx]।

सभी परीक्षण मामलों को चलाएं। (स्वचालित रूप से परीक्षण सूट को आवश्यक इनपुट प्रारूप में परिवर्तित करता है।)

यह पूर्व- और nरिक्त स्थान को जोड़कर काम करता है , फिर लंबाई के सभी सबस्ट्रिंग ले रहा है 2n+1, और अपने साधनों की गणना करने से पहले रिक्त स्थान को फिर से हटा रहा है।

— मार्टिन एंडर
स्रोत

1

जूलिया, 57 बाइट्स

f(n,m)=[mean(m[max(1,i-n):min(end,i+1)])for i=1:endof(m)]

यह एक ऐसा फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और फ़्लोट्स की एक सरणी देता है।

यहाँ का दृष्टिकोण बहुत सीधा है। हम इनपुट ऐरे के अनुभागों को आगे ले जाकर एक नई व्यूह रचना करते हैं, जो आगे और पीछे की तरफ घूमता है।

— एलेक्स ए।
स्रोत

0

हास्केल, 97 95 बाइट्स

import Data.List
n#x|t<-2*n+1=[sum a/sum(1<$a)|a<-take t<$>take t(inits x)++tails x,length a>n]

प्रयोग उदाहरण: 2 # [1,3,5,9,10,14,15,16,23]-> [3.0,4.5,5.6,8.2,10.6,12.8,15.6,17.0,18.0]।

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

t<-2*n+1                      -- assign t to the maximum number of elements of a
                              -- of sublist
     take t(inits x)          -- build the sublists from t elements of the inits
                ++tails x     -- of the input and the tails of the input,
                              -- e.g. x=[1,2,3,4], t=3:
                              -- [[],[1],[1,2]] ++ [[1,2,3,4],[2,3,4],[3,4],[4],[]]
  a<-take t<$>                -- take at most t elements from every sublist
                ,length a>n   -- keep those with a minimum length of n+1
sum a/sum(1<$a)               -- calculate average, "sum(1<$a)" is the length of a

— nimi
स्रोत

0

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

.OMsM.:++J*]YKE]MQJhyK

स्पष्टीकरण:

.OM sM .: +               Means of flattens of sublists of length 2K+1 of
            + J *         
                  ] Y     J is E copies of [].
                  K E     Save E to a variable to use it later.
               ]MQ        the input
            J             Put J on both sides of ]MQ.
          h y K           2K+1

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 104

कुल / चल रहा नमूना आकार। जावास्क्रिप्ट में, किसी सरणी की सीमा के बाहर एक मान पढ़ना अपरिभाषित हो जाता है, जिसे 0 का उपयोग करके परिवर्तित किया जा सकता है।

(l,n,p=0)=>l.map((v,i)=>(p+=~l[i-n-1]-~l[i+n])/(n+1+Math.min(n,l.length-1-i,i)),l.map((v,i)=>p+=i<n&&v))

Ungolfed

(l, n) => {
    p = 0;
    for (i = 0; i < n; i++) p += v;
    r = [];
    for (i = 0; i < l.length; i++) {
        p += (l[i + n] || 0) - (i > n ? l[i - n - 1] : 0);
        r.push(p / Math.min(n, l.length - i - 1, i);
    }
    return r;
}

परीक्षा

f=(n,l,p=0)=>l.map((v,i)=>(p+=~l[i-n-1]-~l[i+n])/(n+1+Math.min(n,l.length-1-i,i)),l.map((v,i)=>p+=i<n&&v))

console.log=x=>O.textContent+=x+'\n';


;[
  [1,[12,6,3,9],[9,7,6,6]]
, [1,[1,4,5,7,10],[2.5,3.333,5.333,7.333,8.5]]
, [1,[1,3,3,7,4,2,4,2],[2,2.333,4.333,4.667,4.333,3.333,2.667,3]]
, [2,[1,3,5,9,10,14,15,16,23],[3,4.5,5.6,8.2,10.6,12.8,15.6,17,18]]
, [3,[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1]]
, [3,[1,2,3,4,5,6,7,8],[2.5,3,3.5,4,5,5.5,6,6.5]]
].forEach(t=>{
  var n=t[0],l=t[1],x=t[2],r=f(n,l)
  // verify (limited to 3 decimals)
  var ok = r.every((v,i)=>v.toFixed(3)==x[i].toFixed(3))
  
  console.log((ok?'OK   ':'Fail ')+n+' '+l+' -> '+r+' ('+x+')')
})

<pre id=O></pre>

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

— edc65
स्रोत

0

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

कोड:

F=(n,a)=>a.map((e,i)=>(s=a.slice(i<n?0:i-n,i+n+1))&&s.reduce((l,c)=>l+c)/s.length)

परीक्षा:

F=(n,a)=>a.map((e,i)=>(s=a.slice(i<n?0:i-n,i+n+1))&&s.reduce((l,c)=>l+c)/s.length)

document.write('<pre>' +
  [
    [1, [12, 6, 3, 9], [9, 7, 6, 6] ],
    [1, [1, 4, 5, 7, 10], [2.5, 3.333, 5.333, 7.333, 8.5] ],
    [1, [1, 3, 3, 7, 4, 2, 4, 2], [2, 2.333, 4.333, 4.667, 4.333, 3.333, 2.667, 3] ],
    [2, [1, 3, 5, 9, 10, 14, 15, 16, 23], [3, 4.5, 5.6, 8.2, 10.6, 12.8, 15.6, 17, 18] ],
    [3, [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1] ],
    [3, [1, 2, 3, 4, 5, 6, 7, 8], [2.5, 3, 3.5, 4, 5, 5.5, 6, 6.5] ]
  ].map(t => {
    var [n, m, e] = t;
    var r = F(n, m);
    // verify to precision of 3 decimals
    var test = r.every((v, i) => v.toPrecision(3) === e[i].toPrecision(3));

    return 'F(' + n + ', [' + m + '])\t' + (test ? 'Pass' : 'Fail') +
      '\n\t{' + r + '} ' + (test ? '=' : '≠') + ' {' + e + '}';
  }).join('\n\n') +
  '</pre>');