Este problema está "inspirado" en una pregunta que se hizo originalmente en Quora (no para golf de código). Solo quiero que sea un desafío para ustedes (y mi primer problema presentado aquí).

Dada una matriz de elementos enteros vy un entero d(suponemos que d es menor o igual a la longitud de la matriz), considere todas las secuencias de delementos consecutivos en la matriz. Para cada secuencia, calcule la diferencia entre el valor máximo y mínimo de los elementos en esa secuencia y asígnele el nombre de desviación.

Su tarea es escribir un programa o función que calcule el valor máximo entre todas las desviaciones de todas las secuencias consideradas anteriormente, y devolver o generar ese valor.

Ejemplo resuelto:

v: (6,9,4,7,4,1)
d: 3

The sequences of length 3 are:
6,9,4 with deviation 5
9,4,7 with deviation 5
4,7,4 with deviation 3
7,4,1 with deviation 6

Thus the maximal deviation is 6, so the output is 6.

Este es el código de golf, por lo que gana la respuesta más corta en bytes.

Dyalog APL, 7 bytes

⌈/⌈/-⌊/

Pruébelo en TryAPL .

Cómo funciona

⌈/⌈/-⌊/  Dyadic chain. Left argument: d. Right argument: v

     ⌊/  Reduce v by d-wise minimum, yielding the minima of all slices of length d.
  ⌈/     Reduce v by d-wise maximum, yielding the maxima of all slices of length d.
    -    Subtract, yielding the ranges of all slices of length d.
⌈/       Take the maximum.

JavaScript (ES6), 73 bytes

with(Math)(v,d)=>max(...v.map((a,i)=>max(...a=v.slice(i,i+d))-min(...a)))

Python, 60 bytes

Ahorrando 5 bytes gracias a Neil

f=lambda v,d:v and max(max(v[:d])-min(v[:d]),f(v[1:],d))or 0

Mi primera lambda recursiva!

Uso:

print f([6,9,4,7,4,1], 3)

Perl, 48 bytes

Incluye +5 para -0pi

Dé el ancho después de la -iopción, dé los elementos como líneas separadas en STDIN:

perl -0pi3 -e '/(^.*\n){1,$^I}(?{\$F[abs$1-$&]})\A/m;$_=$#F'
6
9
4
7
4
1
^D

Solo el código:

/(^.*\n){1,$^I}(?{\$F[abs$1-$&]})\A/m;$_=$#F

(use un literal \npara la puntuación reclamada)

R, 63 62 56 bytes

Billywob ya ha proporcionado una gran respuesta R utilizando solo las funciones básicas . Sin embargo, quería ver si era posible un enfoque alternativo, tal vez usando algunos de los amplios paquetes de R. Hay una buena función rollapplyen el zoopaquete diseñado para aplicar una función a una ventana móvil de una matriz, de modo que se adapte bien a nuestros propósitos. Usamos rollapplypara encontrar el maxde cada ventana, y lo usamos nuevamente para encontrar el minde cada ventana. Luego tomamos la diferencia entre los máximos y los minutos, lo que nos da la desviación para cada ventana, y luego devolvemos la maxde esos.

function(v,d)max((r=zoo::rollapply)(v,d,max)-r(v,d,min))

R, 80 bytes de 77 bytes

Editar: Guardado 3 bytes gracias a @rturnbull

function(s,d)max(sapply(d:sum(1|s)-d+1,function(i)diff(range(s[i:(i+d-1)]))))

PowerShell v2 +, 68 bytes

param($v,$d)($v|%{($x=$v[$i..($i+++$d-1)]|sort)[-1]-$x[0]}|sort)[-1]

Solución iterativa. Se repite $v, pero en realidad solo lo estamos utilizando como contador en lugar de analizar los valores. En cada iteración, estamos cortando $vpor $i..($i+++$d-1), donde está $ipredeterminado 0. Tenemos |sortesos elementos, y almacenamos el resultado en $x. Luego tomamos el más grande [-1]y restamos el más pequeño [0]. Luego tomamos |sortesos resultados y tomamos lo más importante [-1]de eso. Ese número se deja en la tubería y la salida es implícita.

Ejemplos

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(6,9,4,7,4,1) 3
6

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(1,2,3,4,5,6) 3
2

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(7,2,3,4,5,6) 3
5

05AB1E , 12 10 bytes

Utiliza la codificación CP-1252 .

