Considere una matriz xcomo [1 5 3 4]y un número n, por ejemplo 2. Escribir todos de talla nsubarreglos correderas: [1 5], [5 3], [3 4]. Deje que el minimax de la matriz se define como el mínimo de los máximos de los bloques de deslizamiento. Entonces, en este caso, sería el mínimo de 5, 5, 4, que es 4.

Desafío

Dada una matriz xy un entero positivo n, genera el minimax como se definió anteriormente.

La matriz xsolo contendrá enteros positivos. nsiempre será al menos 1y como mucho la longitud de x.

El cálculo puede realizarse por cualquier procedimiento, no necesariamente como se definió anteriormente.

Código de golf, menos bytes gana.

Casos de prueba

x, n, Resultará

[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 bytes

⌊/⌈/

Este es un tren de funciones monádicas que espera una matriz y un entero como argumentos derecho e izquierdo, resp.

Pruébalo con TryAPL .

Cómo funciona

Un tren de dos funciones está encima , lo que significa que primero se llama a la derecha (con ambos argumentos), luego se llama a la izquierda encima (con el resultado como único argumento).

Un monádico f/simplemente reduce su argumento por f. Sin embargo, si se llama de forma diádica, f/se reduce en n, y toma el tamaño de corte como argumento izquierdo.

⌊/⌈/    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 bytes)

{ew::e>:e<}

Demostración en línea

Ruby 39 bytes

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

Donde x es la matriz yn es el número por el cual se divide la matriz.

Pyth, 10 bytes

hSmeSd.:QE

Explicación:

           - 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]

Toma entrada en el formulario list newline int

Pruébalo aquí!

¡O ejecuta una suite de prueba!

O también 10 bytes

hSeCSR.:EE

Explicación:

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

Test Suite aquí

Oracle SQL 11.2, 261 bytes

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;

Sin 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 bytes

YCX>X<

Pruébalo en línea!

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

Jalea, 6 bytes

ṡ»/€«/

Pruébalo en línea!

Cómo funciona

ṡ»/€«/  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 bytes

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

Gracias a user81655 por ayudar a reducir 11 bytes

Julia, 51 bytes

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

Nada demasiado innovador. Esta es una función que acepta una matriz y un entero y devuelve un entero. Solo usa el algoritmo básico. Sería mucho más corto si miny maxno requería matrices Splatting en argumentos.

Obtenemos cada submatriz superpuesta, tomamos el máximo y tomamos el mínimo del resultado.

Perl 6 , 32 bytes

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

Uso:

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 bytes

Requiere que se instale el zoológico.

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

editar - ¡6 bytes al darse cuenta de que zoo::rollmaxexiste!

J, 9 bytes

[:<./>./\

Similar a la respuesta APL. >./\se aplica >./(máximo) a los subconjuntos (argumento izquierdo) del argumento derecho. Luego, <./encuentra el mínimo de eso, ya que está limitado con [:.

Casos de prueba

   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 bytes.

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

Casos de prueba:

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 bytes

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

Calcula recursivamente el mínimo de dos cosas: el máximo de las primeras nentradas y la función recursiva en la lista con el primer elemento eliminado. Para un caso base de la lista que tiene menos de nelementos, da la lista vacía, que sirve como infinito porque Python 2 pone las listas como mayores que los números.

JavaScript (ES6), 70 bytes

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

Al usar curry , esta función ahorra 2 bytes de la respuesta anterior.

Manifestación

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 bytes

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

Caso de prueba

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

Java 7, 128 126 124 bytes

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

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

4
3
1
42

Raqueta 84 bytes

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

Sin golf:

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

Pruebas:

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

Salida:

4
3
42

Clojure, 51 bytes

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

SmileBASIC, 68 bytes

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

Nada especial aquí. Las entradas son X[]yN