26

আমি কিছুক্ষণের জন্য এই সাইটের চারপাশে ঘুরে বেড়াচ্ছি, তবে সম্প্রতি কিছুটা চ্যালেঞ্জের চেষ্টা করার জন্য সত্যিই আগ্রহী হয়ে উঠেছে। আমি বিদ্যমান কোড-গল্ফ সম্পর্কিত কয়েকটি বিষয় নিয়ে আমার হাত দেওয়ার চেষ্টা করছিলাম, তবে গতকাল আমার কাছে ইন্টারনেটের অ্যাক্সেস ছিল না এবং এর মধ্যে আমি আমার নিজের চ্যালেঞ্জটি ভেবেছিলাম।

আপনার কাজটি এমন একটি প্রোগ্রাম বা ফাংশন তৈরি করা যা ফ্লোট aএবং একটি পূর্ণসংখ্যার অ্যারে নেয় n, তারপরে প্রতিটি মানটিকে aতার পাশাপাশি দুটি এর গড়তে সেট করে, nবার। বারবার যখন ক্রমবর্ধমান মানগুলির সাথে ব্যবহার করা হয় তখন এটি nএকটি তরঙ্গের মতো গতি তৈরি করে:

তরঙ্গ গতি

সুনির্দিষ্ট:

যদি সেখানে কেবলমাত্র একটি আইটেম থাকে aবা যদি n0 বা তার চেয়ে কম হয় তবে প্রোগ্রামটির আসল অ্যারেটি ফিরিয়ে দেওয়া উচিত।
ইনপুট এবং আউটপুটগুলি আপনার ইচ্ছা মতো যে কোনও বিন্যাসে থাকতে পারে, যতক্ষণ না সেগুলি দৃশ্যত পৃথক হয়।

প্রতিটি পদক্ষেপের জন্য:

প্রথম আইটেমটি aনিজের এবং পরবর্তী আইটেমের গড় হওয়া উচিত।
শেষ আইটেমটি aনিজের এবং পূর্ববর্তী আইটেমের গড় হওয়া উচিত।
অন্য যে কোনও আইটেমের aআগের আইটেম এবং পরবর্তী আইটেমের গড় হওয়া উচিত।
আপনি আগের ধাপের অ্যারে গণনা করছেন তা নিশ্চিত করুন এবং বর্তমানটি নয়!

পরীক্ষার কেস: দ্রষ্টব্য: আপনার ইনপুট / আউটপুটগুলি এই ফর্ম্যাটে থাকতে হবে না!

[0, 0, 1, 0, 0], 1          -> [0, 0.5, 0, 0.5, 0]
[0, 0, 1, 0, 0], 2          -> [0.25, 0, 0.5, 0, 0.25]
[0, 0, 1, 0, 0], 0          -> [0, 0, 1, 0, 0]
[0, 0, 1, 0, 0], -39        -> [0, 0, 1, 0, 0]
[0, 16, 32, 16, 0], 1       -> [8, 16, 16, 16, 8]
[0, 1, 2, 3, 4, 5], 1       -> [0.5, 1, 2, 3, 4, 4.5]
[0, 64], 1                  -> [32, 32]
[0], 482                    -> [0]
[32, 32, 32, 16, 64, 16, 32, 32, 32], 4 -> [33, 27, 40, 22, 44, 22, 40, 27, 33]

এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর। এক সপ্তাহের মধ্যে বিজয়ী বাছাই করা হবে (২ আগস্ট)। শুভকামনা!

সম্পাদনা করুন: পুরোপুরি 18 বাইট সহ বিজয়ী, @ আইস্যাককে অভিনন্দন !

code-golf array-manipulation

— ETHproductions
সূত্র

2

এই চ্যালেঞ্জটি উন্নত করার জন্য আমার পরামর্শটি nহ'ল সরবরাহ করা aহয় না এবং সরবরাহ করা হয় না - এগুলি থেকে মুক্তি পাওয়ার জন্য - তারা আসলে বেশি কিছু দেয় না।

— isaacg

আমি বিশ্বাস করি চূড়ান্ত পরীক্ষার কেসটি ভুল। n4 হতে হবে, 5 নয়

— isaacg

@ আইস্যাকগ: হ্যাঁ, এখন আমি আবার এটি তাকিয়ে দেখছি, এই মামলাগুলি এত গুরুত্বপূর্ণ বলে মনে হচ্ছে না। আমি এটি পরিবর্তন করেছি এবং ভুল উদাহরণটিও ঠিক করেছি। এই জিনিসগুলি নির্দেশ করার জন্য ধন্যবাদ!