Œù€{øÀ`-ÄZ

Pruébalo en línea!

Explicación

Π             # sublists of v
 ù             # of length d
  €{           # sort each
    ø          # zip
     À         # rotate left (last 2 lists will be largest and smallest)
      `        # flatten (lists with smallest and largest item will be on top)
       -       # subtract largest from smallest
        Ä      # take absolute value (as we will have negatives after the previous step)
         Z     # take the largest

Java 8, 140 128

Me afeité un montón, en parte gracias a VTCAKAVSMoACE.

int l(int[]a,int d){int x=0,i=0,f,j,k;for(;i<=a.length-d;i++)for(j=i;j<i+d;j++)for(k=i;k<i+d;)x=(f=a[j]-a[k++])>x?f:x;return x;}

Sin golf

int l(int[]a,int d){
    int x=0,i=0,f,j,k;
    for(;i<=a.length-d;i++)
        for(j=i;j<i+d;j++)
            for(k=i;k<i+d;)
                x=(f=a[j]-a[k++])>x?f:x;
    return x;
}

Mathematica, 41 37 bytes

Max[MovingMap[MinMax,#,#2-1].{-1,1}]&

Ruby, 45 bytes

->a,d{a.each_cons(d).map{|b|b.max-b.min}.max}

Siento que esto podría ser mucho mejor.

MATLAB con estadísticas y cajas de herramientas de procesamiento de imágenes, 33 bytes

@(v,d)max(range(im2col(v,[1 d])))

Esto define una función anónima. Ejemplo de uso:

>> f = @(v,d)max(range(im2col(v,[1 d])));
>> f([6,9,4,7,4,1], 3)
ans =
     6

También puede probarlo en Octave en Ideone (pero Octave, a diferencia de Matlab, requiere cargar explícitamente el paquete de imágenes).

Explicación

im2col(v,[1 d]))   % Takes overlapping blocks of size d from v, and arranges them as
                   % columns of a matrix
range(...)         % Maximum minus minimum of each column. Gives a row vector
max(...)           % Maximum of the above row vector

Scala, 48 bytes

(_:Seq[Int])sliding(_:Int)map(s=>s.max-s.min)max

Sin golf:

(a:Seq[Int],d:Int)=>a.sliding(d).map(s=>s.max-s.min).max

Explicación:

(_:Seq[Int])   //define a function with a seq of ints as an argument
sliding(_:Int) //get the sequences with the length of an int argument
map(s=>        //map each sequence
  s.max-s.min    //to its deviation
)max           //and take the maximum value

MATL , 10 bytes

YCS5LY)dX>

Pruébalo en línea!

Explicación

Considere las entradas [6,9,4,7,4,1], 3 como ejemplo.

       % Implicitly take the two inputs: v, d
       % STACK: [6,9,4,7,4,1], 3
YC     % Matrix of overlapping d-blocks of v
       % STACK: [6 9 4 7
                 9 4 7 4
                 4 7 4 1]
S      % Sort each column
       % STACK: [4 4 4 1
                 6 7 4 4
                 9 9 7 7]
5LY)   % Keep first and last rows
       % STACK: [4 4 4 1
                 9 9 7 7]
d      % Differences along each column
       % STACK: [5 5 3 6]
X>     % Maximum
       % STACK: 6
       % Implicitly display

En realidad , 13 bytes

╗╜@V`;m@M-`MM

Pruébalo en línea!

-6 bytes de la observación en la respuesta Haskell de nimi , que los cortes más cortos que dno afectan la desviación máxima.

Explicación:

╗╜@V`;m@M-`MM
╗              store d in register 0
 ╜@            push d, swap so v is on top
   V           push all slices of v whose length is in [1, d]
    `;m@M-`M   map (for each slice):
     ;m@M-       get minimum and maximum, subtract min from max
           M  get maximum of list of deviations

PHP, 89 87 bytes

for($i=1;$r=array_slice($argv,++$i,$argv[1]);$d=max($r)-min($r))$o=$d>$o?$d:$o;echo+$o;

No es particularmente inteligente o bonita, pero funciona. Usar como:

php -r "for($i=1;$r=array_slice($argv,++$i,$argv[1]);$d=max($r)-min($r))$o=$d>$o?$d:$o;echo+$o;" 3 6 9 4 7 1

para v= 6,9,4,7,4,1, d=3

Editar: 2 bytes guardados gracias a Jörg Hülsermann

CJam , 17 bytes

q~ew{$)\(\;-}%:e>

(También q~ew:$z)\(\;.-:e> )

Pruébalo en línea!

Explicación

