Considérons un tableau xtel que [1 5 3 4]et un nombre n, par exemple 2. Écrivez tous longueur - nsous - tableaux coulissants: [1 5], [5 3], [3 4]. Soit le minimax du tableau défini comme le minimum des maxima des blocs glissants. Donc, dans ce cas, ce serait le minimum de 5, 5, 4, ce qui est 4.

Défi

Étant donné un tableau xet un entier positif n, affichez le minimax tel que défini ci-dessus.

Le tableau xne contiendra que des entiers positifs. nsera toujours au moins 1et au plus la longueur de x.

Le calcul peut être effectué par n'importe quelle procédure, pas nécessairement comme défini ci-dessus.

Code golf, le moins d'octets gagne.

Cas de test

x, n, Résultat

[1 5 3 4], 2                    4
[1 2 3 4 5], 3                  3
[1 1 1 1 5], 4                  1
[5 42 3 23], 3                 42

Dyalog APL, 4 octets

⌊/⌈/

Il s'agit d'un train de fonctions monadique qui attend un tableau et un entier comme arguments droit et gauche, resp.

Essayez-le avec TryAPL .

Comment ça fonctionne

Un train de deux fonctions est un sommet , ce qui signifie que celui de droite est appelé en premier (avec les deux arguments), puis celui de gauche est appelé au-dessus (avec le résultat comme seul argument).

Un monadique f/réduit simplement son argument de f. Cependant, s'il est appelé dyadiquement, il f/est réduit n et prend la taille de tranche comme argument de gauche.

⌊/⌈/    Monadic function. Right argument: A (array). Left argument: n (list)

  ⌈/    N-wise reduce A by maximum, using slices of length n.
⌊/      Reduce the maxima by minimum.

CJam (11 octets)

{ew::e>:e<}

Démo en ligne

Ruby 39 octets

->(x,n){x.each_slice(n).map(&:max).min}

Où x est le tableau et n est le nombre par lequel découper le tableau.

Pyth, 10 octets

hSmeSd.:QE

Explication:

           - autoassign Q = eval(input())
      .:QE -   sublists(Q, eval(input())) - all sublists of Q of length num
  meSd     -  [sorted(d)[-1] for d in ^]
hS         - sorted(^)[0]

Prend entrée dans le formulaire list newline int

Essayez-le ici!

Ou lancez une suite de tests!

Ou aussi 10 octets

hSeCSR.:EE

Explication:

      .:EE -    sublists(Q, eval(input())) - all sublists of Q of length num 
    SR     -   map(sorted, ^)
  eC       -  transpose(^)[-1]
hS         - sorted(^)[0]

Test Suite ici

Oracle SQL 11.2, 261 octets

SELECT MIN(m)FROM(SELECT MAX(a)OVER(ORDER BY i ROWS BETWEEN CURRENT ROW AND :2-1 FOLLOWING)m,SUM(1)OVER(ORDER BY i ROWS BETWEEN CURRENT ROW AND:2-1 FOLLOWING)c FROM(SELECT TRIM(COLUMN_VALUE)a,rownum i FROM XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))))WHERE:2=c;

Non golfé

SELECT MIN(m)
FROM   (
         SELECT MAX(a)OVER(ORDER BY i ROWS BETWEEN CURRENT ROW AND :2-1 FOLLOWING)m,
                SUM(1)OVER(ORDER BY i ROWS BETWEEN CURRENT ROW AND :2-1 FOLLOWING)c
         FROM   (
                  SELECT TRIM(COLUMN_VALUE)a,rownum i 
                  FROM XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))
                )
       )
WHERE :2=c;

MATL , 6 octets

YCX>X<

Essayez-le en ligne!

YC    % Implicitly input array and number. Build a matrix with columns formed
      % by sliding blocks of the array with size given by the number
X>    % maximum of each column
X<    % minimum of all maxima

Gelée, 6 octets

ṡ»/€«/

Essayez-le en ligne!

Comment ça fonctionne

ṡ»/€«/  Main link. Left input: A (list). Right input: n (integer)

ṡ       Split A into overlapping slices of length n.
 »/€    Reduce each slice by maximum.
    «/  Reduce the maxima by minimum.

JavaScript (ES6), 84 83 72 octets

(x,y)=>Math.min(...x.slice(y-1).map((a,i)=>Math.max(...x.slice(i,i+y))))

Merci à user81655 pour avoir aidé à raser 11 octets

Julia, 51 octets

f(x,n)=min([max(x[i-n+1:i]...)for i=m:endof(x)]...)

Rien de trop révolutionnaire. Il s'agit d'une fonction qui accepte un tableau et un entier et renvoie un entier. Il utilise simplement l'algorithme de base. Ce serait beaucoup plus court simin et maxne nécessitait pas de répartir les tableaux en arguments.