— ইটিএইচ প্রোডাকশনস

1

আপনি যদি সত্যিই এটি খালি তালিকাগুলি পরিচালনা করতে চান তবে আপনি এটি পরীক্ষার কেসগুলির তালিকায় যুক্ত করতে চাইতে পারেন। আমি কেবল লক্ষ্য করেছি যে আমার সমাধান সেই ক্ষেত্রে ব্যর্থ। ব্যক্তিগতভাবে, আমি সমস্যার বড় ফ্যান নই যেখানে সমাধানের একটি বড় অংশ বিশেষ ক্ষেত্রে পরিচালনা করার জন্য।

— রেটো কোরাাদি

@ রেটোকোরাদি দুঃখিত, আমি উদাহরণগুলি থেকে অপসারণ করার সময় নিয়ম থেকে "খালি তালিকা" কেস সরিয়ে দিতে ভুলে গিয়েছিলাম। নোটিশের জন্য ধন্যবাদ!

— ETH প্রোডাকশনগুলি

11

পাইথ, 46 18 বাইট

ucR2sV+hGGt+GeG.*Q

এই কোডটি ফর্মটিতে ইনপুট প্রত্যাশা করে iterations, [wave1, wave2, wave3 ...], যেমন নীচের প্রথম লিঙ্কে দেখানো হয়েছে।

প্রদর্শন. পরীক্ষার জোতা।

প্রোগ্রামটি uইনপুট তালিকায় হ্রাস ( ) ফাংশনটির মধ্যে কোড প্রয়োগ করে , পুনরাবৃত্তির সংখ্যার চেয়ে বহুগুণ বেশি কাজ করে।

আমি তালিকায় তরঙ্গ প্রচার কার্য প্রদর্শন করব [0, 1, 2, 3, 4, 5], যা এতে রয়েছে G:

+hGGprepends Gকরতে 'প্রথম উপাদান G, বিরচন [0, 0, 1, 2, 3, 4, 5]।

t+GeGআপনার স্বাক্ষরে G's করা শেষ উপাদান Gএবং, তার প্রথম উপাদান সরিয়ে ফেলা হবে বিরচন [1, 2, 3, 4, 5, 5]।

sVপ্রথম তালিকা থেকে জোড়া গঠন [[0, 1], [0, 2], [1, 3], [2, 4], [3, 5], [4, 5]]করে, প্রথম তালিকার চূড়ান্ত উপাদানটি কেটে ফেলা হয়। তারপরে, জোড়াটি sফাংশনটির মাধ্যমে দেওয়া হয় , দেওয়া হয় [1, 2, 4, 6, 8, 9]।

cR2সমস্ত সংখ্যাকে 2 দ্বারা বিভক্ত করতে ভাসমান পয়েন্ট বিভাজন ব্যবহার করে কাঙ্ক্ষিত ফলাফল [0.5, 1.0, 2.0, 3.0, 4.0, 4.5],।

— isaacg
সূত্র

8

স্নোম্যান 1.0.0 , 219 অক্ষর

