Ce problème est "inspiré" d'une question posée à l'origine sur Quora (pas pour le golf à code). Je veux juste en faire un défi pour vous les gars (et ma première soumission de problème ici).

Étant donné un tableau d'éléments entiers vet un entier d(nous supposons que d est inférieur ou égal à la longueur du tableau), considérons toutes les séquences d' déléments consécutifs dans le tableau. Pour chaque séquence, calculez la différence entre la valeur maximale et minimale des éléments de cette séquence et nommez-la l'écart.

Votre tâche consiste à écrire un programme ou une fonction qui calcule la valeur maximale parmi tous les écarts de toutes les séquences considérées ci-dessus, et à retourner ou à sortir cette valeur.

Exemple élaboré:

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.

C'est le golf de code, donc la réponse la plus courte en octets l'emporte.

Dyalog APL, 7 octets

⌈/⌈/-⌊/

Testez-le sur TryAPL .

Comment ça fonctionne

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

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

Python, 60 octets

Économiser 5 octets grâce à Neil

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

Ma première lambda récursive!

Usage:

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

Perl, 48 octets

Comprend +5 pour -0pi

Donnez la largeur après l' -ioption, donnez les éléments sous forme de lignes distinctes sur STDIN:

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

Juste le code:

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

(utilisez un littéral \npour le score revendiqué)

R, 63 62 56 octets

Billywob a déjà fourni une excellente réponse R en utilisant uniquement les fonctions de base . Cependant, je voulais voir si une approche alternative était possible, peut-être en utilisant certains des packages complets de R. Il y a une belle fonction rollapplydans le zoopackage conçue pour appliquer une fonction à une fenêtre déroulante d'un tableau, ce qui correspond bien à nos besoins. Nous utilisons rollapplypour trouver le maxde chaque fenêtre, et nous l'utilisons à nouveau pour trouver le minde chaque fenêtre. Ensuite, nous prenons la différence entre les maximales et les minutes, ce qui nous donne l'écart pour chaque fenêtre, puis renvoyons la maxde celles-ci.

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

R, 80 77 octets octets

Edit: sauvé 3 octets grâce à @rturnbull

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

PowerShell v2 +, 68 octets

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

Solution itérative. Boucles à travers $v, mais nous utilisons vraiment cela comme un compteur plutôt que de passer réellement par les valeurs. Chaque itération, nous sommes découpage en tranches $vpar $i..($i+++$d-1), où la $ivaleur par défaut 0. Nous |sortces éléments et stockons le résultat dans $x. Ensuite, nous prenons le plus grand [-1]et soustrayons le plus petit [0]. Nous avons ensuite |sortces résultats et prenons le plus grand [-1]de cela. Ce nombre est laissé sur le pipeline et la sortie est implicite.

Exemples

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 octets

Utilise l' encodage CP-1252 .

Œù€{øÀ`-ÄZ

Essayez-le en ligne!

Explication

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

Rasé un tas, en partie grâce à 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;}

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

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

Rubis, 45 octets

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

Je pense que cela pourrait être beaucoup mieux.

MATLAB avec statistiques et boîtes à outils de traitement d'image, 33 octets

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

Cela définit une fonction anonyme. Exemple d'utilisation:

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

Vous pouvez également l' essayer sur Octave à Ideone (mais Octave, contrairement à Matlab, nécessite de charger explicitement le paquet d'images).

Explication

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 octets

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

Non golfé:

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

Explication:

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

YCS5LY)dX>

Essayez-le en ligne!

Explication

Prenons l'exemple des entrées [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

En fait , 13 octets

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

Essayez-le en ligne!

-6 octets de l'observation dans la réponse Haskell de nimi , que les tranches plus courtes que dn'affectent pas l'écart maximum.

Explication:

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

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

Pas particulièrement intelligent ou joli mais ça marche. Utilisez comme:

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

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

Edit: 2 octets enregistrés grâce à Jörg Hülsermann

CJam , 17 octets

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

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

Essayez-le en ligne!

Explication

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 octets

Java = cher (je sais qu'il peut être joué beaucoup plus)

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

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

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

Exemple d'utilisation: 3 # [6,9,4,7,4,1]-> 6.

Compte tenu des plages moins dne change pas le maximum d' ensemble, afin que nous puissions courir take djusqu'à la fin de la liste (c. -à inclure également les gammes avec les derniers d-1, d-2... 0éléments). La récursivité s'arrête avec la liste vide où nous définissons l'écart 0.

Java, 126 octets

Je me suis inspiré de la réponse de dpa97 et j'ai trouvé ceci:

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

Code développé, golfé et exemple

Raquette 121 octets

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

Non 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

Essai:

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

Production:

6

q, 25 octets

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

mmaxet mminsont des fenêtres coulissantes maximum et minimum respectivement

Exemple

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

C #, 131 octets

voici une solution linq verbeuse

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 octets

Golfé:

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

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

Tester:

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

Production:

6

Pyth, 11 octets

eSms.+Sd.:F

Explication

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

Gelée , 8 octets

ṡµṂ€ạṀ€Ṁ

Essayez-le en ligne!

Utilise le même algorithme que Dyalog APL, mais je l'ai compris moi-même avant de le regarder.

Explication:

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

Note: x, ysont à gauche, à droite respectivement arguments.

Perl 6 , 44 octets

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

$^aet $^bsont les deux arguments de la fonction, appelés vet drespectivement dans l'énoncé du problème. La rotorméthode renvoie la séquence de sous-séquences vde taille d.

Clojure, 73 67 octets

Modifier: utiliser à la #(...)place de (fn[...])et forau lieu de map.

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

Python 3, 80 octets

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