q~                   e# Read the two inputs. Evaluate
  ew                 e# Overlapping blocks
    {       }%       e# For each block
     $               e# Sort
      )              e# Get last element (that is, maximum)
       \(            e# Swap, get first element (minimum)
         \;          e# Swap, delete rest of the block
           -         e# Subtract (maximum minus minimum)
              :e>    e# Maximum of array

Java 7.159 bytes

Java = caro (sé que se puede jugar mucho más)

int c(int[]a,int d){int[]b=new int[d];int i,j,s=0;for(i=-1;i<a.length-d;){for(j=++i;j<i+d;)b[i+d-1-j]=a[j++];Arrays.sort(b);s=(j=b[d-1]-b[0])>s?j:s;}return s;}

Sin golf

static int c ( int []a , int d){
    int []b = new int[ d ];
    int i , j , s = 0 ;
    for ( i = -1 ; i < a.length - d ;) {
        for ( j = ++i ; j < i + d ;)
        b[ i + d - 1 - j ] = a[ j++ ] ;
        Arrays.sort( b ) ;
        s = ( j = b[ d - 1 ] - b[ 0 ] ) > s ? j : s ;
    }
    return s ;
    }

Haskell, 56 bytes

_#[]=0 
d#l|m<-take d l=max(maximum m-minimum m)$d#tail l

Ejemplo de uso: 3 # [6,9,4,7,4,1]-> 6.

Teniendo en cuenta los rangos menos dno cambia el máximo total, por lo que podemos correr take dhasta el final de la lista (es decir, también incluyen los rangos con el último d-1, d-2, ... 0elementos). La recursión se detiene con la lista vacía donde establecemos la desviación 0.

Java, 126 bytes

Me inspiré en la respuesta de dpa97 y encontré esto:

int f(int v[],int d){int m=0,i=0,j,t,l=v.length;for(;i<l;i++)for(j=i;j<l;j++)m=j-i<d&&(t=Math.abs(v[i]-v[j]))>m?t:m;return m;}

Código expandido, golfizado y de ejemplo

Raqueta 121 bytes

(let p((v v)(j 0))(let*((l(take v d))(k(-(apply max l)(apply min l)))
(j(if(> k j)k j)))(if(= d(length v))j(p(cdr v)j))))

Sin golf:

(define (f d v)
  (let loop ((v v)
             (mxdev 0))                     ; start with max deviation as 0
    (let* ((l (take v d))                   ; take initial d elements in v
           (dev (- (apply max l)            ; find deviation
                    (apply min l)))
           (mxdev (if(> dev mxdev)          ; note max deviation
                   dev
                   mxdev)))
      (if (= d (length v)) mxdev            ; if all combinations tested, print max deviation
          (loop (rest v) mxdev))            ; else test again 
      )))                                   ; with first element of list removed

Pruebas:

(f 3 '(6 9 4 7 4 1))

Salida:

6

q, 25 bytes

{max mmax[y;x]-mmin[y;x]}

mmaxy mminson ventanas deslizantes máximas y mínimas respectivamente

Ejemplo

q){max mmax[y;x]-mmin[y;x]}[6 9 4 7 4 1;3]
6

C #, 131 bytes

aquí hay una solución detallada de linq

int c(int[]a){var x=from j in Enumerable.Range(0,a.Length-2)let p=new[]{a[j],a[j+1],a[j+2]}select p.Max()-p.Min();return x.Max();}

C #, 163 bytes

Golfizado:

int m(List<int> v,int d){var l=new List<List<int>>();for(int i=0;i<v.Count;i++){if(v.Count-i>=d)l.Add(v.GetRange(i,d));}return l.Select(o=>o.Max()-o.Min()).Max();}

Sin golf:

public int m(List<int> v, int d)
{
  var l = new List<List<int>>();

  for (int i = 0; i < v.Count; i++)
  {
    if (v.Count - i >= d)
      l.Add(v.GetRange(i, d));
  }

  return l.Select(o => o.Max() - o.Min()).Max();
}

Prueba:

var maximumDeviation = new MaximumDeviation();
Console.WriteLine(maximumDeviation.f(new List<int> {6,9,4,7,4,1}, 3));

Salida:

6

Pyth, 11 bytes

eSms.+Sd.:F

Explicación

eSms.+Sd.:FQ   Implicit input
          FQ   Unpack the input (v, d)
        .:     Get all subsequences of length d
  m   Sd       Sort each
   s.+         Take the sum of differences to get the deviation
eS             Get the maximum

Jalea , 8 bytes

ṡµṂ€ạṀ€Ṁ

Pruébalo en línea!

Utiliza el mismo algoritmo que Dyalog APL, pero lo imaginé antes de mirarlo.

Explicación:

ṡµṂ€ạṀ€Ṁ ḷ“Main link. Arguments: v d.”
ṡ        ḷ“Overlapping sublists of x of length y.”
 µ       ḷ“Start a new monadic chain.”
  Ṃ€ạṀ€  ḷ“Find the deviation of each of the elements of x.”
       Ṁ ḷ“Take the maximum of x.”

Nota: x, yse dejan, argumentos derecho, respectivamente.

Perl 6 , 44 bytes

{$^a.rotor($^b=>1-$^b).map({.max-.min}).max}

$^ay $^bson los dos argumentos de la función, llamados vy drespectivamente en la declaración del problema. El rotormétodo devuelve la secuencia de subsecuencias vde tamaño d.

Clojure, 73 67 bytes

Editar: Usar en #(...)lugar de (fn[...])y en forlugar de map.

#(apply max(for[p(partition %2 1 %)](-(apply max p)(apply min p))))

Python 3, 80 bytes

lambda v,d:max(map(lambda g:max(g)-min(g),[v[i:i+d]for i in range(-~len(v)-d)]))