{vg" "aS:10sB;aM0aa,AAg**-:|al|'NdE'0nRal@(%}{->:1*?{0AaG;:?{;bI:dUNiNwR'NdEwRaC;aM(~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;:0wRdUaCwR*?{#aC;#bI:*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM|*0*;bR|tSsP

"পাঠযোগ্যতা" এর জন্য লাইন ব্রেকগুলি সহ:

{vg" "aS:10sB;aM0aa,AAg**-:|al|'NdE'0nRal@(%}{->:1*?{0AaG;:?{;bI:dUNiNwR'NdEwRaC;
aM(~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;:0wRdUaCwR*?{#aC;#
bI:*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM|*0*;bR|tSsP

অবরুদ্ধ / অবিহীন সংস্করণ:

{vg" "aS:10sB;aM  // input space-separated list of numbers
0aa,AAg           // get first element and array of all-but-first elements
**                // discard original input and the 0

// execute the following (input[0]) times
-:
    |al|'NdE'0nR               // get range from (0..input.length-1]
    al@(%}{->:1*?{0AaG;:?{;bI  // chop off first element if any
    :dUNiNwR'NdEwRaC;aM        // map n -> [n-1 n+1]
    // if the input consisted of a single element, append [0 0]
    // otherwise prepend [0 1] and append [len-2 len-1]
    (~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;
        :0wRdUaCwR*?{#aC;#bI
    // map indeces to avg(input[i1], input[i2])
    :*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM
    // replace old input, reset permavar
    |*0*
;bR

|tSsP  // output result

নমুনা I / O ফর্ম্যাট:

llama@llama:...Code/snowman/ppcg53799waves$ snowman waves.snowman 
4 32 32 32 16 64 16 32 32 32
[33 27 40 22 44 22 40 27 33]

— ডোরকনব
সূত্র

2

এটি মারাত্মক সুন্দর।

— kirbyfan64sos

5

পাইথ - 25 24 বাইট

পুনরাবৃত্তি করতে কমাতে, হ্রাস ব্যবহার করে।

u.ecs@L++hGGeG,khhk2GvzQ

এটি এখানে অনলাইনে চেষ্টা করুন ।

— Maltysen
সূত্র

5

কোলাহল, 164 145 বাইট

(define(f a n)(if(< n 1)a(f(let([l(length a)][r list-ref])(for/list([i(in-range l)])(/(+(r a(max(- i 1)0))(r a(min(+ i 1)(- l 1))))2)))(- n 1))))

Ungolfed

(define (f a n)
  (if (< n 1)
      a
      (f (let ([l (length a)] [r list-ref])
           (for/list ([i (in-range l)])
             (/ (+ (r a (max (- i 1) 0))
                   (r a (min (+ i 1) (- l 1))))
                2))) (- n 1))))

দ্রষ্টব্য, এটি #lang racketচালানোর জন্য আপনার লাইনের প্রয়োজন হতে পারে ।

— Winny
সূত্র

4

আর, 109 বাইট

function(x,n){l=length(x);t=if(l>2)c(.5,0,.5)else if(l==2)c(.5,.5)else 1;for(i in 1:n)x=filter(x,t,c=T);c(x)}

এটি একটি নামহীন ফাংশন তৈরি করে যা একটি ভেক্টর এবং একটি পূর্ণসংখ্যা গ্রহণ করে এবং একটি ভেক্টরকে ফিরিয়ে দেয়। এখানে পন্থাটি হ'ল ইনপুটটিকে অবিচ্ছিন্ন সময় সিরিজ হিসাবে বিবেচনা করা এবং লিনিয়ার কনভোলিউশন ফিল্টার প্রয়োগ করা।

অবহেলিত + ব্যাখ্যা:

f <- function(x, n) {
    # Define filter coefficients
    t <- if (length(x) > 2)
        c(0.5, 0, 0.5)
    else if (length(x) == 2)
        c(0.5, 0.5)
    else
        1

    # Apply the filter n times
    for (i in 1:n) {
        # The circular option wraps the filter around the edges
        # of the series, otherwise the ends would be set to NA.
        x <- filter(x, t, circular = TRUE)
    }

    # Returned the modified input, stripped of the extraneous
    # properties that the filter function adds.
    c(x)
}

উদাহরণ:

> f(c(32, 32, 32, 16, 64, 16, 32, 32, 32), 4)
[1] 33 27 40 22 44 22 40 27 33

> f(0, 482)
[1] 0

> f(c(0, 64), 1)
[1] 32 32

— অ্যালেক্স এ।
সূত্র

4

হাস্কেল, 76 টি অক্ষর

কৌশলটি হ'ল তালিকার শুরুতে প্রথম সংখ্যাটি এবং সীমানা শর্তের সাথে ডিলের পরিবর্তে তালিকার শেষের একটিতে যুক্ত করা।

f a@(x:s)=(/2)<$>zipWith(+)(x:a)(s++[last s])
f x=x
a#n|n<1=a|n>0=f a#(n-1)

পরীক্ষা:

λ: [0, 0, 1, 0, 0]#1  
[0.0,0.5,0.0,0.5,0.0]
λ: [0, 0, 1, 0, 0]#2
[0.25,0.0,0.5,0.0,0.25]
λ: [0, 0, 1, 0, 0]#0  
[0.0,0.0,1.0,0.0,0.0]
λ: [0, 0, 1, 0, 0]#(-39) 
[0.0,0.0,1.0,0.0,0.0]
λ: [0, 16, 32, 16, 0]#1
[8.0,16.0,16.0,16.0,8.0]
λ: [0, 1, 2, 3, 4, 5]#1
[0.5,1.0,2.0,3.0,4.0,4.5]
λ: [0, 64]#1
[32.0,32.0]
λ: [0]#482
[0.0]
λ: [32, 32, 32, 16, 64, 16, 32, 32, 32]#4
[33.0,27.0,40.0,22.0,44.0,22.0,40.0,27.0,33.0]

— Keyran
সূত্র

1

আপনি পরিবর্তে 2-যুক্তি কার্যকারিতা ও রক্ষীদের জন্য পোঁতা অপারেটার ব্যবহার করে একটি কয়েক বাইট সংরক্ষণ করতে পারবেন if then else, অর্থাৎ cহয়ে a#n|n<1=a|1<2=iterate f a!!nএবং sহয়ে x!y=(x+y)/2(এবং বলা হয় ...zipWith(!)(x:a)...)।

— নিমি

ধন্যবাদ! প্রহরীরা কীভাবে এক-লাইনের অভিব্যক্তিগুলিতে কাজ করে তা জানতেন না।

— কিরান

আরেকটি 2 বাইট: করতে cএকটি পোতা অপারেটর বলে #: a#n|n<1=a|1<2=iterate f a!!n। এটিকে কল করুন [0, 0, 1, 0, 0] # 2।

— নিমি

2

সিজেম, 23 22 বাইট

q~{_(@)@@+@@+.+.5f*}*`

এটি অনলাইনে চেষ্টা করুন

ইনপুটটি সিজেএম তালিকার বিন্যাসে রয়েছে, যেমন শেষ উদাহরণের জন্য:

[32 32 32 16 64 16 32 32 32] 4

আউটপুটটিও একটি সিজেএম তালিকা:

[33.0 27.0 40.0 22.0 44.0 22.0 40.0 27.0 33.0]

প্রাথমিক পদ্ধতির হ'ল প্রতিটি পদক্ষেপে ভেক্টরকে একটি অবস্থান বামে এবং একটি অবস্থানকে ডানে স্থানান্তরিত করা হয়। দুটি ভেক্টরের প্রত্যেককেই প্রথম / শেষ উপাদান দিয়ে প্যাড করা হয় এবং তারপরে দুটি ভেক্টরের গড় গণনা করা হয়।

ব্যাখ্যা:

q~    Get and interpret input.
{     Loop over repeat count.
  _     Copy list.
  (     Pop off left element.
  @     Get original list to top.
  )     Pop off right element.
  @@    Get first element and list with last element removed to top.
  +     Concatenate. This gives right-shifted list with first element repeated.
  @@    Get list with first element removed and last element to top.
  +     Concatenate. This gives left-shifted list with last element repeated.
  .+    Perform vector addition of two shifted lists.
  .5f*  Multiply sum by 0.5 to give average.
}*    End loop over repeat count.
`     Convert result array to string.

— রেটো কোরাদি
সূত্র

আমি ওপি নই, তবে "যদি শূন্য বা একটি আইটেমে কোনও কিছু ঘটে থাকে, বা n 0 বা তার চেয়ে কম হয় তবে প্রোগ্রামটি আসল অ্যারেটি ফিরিয়ে আনতে হবে" "

— মালটিসেন

2

জাভা, 181 বাইট

গল্ফ করা সংস্করণ এখানে:

float[]g(float[]i,int n){float[]c=i.clone();int l=c.length,s=1;if(n>0&&l>1){c[0]=(i[0]+i[1])/2f;c[--l]=(i[l]+i[l-1])/2f;while(s<l)c[s]=(i[s-1]+i[++s])/2f;return g(c,n-1);}return i;}

Ungolfed:

float[] g(float[] i, int n) {
    float[] c = i.clone();
    int l = c.length,s=1;
    if(n>0&&l>1) {
        c[0] = (i[0]+i[1])/2f;
        c[--l] = (i[l]+i[l-1])/2f;
        while(s<l)
            c[s] = (i[s-1] + i[++s]) / 2f;
        return g(c, n-1);
    }
    return i;
}

আমি জাভা দিয়ে যতটা সম্ভব অ্যাসাইনমেন্ট এবং শর্তসাপেক্ষ ছোট করার চেষ্টা করেছি। উন্নতি অবশ্যই স্বাগত।

— JackWhiteIII
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 153 132 67 অক্ষর

আমি 6 মাস পরে আমার প্রথম উত্তরে ফিরে আসি এবং আমি কী করব? গল্ফ 50% বন্ধ, এটাই। ;)

s=(a,n)=>n<1?a:s(a.map((j,i)=>(a[i&&i-1]+a[a[i+1]+1?i+1:i])/2),n-1)

এই সংস্করণটি নিজেকে n1 বারের চেয়ে কম করে বার বার কল করে , nপ্রতিবার 1 টি হ্রাস পাচ্ছে ।

একটি পুনরাবৃত্তি সমাধান ( ~~151~~ ~~130~~ 78 অক্ষর):

(a,n)=>n<1?a:eval("while(n--)a=a.map((j,i)=>(a[i&&i-1]+a[a[i+1]+1?i+1:i])/2)")

অবহেলিত: (পুরানো)

রিকার্সিভ:

s = function (a, n) {
  if (n < 1)
    return a;
  b = [];
  l = a.length;
  x = y = 0;
  for(var i = 0; i < l; i++) {
    x = a[(i < 1) ? 0 : i-1];
    y = a[(i > l-2) ? i : i+1];
    b[i] = (x + y)/2;
  }
  if (n > 2)
    return b;
  return s(b,n-1);
}

অ রিকার্সিভ:

s = function (a, n) {
  if (n < 1)
    return a;
  b = [];
  l = a.length;
  x = y = 0;
  while(n-- > 0) {
    for(var i = 0; i < l; i++) {
      x = a[(i < 1) ? 0 : i-1];
      y = a[(i > l-2) ? i : i+1];
      b[i] = (x + y)/2;
      a = b.slice(0);   // setting a to a copy of b, for copyright reasons
    }
  return b;
}

— ETHproductions
সূত্র

if(n<2)return b;return s(b,n-1)হ্রাস করা যেতে পারেreturn n<2?b:s(b,n-1)

— সাইওস

@ কিউস ধন্যবাদ, আমি এটিকে বিবেচনায় রেখেছি এবং এরপরে কিছু ...

— ইটিএইচ প্রডাকশন

1

জাভা, 203 বাইট

জাভা দিয়ে আমার প্রথম পুট চেষ্টা করছি। উন্নতি টিপস স্বাগত :)

double[]f(double[]a,int n){int j,s,i=0;s=a.length-1;if(n<1||s<1)return a;double b[]=a;for(;i++<n;a=b.clone()){b[0]=.5*(a[0]+a[1]);b[s]=.5*(a[s]+a[s-1]);for(j=1;j<s;++j)b[j]=.5*(a[j-1]+a[j+1]);}return b;}

বেশিরভাগ মুদ্রিত:

double[] g(double[] a, int n) {
  int j, s, i = 0;
  s = a.length - 1;
  if (n < 1 || s < 1)
     return a;
  double b[] = a;
  for (; i++ < n; a = b.clone()) {
     b[0] = .5 * (a[0] + a[1]);
     b[s] = .5 * (a[s] + a[s - 1]);
     for (j = 1; j < s; ++j)
        b[j] = .5 * (a[j - 1] + a[j + 1]);
  }
  return b;
}

— Geir
সূত্র

পিপিসিজিতে আপনাকে স্বাগতম! আমি জাভাতে খুব গল্ফ করি না, তবে আপনি কি বাহ্যিক forলুপের ভিতরে তিনটি অ্যাসাইনমেন্ট লুপের ইনক্রিমেন্ট স্টেটমেন্টে সরাতে পারবেন ? পছন্দ for(i=0;i<n;b[0]=...,b[s-1]=...,a=...,++i)for(...)b[j]=...;? তাহলে আপনার ধনুর্বন্ধনী থেকে মুক্তি পেতে সক্ষম হওয়া উচিত।

— মার্টিন ইন্ডার

দুর্ভাগ্যক্রমে তাদের প্রতিটি পুনরাবৃত্তির উপর পুনরাবৃত্তি করতে হবে, তাই তাদের ধনুর্বন্ধনীগুলির মধ্যে থাকতে হবে।

— গির

প্রতিটি পুনরাবৃত্তির পুনরবৃদ্ধিও করা হয়, এজন্য আপনি সেগুলি তৃতীয় স্লটে রেখেছিলেন ( ++iসেমিকোলনের পরিবর্তে কৌমা দিয়ে এবং একে অপরের থেকে পৃথক )। চেষ্টা কর. :)

— মার্টিন এন্ডার

আপনি কোথায় যাচ্ছেন তা আমি দেখতে পাচ্ছি, তবে আমি চূড়ান্ত পুনরাবৃত্তিতে আপডেটটি হারাচ্ছি (যদি না জানি এমন কৌশল না থাকে)। এখনও, সক্ষম কয়েক বাইট এখানে সেখানে "অরুপ জিনিস" :) করে শেভ

— Geir

আমি মনে করি না আপনি চূড়ান্ত পুনরাবৃত্তির আপডেটটি হারাচ্ছেন। f(a;b;c){d;e;}সম্পূর্ণরূপে অভিন্ন হওয়া উচিত f{a;b;}{d;e;c;}, এবং সেইজন্যেও f(a;b;e,c)d;। তবে আপনার পুনর্বিন্যাসিত কোডের সাহায্যে এটি আর কাজ করে না, কারণ আপনি অন্যটির forঅভ্যন্তরে স্থানান্তর করতে পারবেন না for, তাই আমি অনুমান করি যে এগুলি এখন আর গুরুত্বপূর্ণ নয়। ;)

— মার্টিন ইন্ডার

1

পাইথন 2, 98 বাইট

execকিছুক্ষণ লুপ ব্যবহার করে বেরিয়ে আসার জন্য সোজা পদ্ধতিটি গ্রহণ করে । আমি মনে করি বিশেষ কেস পজিশনগুলি খুঁজে বের করার জন্য যুক্তি করার আরও ভাল উপায় আছে তবে এটি আপাতত কার্যকর হয়। ইনপুট মত ফর্ম্যাট করা উচিত [list], times।

b,c=input()
k=~-len(b)
exec'b=[(b[x-(0<x<k)]+b[x+(x<k)-(x==k)])/2.for x in range(-~k)];'*c
print b

Ungolfed:

BASE,TIME = input()
TEMP = [0]*len(BASE)                               # Temporary array as to not modify base.
while TIME:
    for x in xrange(len(BASE)):
        if x == 0:                                
            TEMP[x] = (BASE[x]   + BASE[x+1])/2.0  # First element special case.
        elif x == len(BASE)-1:                    
            TEMP[x] = (BASE[x]   + BASE[x-1])/2.0  # Last element special case.
        else:                                     
            TEMP[x] = (BASE[x-1] + BASE[x+1])/2.0  # Every other element.
    BASE = TEMP                                    # Set base to temporary array.
    TEMP = [0]*len(BASE)                           # Reset temporary array to 0s.
    TIME = TIME - 1
print BASE

— Kade
সূত্র

1

গণিত, 81 বাইট

আমার যদি মনে হয় যে আমি ইতিবাচক অবস্থাটি পরিচালনা করার জন্য আরও ভাল উপায় বের করতে পারি তবে এটি আরও গল্ফ করা যেতে পারে।

f[l_,_]:=l;f[l_,n_/;n>0]:=Nest[.5{1,0,1}~ListConvolve~ArrayPad[#,1,"Fixed"]&,l,n]

মূল্যবান লক্ষণীয়: ম্যাথমেটিকা তার তালিকা-প্রক্রিয়াজাতকরণ এবং ফিল্টার ফাংশনগুলির পরিসীমাতে প্রচুর সম্ভাব্য অন্তর্নির্মিত সমাধানও সরবরাহ করে CellularAutomaton। আমি নির্বাচন করেছি Nest[... ListConvolve ...]কারণ তালিকার শেষ প্রান্তে কিঙ্কসটি কাজ করার সবচেয়ে সহজ উপায় ছিল, তবে অন্যান্য কোণগুলি সংক্ষিপ্ত প্রমাণ হতে পারে।

— hYPotenuser
সূত্র

0

মতলব, 109

function a=f(a,n)
if numel(a)>1&n>0
for k=1:n
a=[a(1)+a(2) conv(a,[1 0 1],'valid') a(end-1)+a(end)]/2;end
end

উদাহরণ:

>> f([0, 0, 1, 0, 0], 1)
ans =
         0    0.5000         0    0.5000         0

>> f([0, 0, 1, 0, 0], 2)
ans =
    0.2500         0    0.5000         0    0.2500

>> f([0, 0, 1, 0, 0], 0)
ans =
     0     0     1     0     0

>> f([0, 0, 1, 0, 0], -39)
ans =
     0     0     1     0     0

>> f([0], 482)
ans =
     0

>> f([], 10)
ans =
     []

— লুইস মেন্ডো
সূত্র

0

স্কেলা, ১৯৫ টি অক্ষর (অলস আউটপুট সহ 186 `Stream`) অর্থাৎ 187 টি অক্ষর

(t:Seq[Float],n:Int)⇒t.size match{case 0|1⇒t;case 2⇒{val a=t.sum/2;Seq(a,a)};case i⇒(t/:(1 to n)){(s,_)⇒(s.take(2).sum/2)+:s.sliding(3).map(l=>(l(0)+l(2))/2).toList:+(s.drop(i-2).sum/2)}}

সম্ভবত অনুকূল নয়, ম্যাপিং sliding(3) এই ক্ষেত্রে খুব দরকারী।

পরীক্ষা:

scala> (t:Seq[Float],n:Int)⇒t.size match{case 0|1⇒t;case 2⇒{val a=t.sum/2;Seq(a,a)};case i⇒(t/:(1 to n)){(s,_)⇒(s.take(2).sum/2)+:s.sliding(3).map(l=>(l(0)+l(2))/2).toList:+(s.drop(i-2).sum/2)}}
res0: (Seq[Float], Int) => List[Float] = <function2>

scala> res0(Seq(0, 0, 1, 0, 0), 1)
res1: Seq[Float] = List(0.0, 0.5, 0.0, 0.5, 0.0)

scala> res0(Seq(0, 0, 1, 0, 0), 2)
res2: Seq[Float] = List(0.25, 0.0, 0.5, 0.0, 0.25)

scala> res0(Seq(0, 0, 1, 0, 0), 0)
res3: Seq[Float] = List(0.0, 0.0, 1.0, 0.0, 0.0)

scala> res0(Seq(0, 0, 1, 0, 0), -39)
res4: Seq[Float] = List(0.0, 0.0, 1.0, 0.0, 0.0)

scala> res0(Seq(0, 16, 32, 16, 0), 1)
res5: Seq[Float] = List(8.0, 16.0, 16.0, 16.0, 8.0)

scala> res0(Seq(1, 2, 3, 4, 5), 1)
res6: Seq[Float] = List(1.5, 2.0, 3.0, 4.0, 4.5)

scala> res0(Seq(0,64), 1)
res7: Seq[Float] = List(32.0, 32.0)

scala> res0(Seq(0), 482)
res8: Seq[Float] = List(0.0)

scala> res0(Seq(32, 32, 32, 16, 64, 16, 32, 32, 32), 4)
res9: Seq[Float] = List(33.0, 27.0, 40.0, 22.0, 44.0, 22.0, 40.0, 27.0, 33.0)

— গিলাদ হচ
সূত্র

0

q (২ characters টি অক্ষর)

{avg x^/:1 -1 xprev\:x}/[;]

উদাহরণ

q)f:{avg x^/:1 -1 xprev\:x}/[;]
q)f[4;32 32 32 16 64 16 32 32 32]
33 27 40 22 44 22 40 27 33f
//1-length input
q)f[10;enlist 1] 
,1f
//0-length input
q)f[10;`float$()]
`float$()

— skeevey
সূত্র

0

আর, 93 বাইট

নামহীন ফাংশন হিসাবে

function(a,n){l=length(a);while((n=n-1)>=0)a<-colMeans(rbind(c(a[-1],a[l]),c(a[1],a[-l])));a}

সম্প্রসারিত

function(a,n){
    l=length(a);             # get the length of the vector
    while((n=n-1)>=0)        # repeat n times
        a<-colMeans(         # do the column means and assign to a
          rbind(             # create an array
            c(a[-1],a[l]),   # shift the vector left and duplicate last
            c(a[1],a[-l])    # shift the vector right and duplicate first
          )
        );
    a                        # return the vector
}

টেস্ট

> f=function(a,n){l=length(a);while((n=n-1)>=0)a<-colMeans(rbind(c(a[-1],a[l]),c(a[1],a[-l])));a}
> f(c(0, 0, 1, 0, 0), 1)
[1] 0.0 0.5 0.0 0.5 0.0
> f(c(0, 0, 1, 0, 0), 2)         
[1] 0.25 0.00 0.50 0.00 0.25
> f(c(0, 0, 1, 0, 0), 0)         
[1] 0 0 1 0 0
> f(c(0, 0, 1, 0, 0), -39)        
[1] 0 0 1 0 0
> f(c(0, 16, 32, 16, 0), 1)       
[1]  8 16 16 16  8
> f(c(0, 1, 2, 3, 4, 5), 1)      
[1] 0.5 1.0 2.0 3.0 4.0 4.5
> f(c(0, 64), 1)                  
[1] 32 32
> f(c(0), 482)                    
[1] 0
> f(c(32, 32, 32, 16, 64, 16, 32, 32, 32),4)
[1] 33 27 40 22 44 22 40 27 33
>

— MickyT
সূত্র

0

জাপট, 39 37 বাইট (প্রতিদ্বন্দ্বী)

এই উত্তরটি প্রতিদ্বন্দ্বিতামূলক নয় কারণ ভাষা চ্যালেঞ্জের চেয়ে নতুন। আমি কেবল দেখতে চেয়েছিলাম যে আমার গল্ফের ভাষা আমার প্রথম চ্যালেঞ্জটি কতটা ভালভাবে ধরে রাখতে পারে।

Vm0 o r_£ZgY©Y-1 +ZgY>Zl -2?Y:°Y)/2}U

এটি অনলাইন চেষ্টা করুন!

Vm0 o r_£ZgY©Y-1 +ZgY>Zl -2?Y:°Y)/2}U
Vm0 o      // Generate the range of integers [0, max(V,0)).
r_     }U  // Reduce it with this function, with a starting value of U:
£          //  Return the argument, with each item X, index Y, and the full array Z mapped by this function:
ZgY©Y-1 +  //   Return (Z[max(Y-1,0)] plus
ZgY>Zl -2? //    Z[Y > Z.length-2?
Y:°Y)      //      Y:--Y],)
/2         //   divided by two.
           // Implicit: output last expression

— ETHproductions
সূত্র

0

সি ++ 14, 158 বাইট

#define D(a,b)d[i]=(c[a]+c[b])/2;
auto f(auto c,int n){while(n-->0&&c.size()>1){auto d{c};int i{};D(0,1)while(++i<c.size()-1)D(i-1,i+1)D(i,i-1)c=d;}return c;}

value_type==doubleমত ধারক হতে ইনপুট প্রয়োজন vector<double>।

Ungolfed:

#define D(a,b) d[i] = (c[a]+c[b])/2;   //average
auto f(auto c, int n) {
  while(n-- > 0 && c.size() > 1) {     //breaks
    auto d{c};                         //copy container
    int i{};
    D(0,1)                             //left
    while(++i < c.size()-1)            //count up to right
      D(i-1,i+1)                       //interior
    D(i,i-1)                           //right
    c=d;                               //overwrite container
  }
  return c;
}

— কার্ল ন্যাপ
সূত্র

0

223 বাইট রেকেট

(let p((l l)(m 0)(g list-ref))(cond[(> n m)(let*((j(length l))(k(for/list((i j))(cond[(= i 0)(/(+(g l 0)(g l 1))2)]
[(= i(- j 1))(/(+(g l(- j 2))(g l(- j 1)))2)][else(/(+(g l(+ i 1))(g l(- i 1)))2)]))))(p k(+ 1 m) g))][l]))

Ungolfed:

(define(f l n)
  (let loop ((l l)
             (m 0)
             (lr list-ref))
    (cond
      [(> n m)
       (let* ((j (length l))
              (k (for/list ((i j))
                   (cond
                     [(= i 0)       (/ (+ (lr l 0)
                                          (lr l 1))
                                       2)]
                     [(= i (- j 1)) (/ (+ (lr l (- j 2))
                                          (lr l (- j 1)))
                                        2)]
                     [else          (/ (+ (lr l (+ i 1))
                                          (lr l (- i 1)))
                                       2)])
                   )))
         (loop k
               (+ 1 m)
               lr))]
      [else l]
      )))

পরীক্ষামূলক:

(f '[32 32 32 16 64 16 32 32 32] 4)

আউটপুট:

'(33 27 40 22 44 22 40 27 33)

— rnso
সূত্র

0

জেলি , 14 বাইট

.ịṚjṡ3 .ịⱮÆmµ¡

এটি অনলাইন চেষ্টা করুন!

পুরো প্রোগ্রাম।

— এরিক দ্য আউটগল্ফার
সূত্র

0

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 160 144 বাইট

float[]a(float[]b,int c)=>c>0&b.Length>1?a(b.Select((_,w)=>w<1?(b[w]+b[w+1])/2:w>b.Length-2?(b[w]+b[w-1])/2:(b[w-1]+b[w+1])/2).ToArray(),c-1):b;

ভাল ওল 'পুনরাবৃত্তি ব্যবহার করে।

এটি অনলাইন চেষ্টা করুন!

— অজ্ঞতার প্রতিমূর্তি
সূত্র

তরঙ্গ গণনা করা হচ্ছে

পাইথ, 46 18 বাইট

স্নোম্যান 1.0.0 , 219 অক্ষর

পাইথ - 25 24 বাইট

কোলাহল, 164 145 বাইট

Ungolfed

আর, 109 বাইট

হাস্কেল, 76 টি অক্ষর

সিজেম, 23 22 বাইট

জাভাস্ক্রিপ্ট (ES6), 153 132 67 অক্ষর

অবহেলিত: (পুরানো)

রিকার্সিভ:

অ রিকার্সিভ:

জাভা, 203 বাইট

পাইথন 2, 98 বাইট

গণিত, 81 বাইট

মতলব, 109

স্কেলা, ১৯৫ টি অক্ষর (অলস আউটপুট সহ 186 Stream) অর্থাৎ 187 টি অক্ষর

পরীক্ষা:

q (২ characters টি অক্ষর)

আর, 93 বাইট

জাপট, 39 37 বাইট (প্রতিদ্বন্দ্বী)

সি ++ 14, 158 বাইট

223 বাইট রেকেট

জেলি , 14 বাইট

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 160 144 বাইট

স্কেলা, ১৯৫ টি অক্ষর (অলস আউটপুট সহ 186 `Stream`) অর্থাৎ 187 টি অক্ষর