একটি লাইন গ্রাফ মসৃণ করুন

Question

একটি পূর্ণসংখ্যা এর একটি ইনপুট দেওয়া এন এবং ধনাত্মক পূর্ণসংখ্যা একটি তালিকা মি ₁ , মি ₂ , ..., আউটপুট পূর্ণসংখ্যার একটি তালিকা মি ₁ ' , মি ₂ ' , ... যেখানে মি _এক্স ' গড় হিসাবে সংজ্ঞায়িত করা হয় মি _XN মাধ্যমে মি _{এক্স + N} ।

এই গড়গুলি গণনা করার সময়, সীমার বাইরে থাকা সূচকগুলি উপেক্ষা করুন (এবং আপনি সেই পরিমাণটি যোগফলকে কীভাবে ভাগ করছেন তা সামঞ্জস্য করুন)। n সর্বদা ≥ 1 হবে তবে মিটার দৈর্ঘ্যের অর্ধেক (বৃত্তাকার) বা তার বেশি কখনও হবে না। এর অর্থ এই যে ন্যূনতম দৈর্ঘ্য মিটার 4. উপাদান মি ধনাত্মক পূর্ণসংখ্যা হবে, কিন্তু আউটপুট অন্তত 3 দশমিক স্থানে সঠিক হওয়া উচিত।

তালিকাভুক্ত ইনপুট / আউটপুট উপাদানগুলি হ'ল হোয়াইট স্পেস- / কমা-বিভাজিত স্ট্রিং বা অ্যারে / তালিকা / ইত্যাদি হতে পারে। ইনপুট, যদি আপনার সমাধান একটি ফাংশন, আপনি অতিরিক্ত প্রথম যুক্তি লাগতে পারে এন এবং অতিরিক্ত আর্গুমেন্ট হিসাবে মি _এক্স (এই পাশাপাশি কমান্ড লাইন আর্গুমেন্ট প্রযোজ্য)।

এখানে একটি চাক্ষুষ উপস্থাপনা 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

Comments

স্পষ্টরূপে, এটি শূন্যগুলি প্রিপেন্ডিং এবং সংযোজন এবং তারপরে 3 দৈর্ঘ্যের প্রতিটি সুসংগত উপসর্গের মাধ্যম গণনা করা সমান?

— এল'েন্ডিয়া স্টারম্যান

@ এল'েন্দিয়া স্টারম্যান নং এর avg(0,1,2)মতো নয় avg(1,2)। "প্রান্তের কেস" (হেক্টর) এর জন্য, আপনার ইনপুট তালিকার অনেকগুলি উপাদানকে গড় হিসাবে নেওয়া উচিত নয়।

— Doorknob

আহ, ঠিক আছে, আমি এখন দেখতে।

— এল'েন্দিয়া স্টারম্যান

সম্পর্কিত

— অ্যালেক্স এ।

এই m_iইতিবাচক যে সীমাবদ্ধতা ছাড়া এটি আরও ভাল চ্যালেঞ্জ হতে পারে ।

— পিটার টেলর

Answer 1

পাইথ, 20 বাইট

m.O:vzeS,0-dQh+dQUvz

পরীক্ষা স্যুট

খুব সোজা, তালিকার বাইরে উপযুক্ত বিভাগটি স্লাইস করুন, তারপরে গড়।

Comments

@ থমাসকওয়া আমি চেষ্টা করেছিলাম, তবে মনে হচ্ছে আপনাকে Eমানচিত্রের বাইরে সংরক্ষণ করতে হবে কারণ এটি ভিতরে থাকলে এটি কোনও নতুন মান পড়ার চেষ্টা চালিয়ে যাবে। এটি এটি একই সংখ্যক বাইট গ্রহণ করে।

— FryAmTheEggman

Answer 2

এমএটিএল , 30 28 26 24 বাইট

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

মতলব এবং অক্টেভে পরীক্ষিত। ব্যবহার বর্তমান সংস্করণ (9.1.0) ভাষা / কম্পাইলার করুন।

ইনপুটটি হ'ল: প্রথমে উইন্ডোর দৈর্ঘ্য নিয়ন্ত্রণকারী নম্বর, তারপরে বিন্যাস সহ অ্যারে [1 4 5 7 10]।

সম্পাদনা (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');

এমএটিএল কোডটি অন্তর্ভুক্ত ইনপুট এবং স্বয়ংক্রিয় ফাংশন-ইনপুট ক্লিপবোর্ডের সাম্প্রতিক যুক্ত বৈশিষ্ট্যগুলি ব্যবহার করে:

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

Answer 3

সিজেম, 31 30 বাইট

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

ইনপুট ফর্ম্যাট হয় n [m1 m2 ... mx]।

সমস্ত পরীক্ষার কেস চালান। (টেস্ট স্যুটটি স্বয়ংক্রিয়ভাবে প্রয়োজনীয় ইনপুট ফর্ম্যাটে রূপান্তর করে)

এটি পূর্ব নির্ধারিত এবং nস্পেস যুক্ত করে কাজ করে , তারপরে দৈর্ঘ্যের সমস্ত সাবস্ট্রিংগুলি গ্রহণ করে 2n+1এবং স্পেসগুলি পুনরায় তার মাধ্যমগুলির পূর্বে গণনা করার পূর্বে সরানো।

Answer 4

জুলিয়া, 57 বাইট

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

এটি এমন একটি ফাংশন যা দুটি পূর্ণসংখ্যাকে গ্রহণ করে এবং একটি ফ্লেটের অ্যারে প্রদান করে।

এখানে পদ্ধতির খুব সোজা। আমরা ইনপুট অ্যারের বিভাগগুলির গড় গ্রহণ করে সামনে এবং পিছনে ছাঁটাই করে একটি নতুন অ্যারে তৈরি করি।

Answer 5

হাস্কেল, 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

Answer 6

পাইথ, 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

এখানে চেষ্টা করুন ।

Answer 7

জাভাস্ক্রিপ্ট (ES6), 104

মোট চলমান / চলমান নমুনা আকার। জাভাস্ক্রিপ্টে, একটি অ্যারের সীমানার বাইরে একটি মান পড়া অপরিজ্ঞাপিত দেয়, যা using ব্যবহার করে 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>

Answer 8

জাভাস্ক্রিপ্ট (ES6), 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>');