Esse problema é "inspirado" a partir de uma pergunta que foi originalmente feita no Quora (não no código de golfe). Eu só quero fazer disso um desafio para vocês (e meu primeiro problema de envio aqui).

Dada uma matriz de elementos inteiros ve um número inteiro d(assumimos que d é menor ou igual ao comprimento da matriz), considere todas as seqüências de delementos consecutivos na matriz. Para cada sequência, calcule a diferença entre o valor máximo e mínimo dos elementos nessa sequência e nomeie-o como desvio.

Sua tarefa é escrever um programa ou função que calcule o valor máximo entre todos os desvios de todas as seqüências consideradas acima e retornar ou gerar esse valor.

Exemplo elaborado:

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.

Isso é código de golfe, então a resposta mais curta em bytes vence.

Dyalog APL, 7 bytes

⌈/⌈/-⌊/

Teste-o no TryAPL .

Como 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

Economizando 5 bytes graças a Neil

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

Minha primeira lambda recursiva!

Uso:

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

Perl, 48 bytes

Inclui +5 para -0pi

Dê a largura após a -iopção, dê os elementos como linhas separadas em STDIN:

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

Apenas o código:

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

(use um literal \npara a pontuação reivindicada)

R, 63 62 56 bytes

Billywob já forneceu uma ótima resposta R usando apenas as funções básicas . No entanto, eu queria ver se uma abordagem alternativa era possível, talvez usando alguns dos extensos pacotes de R. Há uma função interessante rollapplyno zoopacote projetada para aplicar uma função a uma janela rotativa de uma matriz, para que se ajuste bem a nossos propósitos. Usamos rollapplypara encontrar o maxde cada janela e usamos novamente para encontrar o minde cada janela. Então tomamos a diferença entre os máximos e os minutos, o que nos dá o desvio para cada janela e depois retornamos maxos valores.

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

R, 80 bytes de 77 bytes

Edit: Salvo 3 bytes graças 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]

Solução iterativa. Loops $v, mas na verdade estamos apenas usando isso como um contador, em vez de realmente passar pelos valores. Cada iteração, estamos corte $vpor $i..($i+++$d-1), onde $io padrão é 0. Nós |sortesses elementos e armazenamos o resultado $x. Então pegamos o maior [-1]e subtraímos o menor [0]. Nós, então, |sortobtemos esses resultados e obtemos o maior deles [-1]. Esse número é deixado no pipeline e a saída é implícita.

Exemplos

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

Usa a codificação CP-1252 .

Œù€{øÀ`-ÄZ

Experimente online!

Explicação

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

Raspou um monte, em parte graças ao 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;}

Ungolfed

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}

Eu sinto que isso poderia ser muito melhor.

MATLAB com caixas de ferramentas de estatística e processamento de imagens, 33 bytes

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

Isso define uma função anônima. Exemplo de uso:

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

Você também pode experimentá-lo no Octave no Ideone (mas o Octave, ao contrário do Matlab, exige o carregamento explícito do pacote de imagens).

Explicação

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

Ungolfed:

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

Explicação:

(_: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>

Experimente online!

Explicação

Considere as entradas [6,9,4,7,4,1], 3 como exemplo.

       % 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

Na verdade , 13 bytes

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

Experimente online!

-6 bytes da observação na resposta Haskell de nimi , que fatias menores que dnão afetam o desvio máximo.

Explicação:

╗╜@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;

Não é particularmente inteligente ou bonito, mas funciona. Use 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

Edit: 2 bytes salvos graças a Jörg Hülsermann

CJam , 17 bytes

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

(Além disso q~ew:$z)\(\;.-:e> )

Experimente online!

Explicação

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 (eu sei que pode ser jogado muito mais)

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

Ungolfed

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

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

Considerando gamas inferiores a dnão altera o máximo global, para que possamos correr take dpara baixo até o fim da lista (ou seja, também incluem as faixas com o último d-1, d-2, ... 0elementos). A recursão para com a lista vazia em que definimos o desvio 0.

Java, 126 bytes

Eu me inspirei na resposta do dpa97 e achei o seguinte:

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, golfe e de exemplo

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

Ungolfed:

(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

Teste:

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

Saída:

6

q, 25 bytes

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

mmaxe mminsão a janela deslizante máxima e mínima respectivamente

Exemplo

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

C #, 131 bytes

aqui está uma solução linq detalhada

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

Golfe:

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

Ungolfed:

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

Teste:

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

Saída:

6

Pitão, 11 bytes

eSms.+Sd.:F

Explicação

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

Gelatina , 8 bytes

ṡµṂ€ạṀ€Ṁ

Experimente online!

Usa o mesmo algoritmo que o Dyalog APL, mas percebi isso antes de olhar para ele.

Explicação:

ṡµṂ€ạṀ€Ṁ ḷ“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, ysão deixados, argumentos certos respectivamente.

Perl 6 , 44 bytes

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

$^ae $^bsão os dois argumentos para a função, chamados ve drespectivamente na declaração do problema. O rotormétodo retorna a sequência de subsequências vde tamanho d.

Clojure, 73 67 bytes

Editar: usando em #(...)vez de (fn[...])e em forvez 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)]))