Dieses Problem ist von einer Frage "inspiriert", die ursprünglich auf Quora gestellt wurde (nicht für Code-Golf). Ich möchte es nur zu einer Herausforderung für euch machen (und meine erste Problemmeldung hier).

Berücksichtigen Sie bei einem Array von Ganzzahlelementen vund einer Ganzzahl d(wir nehmen an, dass d kleiner oder gleich der Länge des Arrays ist) alle Folgen daufeinanderfolgender Elemente im Array. Berechnen Sie für jede Sequenz die Differenz zwischen dem Maximal- und Minimalwert der Elemente in dieser Sequenz und nennen Sie sie die Abweichung.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die den Maximalwert aller Abweichungen aller oben betrachteten Sequenzen berechnet und diesen Wert zurückgibt oder ausgibt.

Aufgearbeitetes Beispiel:

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.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes.

Dyalog APL, 7 Bytes

⌈/⌈/-⌊/

Testen Sie es auf TryAPL .

Wie es funktioniert

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

5 Bytes sparen dank Neil

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

Mein erstes rekursives Lambda!

Verwendung:

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

Perl, 48 Bytes

Beinhaltet +5 für -0pi

Geben Sie die Breite nach der -iOption an und geben Sie die Elemente als separate Linien in STDIN an:

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

Nur der Code:

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

(Verwenden Sie ein Literal \nfür die beanspruchte Punktzahl)

R, 63 62 56 Bytes

Billywob hat bereits eine großartige R-Antwort geliefert , bei der nur die Basisfunktionen verwendet wurden . Ich wollte jedoch herausfinden, ob ein alternativer Ansatz möglich ist, vielleicht unter Verwendung einiger der umfangreichen Pakete von R. Es gibt eine nette Funktion rollapplyin dem zooPaket, die entwickelt wurde, um eine Funktion auf ein rollendes Fenster eines Arrays anzuwenden, so dass dies gut zu unseren Zwecken passt. Wir verwenden rollapply, um das maxvon jedem Fenster zu finden , und wir verwenden es erneut, um das minvon jedem Fenster zu finden . Dann nehmen wir die Differenz zwischen den Maxima und Minima, die uns die Abweichung für jedes Fenster gibt, und geben dann die maxvon diesen zurück.

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

R, 80 77 Bytes Bytes

Bearbeiten: 3 Bytes dank @rturnbull gespeichert

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]

Iterative Lösung. Schleifen durch $v, aber im Grunde verwenden wir das nur als Zähler, anstatt die Werte tatsächlich durchzugehen. Jede Iteration können wir schneiden $vdurch $i..($i+++$d-1), wo $istandardmäßig 0. Wir |sortdiese Elemente und speichern das Ergebnis in $x. Dann nehmen wir das Größte [-1]und subtrahieren das Kleinste [0]. Wir dann |sortdiese Ergebnisse und nehmen das größte [-1]davon. Diese Nummer bleibt in der Pipeline und die Ausgabe ist implizit.

Beispiele

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

Verwendet die CP-1252- Codierung.

Œù€{øÀ`-ÄZ

Probieren Sie es online!

Erläuterung

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

Zum Teil dank 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}

Ich denke, das könnte viel besser sein.

MATLAB mit Statistik- und Bildverarbeitungs-Toolboxen, 33 Byte

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

Dies definiert eine anonyme Funktion. Beispiel Verwendung:

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

Sie können es auch auf Octave bei Ideone ausprobieren (Octave erfordert jedoch im Gegensatz zu Matlab das explizite Laden des Image-Pakets).

Erläuterung

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

Erläuterung:

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

Probieren Sie es online!

Erläuterung

Betrachten Sie als Beispiel die Eingänge [6,9,4,7,4,1], 3.

       % 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

Eigentlich 13 Bytes

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

Probieren Sie es online!

-6 Bytes von der Beobachtung in Nimis Haskell-Antwort , dass Scheiben kürzer als ddie maximale Abweichung nicht beeinflussen.

Erläuterung:

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

Nicht besonders schlau oder hübsch, aber es funktioniert. Verwenden Sie wie:

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

für v= 6,9,4,7,4,1, d=3

Edit: 2 Bytes gespeichert dank Jörg Hülsermann

CJam , 17 Bytes

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

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

Probieren Sie es online!

Erläuterung

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 = teuer (ich weiß, es kann viel mehr Golf gespielt werden)

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

Anwendungsbeispiel: 3 # [6,9,4,7,4,1]-> 6.

In Anbetracht Bereiche weniger als d, nicht das Gesamt Maximum ändern , damit wir laufen können take d(dh auch die Bereiche mit dem letzten bis zum Ende der Liste nach unten d-1, d-2...0 Elemente). Die Rekursion stoppt mit der leeren Liste, auf die wir die Abweichung setzen 0.

Java, 126 Bytes

Ich habe mich von der Antwort von dpa97 inspirieren lassen und Folgendes gefunden:

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

Erweiterter, Golf- und Beispielcode

Schläger 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

Testen:

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

Ausgabe:

6

q, 25 Bytes

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

mmax und mmin sind Schiebefenster Maximum und Minimum

Beispiel

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

C # 131 Bytes

Hier ist eine ausführliche Linq-Lösung

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

Golf gespielt:

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

Prüfung:

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

Ausgabe:

6

Pyth, 11 Bytes

eSms.+Sd.:F

Erläuterung

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

Gelee , 8 Bytes

ṡµṂ€ạṀ€Ṁ

Probieren Sie es online!

Verwendet den gleichen Algorithmus wie Dyalog APL, aber ich habe das selbst herausgefunden, bevor ich es mir ansah.

Erläuterung:

ṡµṂ€ạṀ€Ṁ ḷ“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.”

Hinweis: x,y sind links, rechts Argumente sind.

Perl 6 , 44 Bytes

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

$^aund $^bsind die beiden Argumente für die Funktion, die in der problem-Anweisung aufgerufen vbzw. dangegeben werden. Die rotorMethode gibt die Folge von Teilsequenzen vder Größe zurück d.

Clojure, 73 67 Bytes

Bearbeiten: Verwenden von #(...)anstelle von (fn[...])und foranstelle von 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)]))