Questo problema è "ispirato" da una domanda originariamente posta su Quora (non per il golf del codice). Voglio solo renderlo una sfida per voi ragazzi (e la mia prima presentazione dei problemi qui).

Dato un array di elementi interi ve un intero d(supponiamo che d sia inferiore o uguale alla lunghezza dell'array), considera tutte le sequenze di delementi consecutivi nell'array. Per ogni sequenza, calcola la differenza tra il valore massimo e minimo degli elementi in quella sequenza e chiamala deviazione.

Il tuo compito è scrivere un programma o una funzione che calcoli il valore massimo tra tutte le deviazioni di tutte le sequenze considerate sopra e restituire o emettere quel valore.

Esempio elaborato:

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.

Questo è il golf del codice, quindi vince la risposta più breve in byte.

Dyalog APL, 7 byte

⌈/⌈/-⌊/

Provalo su TryAPL .

Come funziona

⌈/⌈/-⌊/  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 byte

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

Python, 60 byte

Salvataggio di 5 byte grazie a Neil

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

La mia prima lambda ricorsiva!

Uso:

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

Perl, 48 byte

Include +5 per -0pi

Dare la larghezza dopo l' -iopzione, dare gli elementi come linee separate su STDIN:

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

Solo il codice:

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

(usa un valore letterale \nper il punteggio richiesto)

R, 63 62 56 byte

Billywob ha già fornito un'ottima risposta R utilizzando solo le funzioni di base . Tuttavia, volevo vedere se era possibile un approccio alternativo, forse usando alcuni dei pacchetti estesi di R. C'è una bella funzione rollapplynel zoopacchetto progettata per applicare una funzione a una finestra mobile di un array, in modo che si adatti bene ai nostri scopi. Usiamo rollapplyper trovare la maxfinestra di ogni finestra e la riutilizziamo per trovare la minfinestra di ciascuna finestra. Quindi prendiamo la differenza tra i massimi e i min, che ci dà la deviazione per ogni finestra, e quindi restituiamo il valore maxdi quelli.

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

R, 80 77 byte byte

Modifica: salvato 3 byte grazie 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 byte

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

Soluzione iterativa. Passa attraverso $v, ma in realtà lo stiamo solo usando come contatore piuttosto che passare attraverso i valori. Ogni iterazione, siamo affettare $vda $i..($i+++$d-1), dove $iil valore predefinito 0. Noi |sortquegli elementi e archiviamo il risultato $x. Quindi prendiamo il più grande [-1]e sottraggiamo il più piccolo [0]. Abbiamo quindi |sortquei risultati e ne prendiamo il massimo [-1]. Quel numero è rimasto sulla pipeline e l'output è implicito.

Esempi

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 byte

Utilizza la codifica CP-1252 .

Œù€{øÀ`-ÄZ

Provalo online!

Spiegazione

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

Rasato un sacco, in parte grazie 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;}

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 byte

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

Rubino, 45 byte

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

Penso che questo potrebbe essere molto meglio.

MATLAB con toolbox per l'elaborazione di statistiche e immagini, 33 byte

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

Questo definisce una funzione anonima. Esempio di utilizzo:

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

Puoi anche provarlo su Octave su Ideone (ma Octave, a differenza di Matlab, richiede di caricare esplicitamente il pacchetto di immagini).

Spiegazione

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 byte

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

Spiegazione:

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

YCS5LY)dX>

Provalo online!

Spiegazione

Considerare gli input [6,9,4,7,4,1], 3 come esempio.

       % 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

In realtà , 13 byte

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

Provalo online!

-6 byte dall'osservazione nella risposta Haskell di nimi , che le sezioni più brevi di dnon influiscono sulla deviazione massima.

Spiegazione:

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

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

Non particolarmente intelligente o carino ma funziona. Usa come:

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

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

Modifica: 2 byte salvati grazie a Jörg Hülsermann

CJam , 17 byte

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

(Anche q~ew:$z)\(\;.-:e>)

Provalo online!

Spiegazione

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 byte

Java = costoso (so che può essere giocato a golf molto di più)

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 byte

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

Esempio di utilizzo: 3 # [6,9,4,7,4,1]-> 6.

Considerando intervalli meno di dnon modificare la globale massimo, in modo da poter eseguire take dfino alla fine della lista (cioè includere anche gli intervalli con l'ultimo d-1, d-2, ... 0elementi). La ricorsione si interrompe con l'elenco vuoto in cui impostiamo la deviazione su 0.

Java, 126 byte

Mi sono ispirato alla risposta di dpa97 e ho trovato questo:

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

Codice espanso, golfed ed esempio

Racchetta 121 byte

(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

test:

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

Produzione:

6

q, 25 byte

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

mmaxe mminsono rispettivamente finestra massima e minima scorrevoli

Esempio

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

C #, 131 byte

ecco una soluzione linq dettagliata

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 byte

golfed:

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

Test:

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

Produzione:

6

Pyth, 11 byte

eSms.+Sd.:F

Spiegazione

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 byte

ṡµṂ€ạṀ€Ṁ

Provalo online!

Utilizza lo stesso algoritmo di Dyalog APL, ma l'ho capito da solo prima di guardarlo.

Spiegazione:

ṡµṂ€ạṀ€Ṁ ḷ“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, ysono lasciati, gli argomenti giusti, rispettivamente.

Perl 6 , 44 byte

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

$^ae $^bsono i due argomenti della funzione, chiamati ve drispettivamente nell'istruzione problematica. Il rotormetodo restituisce la sequenza di sottosequenze vdi dimensioni d.

Clojure, 73 67 byte

Modifica: usando #(...)invece di (fn[...])e forinvece di map.

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

Python 3, 80 byte

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