Alise un gráfico lineal

13

Dada una entrada de un entero n y una lista de enteros positivos m 1 , m 2 , ..., genera una lista de enteros m 1 ' , m 2 ' , ... donde m x ' se define como el promedio de m xn a través de m x + n .

Al calcular estos promedios, ignore los índices que están fuera de los límites (y ajuste lo que está dividiendo la suma por consiguiente). n siempre será ≥ 1 pero nunca la mitad de la longitud de m (redondeado hacia abajo) o más. Esto significa que la longitud mínima de m es 4. Los elementos en m serán enteros positivos, pero la salida debe tener una precisión de al menos 3 decimales.

Los elementos de entrada / salida que son listas pueden ser cadenas separadas por espacios en blanco / comas o matrices / listas / etc. Para la entrada, si su solución es una función, también puede tomar un primer argumento de n y argumentos adicionales como m x (esto también se aplica a los argumentos de la línea de comandos).

Aquí hay una representación visual de 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

Como se trata de , gana el código más corto en bytes.

Casos de prueba ( estos se realizaron manualmente; notifíqueme cualquier error ):

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
Pomo de la puerta
fuente
Para ser claros, ¿esto es lo mismo que preceder y agregar ceros y luego calcular las medias de cada subsecuencia contigua de longitud 3?
El'endia Starman
@ El'endiaStarman No. avg(0,1,2)no es lo mismo que avg(1,2). Para los "casos límite" (ha), no debe promediar tantos elementos de la lista de entrada.
Pomo de la puerta
Ah, claro, ya veo.
El'endia Starman
Relacionado
Alex A.
Este habría sido un desafío mejor sin la restricción de que m_ison positivos.
Peter Taylor

Respuestas:

1

Pyth, 20 bytes

m.O:vzeS,0-dQh+dQUvz

Banco de pruebas

Bastante sencillo, solo corta la sección apropiada de la lista, luego promedia.

isaacg
fuente
@ThomasKwa Lo intenté, pero parece que tienes que almacenar Efuera del mapa porque seguirá intentando leer un nuevo valor si está dentro. Esto hace que tome la misma cantidad de bytes.
FryAmTheEggman
3

MATL , 30 28 26 24 bytes

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

Probado en Matlab y en Octave. Utiliza la versión actual (9.1.0) del idioma / compilador.

La entrada es: primero el número que controla la longitud de la ventana, luego la matriz con formato [1 4 5 7 10].

EDITAR (20 de mayo de 2016): ¡ Pruébelo en línea! El código en el enlace ha sido X+reemplazado por Y+para cumplir con la versión 18.0.0 del lenguaje.

Ejemplo

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

Explicación

El código equivalente de Matlab sería

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

El código MATL hace uso de las características recientemente agregadas de entrada implícita y portapapeles de entrada de función automática:

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
Luis Mendo
fuente
2

CJam, 31 30 bytes

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

El formato de entrada es n [m1 m2 ... mx].

Ejecute todos los casos de prueba. (Convierte automáticamente el conjunto de pruebas al formato de entrada requerido).

Esto funciona mediante nespacios previos y anexos , luego toma todas las subcadenas de longitud 2n+1y elimina los espacios nuevamente antes de calcular sus medios.

Martin Ender
fuente
1

Julia, 57 bytes

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

Esta es una función que acepta dos enteros y devuelve una matriz de flotantes.

El enfoque aquí es muy sencillo. Construimos una nueva matriz tomando la media de las secciones de la matriz de entrada, truncando en la parte delantera y trasera.

Alex A.
fuente
0

Haskell, 97 95 bytes

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]

Ejemplo de uso: 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].

Cómo funciona:

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
fuente
0

Pyth, 22 bytes

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

Explicación:

.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

Pruébalo aquí .

lirtosiast
fuente
0

JavaScript (ES6), 104

Ejecución total / tamaño de muestra en ejecución. En Javascript, leer un valor fuera de los límites de una matriz da indefinido, que se puede convertir a 0 usando ~~

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

Sin golf

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

Prueba

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
fuente
0

JavaScript (ES6), 82 bytes

código:

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)

prueba:

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

core1024
fuente