लहरों की गणना

Question

मैं इस साइट पर थोड़ी देर के लिए स्क्रॉल कर रहा हूं, लेकिन अभी हाल ही में वास्तव में कुछ चुनौतियों का सामना करने में वास्तव में दिलचस्पी थी। मैं मौजूदा कोड-गोल्फ विषयों में से कुछ पर अपना हाथ आज़माने का इरादा कर रहा था, लेकिन मेरे पास कल थोड़ी देर के लिए इंटरनेट का उपयोग नहीं था, और इस बीच, मैंने अपनी चुनौती को सोचा।

आपका कार्य एक प्रोग्राम या फ़ंक्शन बनाना है , 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]

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है। विजेता को एक सप्ताह (1 अगस्त को) में चुना जाएगा। सौभाग्य!

संपादित करें: विजेता, @issacg को 18 बाइट्स के साथ बधाई !

Comments

इस चुनौती को सुधारने की मेरी सलाह यह nहै कि आपूर्ति से छुटकारा न मिले और aमामलों की आपूर्ति न हो - वे वास्तव में बहुत कुछ नहीं जोड़ते।

— isaacg

मेरा मानना ​​है कि अंतिम परीक्षण का मामला गलत है। n4 होना चाहिए, न कि 5.

— ईसैक

@isaacg: हाँ, अब जब कि मैं इसे फिर से देखता हूं, तो वे मामले महत्वपूर्ण नहीं लगते। मैंने उसे बदल दिया है, और गलत उदाहरण को भी ठीक कर दिया है। उन चीजों को इंगित करने के लिए धन्यवाद!

— ETHproductions

यदि आप वास्तव में इसे खाली सूचियों को संभालना चाहते हैं, तो आप इसे परीक्षण मामलों की सूची में जोड़ना चाह सकते हैं। मैंने अभी देखा कि उस मामले के लिए मेरा समाधान विफल हो गया। व्यक्तिगत रूप से, मैं समस्याओं का एक बड़ा प्रशंसक नहीं हूं, जहां समाधान का एक बड़ा हिस्सा विशेष मामलों को संभालने के लिए है।

— रेटो कोराडी

@RetoKoradi क्षमा करें, मैं "खाली सूची" मामले को नियमों से हटाना भूल गया था जब मैंने इसे उदाहरणों से हटा दिया था। सूचना के लिए धन्यवाद!

— ETHproductions

Answer 1

पायथ, 46 18 बाइट्स

ucR2sV+hGGt+GeG.*Q

यह कोड प्रपत्र में इनपुट की उम्मीद करता है iterations, [wave1, wave2, wave3 ...], जैसा कि नीचे दिए गए पहले लिंक पर देखा गया है।

प्रदर्शन। दोहन ​​परीक्षण।

कार्यक्रम uइनपुट सूची में कम ( ) फ़ंक्शन के भीतर कोड को लागू करके काम करता है , जितनी बार पुनरावृत्तियों की संख्या।

मैं सूची में लहर प्रसार समारोह प्रदर्शित करूंगा [0, 1, 2, 3, 4, 5], जो इस प्रकार है G:

+hGGपहले जोड़ता Gकरने के पहले तत्व G, के गठन [0, 0, 1, 2, 3, 4, 5]।

t+GeGके Gअंतिम तत्व को जोड़ता है 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]।

Answer 2

स्नोमैन 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

Ungolfed / unminified संस्करण:

{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]

Comments

यह बेहद खूबसूरत है।

— kirbyfan64sos

Answer 3

पायथ - 25 24 बाइट्स

गणना का उपयोग करता है, पुनरावृत्तियों को कम करने के लिए।

u.ecs@L++hGGeG,khhk2GvzQ

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

Answer 4

रैकेट, 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इसे चलाने के लिए आपको लाइन की आवश्यकता हो सकती है ।

Answer 5

आर, 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

Answer 6

हास्केल, 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]

Comments

आप के बजाय 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।

— नीम जूल

Answer 7

CJam, 23 22 बाइट्स

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

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

इनपुट CJam सूची प्रारूप में है, उदाहरण के लिए अंतिम उदाहरण के लिए:

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

आउटपुट भी CJam सूची है:

[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.

Comments

मैं ओपी नहीं हूं, लेकिन "अगर वहाँ शून्य या एक आइटम में होता है, या यदि n 0 या उससे कम है, तो कार्यक्रम को मूल सरणी वापस करना चाहिए।"

— माल्टीसेन

Answer 8

जावा, 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;
}

मैंने जावा के साथ जितना संभव हो सके असाइनमेंट और कंडीशन को छोटा करने की कोशिश की। सुधारों का स्वागत है, बिल्कुल।

Answer 9

जावास्क्रिप्ट (ईएस 6), 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)

यह संस्करण प्रत्येक बार 1 nसे कम होने तक बार-बार कॉल करता है, 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;
}

Comments

if(n<2)return b;return s(b,n-1)कम किया जा सकता हैreturn n<2?b:s(b,n-1)

— साइओस

@ धन्यवाद, मैंने इसे ध्यान में रखा है, और फिर कुछ ...

— ETHproductions

Answer 10

जावा, 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;
}

Comments

PPCG में आपका स्वागत है! मैं जावा में बहुत अधिक गोल्फ नहीं करता, लेकिन क्या आप बाहरी forलूप के अंदर के तीन असाइनमेंट को लूप के इन्क्रीमेंट स्टेटमेंट में स्थानांतरित कर सकते हैं ? पसंद है for(i=0;i<n;b[0]=...,b[s-1]=...,a=...,++i)for(...)b[j]=...;? फिर आपको ब्रेसिज़ से छुटकारा पाने में सक्षम होना चाहिए।

— मार्टिन एंडर

दुर्भाग्य से उन्हें प्रत्येक पुनरावृत्ति पर दोहराया जाना है, इसलिए उन्हें ब्रेसिज़ के अंदर रहना होगा।

— गीर

वेतन वृद्धि भी प्रत्येक पुनरावृत्ति को दोहराया जाता है, यही कारण है कि आप उन्हें तीसरे स्लॉट ( ++iअर्धविराम के बजाय अल्पविराम से एक दूसरे से अलग) में डाल देंगे । कोशिश करके देखो। :)

— मार्टिन एंडर

मैं देखता हूं कि आप कहां जा रहे हैं, लेकिन मैं अंतिम पुनरावृत्ति में अद्यतन खो रहा हूं (जब तक कि कोई चाल नहीं पता है)। फिर भी, "बदसूरत चीजें" करके यहाँ और वहाँ कुछ बाइट्स दाढ़ी बनाने में सक्षम :) :)

— गीयर

मुझे नहीं लगता कि आप अंतिम पुनरावृत्ति पर अद्यतन खो रहे हैं। f(a;b;c){d;e;}के लिए पूरी तरह से समान होना चाहिए f{a;b;}{d;e;c;}, और इसलिए भी f(a;b;e,c)d;। हालाँकि, आपके पुनर्व्यवस्थित कोड के साथ जो अब काम नहीं करता है, क्योंकि आप forदूसरे के अंदर नहीं जा सकते हैं for, इसलिए मुझे लगता है कि यह अब मायने नहीं रखता। ;)

— मार्टिन एंडर

Answer 11

पायथन 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

Answer 12

गणितज्ञ, 81 बाइट्स

मुझे लगता है कि अगर मुझे सकारात्मकता की स्थिति को संभालने के लिए एक बेहतर तरीका मिल सकता है, तो इसे और अधिक गोल्फ हो सकता है।

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

वर्थ नोटिंग: मैथमेटिका अपनी सूची-प्रसंस्करण और फ़िल्टर फ़ंक्शंस की श्रेणी में बहुत सारे संभावित अंतर्निहित समाधान प्रदान करता है, साथ ही साथ CellularAutomaton। मैंने चुना Nest[... ListConvolve ...]क्योंकि यह सूची के अंत में किंक को बाहर निकालने का सबसे आसान तरीका था, लेकिन अन्य कोण कम साबित हो सकते हैं।

Answer 13

मतलाब, 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 =
     []

Answer 14

स्काला, 195 वर्ण (आलसी आउटपुट के साथ 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)

Answer 15

q (27 अक्षर)

{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$()

Answer 16

आर, 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
> 

Answer 17

Japt, 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

Answer 18

सी ++ 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;
}

Answer 19

रैकेट 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)

Answer 20

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

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

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

पूरा कार्यक्रम।

Answer 21

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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;

अच्छे राजभाषा पुनरावृत्ति का उपयोग करता है।

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