Calcul des vagues

26

J'ai parcouru ce site pendant un certain temps, mais récemment je me suis vraiment intéressé à essayer certains des défis. J'avais l'intention de m'essayer à certains des sujets de golf de code existants, mais je n'ai pas eu accès à Internet depuis un moment hier, et en attendant, j'ai pensé à mon propre défi.

Votre tâche consiste à créer un programme ou une fonction qui prend un tableau de flottants aet un entier n, puis définit chaque valeur dans ala moyenne des deux à côté, nfois. Lorsqu'il est utilisé à plusieurs reprises avec des valeurs croissantes de n, cela génère un mouvement ondulatoire:

le mouvement des vagues

Détails:

  • S'il se trouve qu'il n'y a qu'un seul élément dans a, ou si nest 0 ou moins, le programme doit retourner le tableau d'origine.
  • Les entrées et sorties peuvent être dans n'importe quel format que vous désirez, tant qu'elles sont visiblement séparées.

Pour chaque étape:

  • Le premier élément adoit devenir la moyenne de lui-même et l'élément suivant.
  • Le dernier élément adoit devenir la moyenne de lui-même et de l'élément précédent.
  • Tout autre élément adoit devenir la moyenne de l'élément précédent et de l'élément suivant.
  • Assurez-vous de calculer à partir du tableau de l'étape précédente et non de celui en cours!

Cas de test: REMARQUE: vos entrées / sorties ne doivent pas nécessairement être dans ce format!

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

C'est le , donc la réponse la plus courte en octets l'emporte. Le gagnant sera choisi dans une semaine (le 1er août). Bonne chance!

Edit: Félicitations au gagnant, @issacg , avec un énorme 18 octets!

ETHproductions
la source
2
Mon conseil pour améliorer ce défi est de se débarrasser des cas nnon fournis et anon fournis - ils n'ajoutent pas vraiment grand-chose.
isaacg
Je crois que le cas de test final est incorrect. ndevrait être 4, pas 5.
isaacg
@isaacg: Oui, maintenant que j'y repense, ces cas ne semblent pas si importants. J'ai changé cela et corrigé également l'exemple incorrect. Merci d'avoir signalé ces choses!
ETHproductions
1
Si vous voulez vraiment qu'il gère les listes vides, vous pouvez l'ajouter à la liste des cas de test. Je viens de remarquer que ma solution échoue pour ce cas. Personnellement, je ne suis pas un grand fan des problèmes où une grande partie de la solution consiste à gérer des cas spéciaux.
Reto Koradi
@RetoKoradi Désolé, j'avais oublié de supprimer le cas "liste vide" des règles lorsque je l'ai supprimé des exemples. Merci pour l'avis!
ETHproductions

Réponses:

11

Pyth, 46 18 octets

ucR2sV+hGGt+GeG.*Q

Ce code attend une entrée dans le formulaire iterations, [wave1, wave2, wave3 ...], comme le montre le premier lien ci-dessous.

Manifestation. Harnais de test.

Le programme fonctionne en appliquant le code de la fonction Reduce ( u) à la liste d'entrée, autant de fois que le nombre d'itérations.

Je vais démontrer la fonction de propagation des ondes sur la liste [0, 1, 2, 3, 4, 5], qui se trouve dans G:

+hGGajoute Gle premier élément à G, formant [0, 0, 1, 2, 3, 4, 5].

t+GeGajoute Gle dernier élément de Get supprime son premier élément, formant [1, 2, 3, 4, 5, 5].

sVla première forme des paires à partir des listes, donnant [[0, 1], [0, 2], [1, 3], [2, 4], [3, 5], [4, 5]]avec le dernier élément de la première liste tronqué. Ensuite, les paires sont additionnées via la sfonction, donnant [1, 2, 4, 6, 8, 9].

cR2Utilisations flottantes division du point de diviser tous les nombres par 2, ce qui donne le résultat souhaité, [0.5, 1.0, 2.0, 3.0, 4.0, 4.5].

isaacg
la source
8

Snowman 1.0.0 , 219 caractères

{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

Avec des sauts de ligne pour la "lisibilité":

{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

Version non golfée / non minimisée:

{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

Exemple de format d'E / S:

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]
Poignée de porte
la source
2
C'est horriblement beau.
kirbyfan64sos
5

Raquette, 164 145 octets

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

Non golfé

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

Remarque, vous devrez peut-être la #lang racketligne pour exécuter cela.

Winny
la source
4

R, 109 octets

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)}

Cela crée une fonction sans nom qui accepte un vecteur et un entier et renvoie un vecteur. L'approche ici consiste à traiter l'entrée comme une série temporelle univariée et à appliquer un filtre de convolution linéaire.

Non golfé + explication:

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)
}

Exemples:

> 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
Alex A.
la source
4

Haskell, 76 caractères

L'astuce consiste à ajouter le premier nombre au début de la liste et le dernier à la fin de la liste au lieu de traiter les conditions aux limites.

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)

Tests:

λ: [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
la source
1
Vous pouvez enregistrer quelques octets en utilisant des opérateurs infixes pour les fonctions à 2 arguments et les gardes au lieu de if then else, c'est-à-dire cdevient a#n|n<1=a|1<2=iterate f a!!net sdevient x!y=(x+y)/2(et est appelé ...zipWith(!)(x:a)...).
nimi
Merci! Je ne savais pas comment fonctionnent les gardes dans les expressions d'une seule ligne.
Keyran
2 autres octets: faire cun opérateur infixe dire #: a#n|n<1=a|1<2=iterate f a!!n. Appelez ça comme [0, 0, 1, 0, 0] # 2.
nimi
2

CJam, 23 22 octets

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

Essayez-le en ligne

L'entrée est au format de liste CJam, par exemple pour le dernier exemple:

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

La sortie est également une liste CJam:

[33.0 27.0 40.0 22.0 44.0 22.0 40.0 27.0 33.0]

L'approche de base est qu'à chaque étape, le vecteur est décalé d'une position vers la gauche et d'une position vers la droite. Chacun des deux vecteurs est complété par le premier / dernier élément, puis la moyenne des deux vecteurs est calculée.

Explication:

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.
Reto Koradi
la source
Je ne suis pas l'OP, mais "S'il se trouve qu'il y a zéro ou un élément dans a, ou si n est égal ou inférieur à 0, le programme devrait retourner le tableau d'origine."
Maltysen
2

Java, 181 octets

Voici la version golfée:

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;}

Non golfé:

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;
}

J'ai essayé de raccourcir autant que possible les affectations et les conditions avec Java. Bien entendu, les améliorations sont les bienvenues.

JackWhiteIII
la source
2

JavaScript (ES6), 153 132 67 caractères

Je reviens à ma première réponse 6 mois plus tard et que dois-je faire? Golf à 50%, c'est quoi. ;)

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)

Cette version s'appelle à plusieurs reprises jusqu'à ce qu'elle nsoit inférieure à 1, décrémentant nde 1 à chaque fois.

Une solution non récursive ( 151 130 78 caractères):

(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)")

Non golfé: (obsolète)

Récursif:

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);
}

Non récursif:

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
la source
if(n<2)return b;return s(b,n-1)pourrait être réduit àreturn n<2?b:s(b,n-1)
Cyoce
@Cyoce Merci, j'ai pris cela en compte, et puis certains ...
ETHproductions
1

Java, 203 octets

Essayer mon premier put avec Java. Les conseils d'amélioration sont les bienvenus :)

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;}

Assez imprimé:

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
la source
Bienvenue chez PPCG! Je ne joue pas beaucoup au golf en Java, mais pouvez-vous déplacer les trois affectations à l'intérieur de la forboucle externe dans l'instruction d'incrémentation de la boucle? Comme for(i=0;i<n;b[0]=...,b[s-1]=...,a=...,++i)for(...)b[j]=...;? Ensuite, vous devriez pouvoir vous débarrasser des accolades.
Martin Ender
Malheureusement, ils doivent être répétés à chaque itération, ils doivent donc rester à l'intérieur des accolades.
Geir
L'incrément est également répété à chaque itération, c'est pourquoi vous les mettriez dans le troisième emplacement (séparés les ++iuns des autres par des virgules au lieu de points-virgules). Essaye le. :)
Martin Ender
Je vois où vous allez, mais je perds la mise à jour dans l'itération finale (sauf s'il y a une astuce que je ne connais pas). Toujours capable de raser quelques octets ici et là en faisant des "choses moches" :)
Geir
Je ne pense pas que vous perdiez la mise à jour sur l'itération finale. f(a;b;c){d;e;}doit être complètement identique à f{a;b;}{d;e;c;}, et donc également à f(a;b;e,c)d;. Cependant, avec votre code réarrangé qui ne fonctionne plus, car vous ne pouvez pas déplacer l' forintérieur de l'autre for, donc je suppose que tout cela n'a plus d'importance. ;)
Martin Ender
1

Python 2, 98 octets

A adopté l'approche simple, utilisée execpour éviter d'utiliser une boucle while. Je pense qu'il y a une meilleure façon de faire la logique pour déterminer les positions de cas spéciaux, mais cela fonctionne pour l'instant. L'entrée doit être formatée comme [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

Non golfé:

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
la source
1

Mathematica, 81 octets

J'ai le sentiment qu'il pourrait être plus joué au golf si je pouvais trouver une meilleure façon de gérer la condition de positivité.

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

À noter: Mathematica propose de nombreuses solutions intégrées potentielles dans sa gamme de fonctions de traitement de liste et de filtrage CellularAutomaton. J'ai choisi Nest[... ListConvolve ...]parce que c'était le moyen le plus simple de résoudre les problèmes à la fin de la liste, mais d'autres angles pourraient se révéler plus courts.

hYPotenuser
la source
0

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

Exemples:

>> 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 =
     []
Luis Mendo
la source
0

Scala, 195 caractères (186 avec sortie paresseuse, c'est-à-dire Stream) 187 caractères

(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)}}

probablement pas optimal, cartographie sliding(3) est très utile dans ce cas.

tests:

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)
gilad hoch
la source
0

q (27 caractères)

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

Exemples

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
la source
0

R, 93 octets

En tant que fonction sans nom

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}

Étendu

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
}

Les tests

> 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
la source
0

Japt, 39 37 octets (non concurrent)

Cette réponse n'est pas concurrente car la langue est plus récente que le défi. Je voulais juste voir à quel point ma langue de golf pouvait tenir mon premier défi.

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

Essayez-le en ligne!

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
la source
0

C ++ 14, 158 octets

#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;}

Nécessite une entrée pour être un conteneur value_type==double , comme vector<double>.

Non golfé:

#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;
}
Karl Napf
la source
0

Raquette 223 octets

(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]))

Non golfé:

(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]
      )))

Essai:

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

Sortie:

'(33 27 40 22 44 22 40 27 33)
rnso
la source