Nous obtenons chaque sous-tableau qui se chevauchent, prenons le max et prenons le min du résultat.

Perl 6 , 32 octets

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

Usage:

my &minimax = {@^a.rotor($^b=>1-$b)».max.min}

say minimax [1,5,3,4], 2;    # 4
say minimax [1,2,3,4,5], 3;  # 3
say minimax [1,1,1,1,5], 4;  # 1
say minimax [5,42,3,23], 3;  # 42

R, 41 35 octets

Nécessite l'installation d'un zoo.

function(x,n)min(zoo::rollmax(x,n))

edit - 6 octets en réalisant qu'il zoo::rollmaxexiste!

J, 9 octets

[:<./>./\

Similaire à la réponse APL. >./\s'applique >./(maximum) aux sous-ensembles (arg gauche) de l'arg droit. Ensuite, <./trouve le minimum, car il est plafonné avec[: .

Cas de test

   f =: [:<./>./\
   2 f 1 5 3 4
4
   3 f 1 2 3 4 5
3
   3 f 1 1 1 1 5
1
   3 f 5 42 3 23
42

Python 3, 55 octets.

lambda x,n:min(max(x[b:b+n])for b in range(len(x)-n+1))

Cas de test:

assert f([1, 5, 3, 4], 2) == 4
assert f([1, 2, 3, 4, 5], 3) == 3
assert f([1, 1, 1, 1, 5], 4) == 1
assert f([5, 42, 3, 23], 3 ) == 42

Python 2, 50 octets

f=lambda l,n:l[n-1:]and min(max(l[:n]),f(l[1:],n))

Calcule récursivement le minimum de deux choses: le maximum des premières nentrées et la fonction récursive de la liste avec le premier élément supprimé. Pour un cas de base de la liste ayant moins de que néléments, donne la liste vide, qui sert d'infini car Python 2 place les listes comme supérieures aux nombres.

JavaScript (ES6), 70 octets

x=>n=>-M(...x.slice(n-1).map((_,i)=>-M(...x.slice(i,i+n)))),M=Math.max

En utilisant le curry , cette fonction enregistre 2 octets de la réponse précédente.

Démo

f=x=>n=>-M(...x.slice(n-1).map((_,i)=>-M(...x.slice(i,i+n)))),M=Math.max
a=[[[1,5,3,4],2,4],[[1,2,3,4,5],3,3],[[1,1,1,1,5],4,1],[[5,42,3,23],3,42]]
document.write(`<pre>${a.map(r=>`${f(r[0])(r[1])==r[2]?'PASS':'FAIL'} ${r[1]}=>${r[2]}`).join`\n`}`)

Mathematica, 23 octets

Min@BlockMap[Max,##,1]&

Cas de test

%[{1,2,3,4,5},3]
(* 3 *)

Java 7, 128 126 124 octets

int c(int[]x,int n){int i=-1,j,q,m=0;for(;i++<x.length-n;m=m<1|q<m?q:m)for(q=x[i],j=1;j<n;j++)q=x[i+j]>q?x[i+j]:q;return m;}

Code non testé et testé:

Essayez-le ici.

class M{
  static int c(int[] x, int n){
    int i = -1,
        j,
        q,
        m = 0;
    for(; i++ < x.length - n; m = m < 1 | q < m
                                           ? q
                                           : m){
      for(q = x[i], j = 1; j < n; j++){
        q = x[i+j] > q
             ? x[i+j]
             : q;
      }
    }
    return m;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1, 5, 3, 4 }, 2));
    System.out.println(c(new int[]{ 1, 2, 3, 4, 5 }, 3));
    System.out.println(c(new int[]{ 1, 1, 1, 1, 5 }, 4));
    System.out.println(c(new int[]{ 5, 42, 3, 23 }, 3));
  }
}

Production:

4
3
1
42

Raquette 84 octets

(λ(l i)(apply min(for/list((j(-(length l)(- i 1))))(apply max(take(drop l j) i)))))

Non golfé:

(define f
  (λ (l i)
    (apply min (for/list ((j (- (length l)
                                (- i 1))))
                 (apply max (take (drop l j) i))
                 ))))

Essai:

(f '[1 5 3 4]  2)
(f '[1 2 3 4 5] 3)
(f '[5 42 3 23] 3)

Production:

4
3
42

Clojure, 51 octets

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

SmileBASIC, 68 octets

M=MAX(X)DIM T[N]FOR I=.TO LEN(X)-N-1COPY T,X,I,N
M=MIN(M,MAX(T))NEXT

Rien de spécial ici. Les entrées sont X[]etN