Si consideri un array xcome [1 5 3 4]e un numero n, ad esempio 2. Scrivi tutti length- nsottoarray scorrevoli: [1 5], [5 3], [3 4]. Lascia che il minimox dell'array sia definito come il minimo dei massimi dei blocchi scorrevoli. Quindi in questo caso sarebbe il minimo di 5, 5, 4, che è 4.

Sfida

Dato un array xe un numero intero positivo n, emette il minimox come definito sopra.

L'array xconterrà solo numeri interi positivi. nsarà sempre almeno 1e al massimo la lunghezza di x.

Il calcolo può essere eseguito con qualsiasi procedura, non necessariamente come sopra definito.

Codice golf, vince il minor numero di byte.

Casi test

x, nrisultato

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

⌊/⌈/

Questo è un treno di funzioni monadico che prevede array e numero intero come argomenti destro e sinistro, resp.

Provalo con TryAPL .

Come funziona

Un treno di due funzioni è in cima , il che significa che viene chiamato per primo quello destro (con entrambi gli argomenti), quindi quello sinistro viene chiamato sopra di esso (con il risultato come unico argomento).

Un monadico f/riduce semplicemente il suo argomento di f. Tuttavia, se chiamato diadicamente, f/è n-saggio ridotto e prende la dimensione della fetta come argomento sinistro.

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

{ew::e>:e<}

Demo online

Ruby 39 byte

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

Dove x è l'array e n è il numero per cui raggruppare l'array.

Pyth, 10 byte

hSmeSd.:QE

Spiegazione:

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

Accetta input nel modulo list newline int

Provalo qui!

O esegui una Test Suite!

O anche 10 byte

hSeCSR.:EE

Spiegazione:

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

Test Suite qui

Oracle SQL 11.2, 261 byte

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;

Un-golfed

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 byte

YCX>X<

Provalo online!

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

Gelatina, 6 byte

ṡ»/€«/

Provalo online!

Come funziona

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

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

Grazie a user81655 per aiutare a radere 11 byte

Julia, 51 byte

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

Niente di troppo innovativo. Questa è una funzione che accetta un array e un numero intero e restituisce un numero intero. Utilizza solo l'algoritmo di base. Sarebbe molto più breve se mine maxnon richiedesse la suddivisione di array in argomenti.

Otteniamo ogni subarray sovrapposto, prendiamo il massimo e prendiamo il minimo del risultato.

Perl 6 , 32 byte

{@^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 byte

Richiede lo zoo da installare.

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

modifica - 6 byte realizzando zoo::rollmaxesiste!

J, 9 byte

[:<./>./\

Simile alla risposta APL. >./\si applica >./(massimo) ai subsets (left arg) dell'arg destro. Quindi <./trova il minimo, dato che è limitato [:.

Casi 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 byte.

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

Casi 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 byte

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

Calcola in modo ricorsivo il minimo di due elementi: il massimo delle prime nvoci e la funzione ricorsiva nell'elenco con il primo elemento rimosso. Per un caso di base dell'elenco con meno di nelementi, viene fornito un elenco vuoto, che funge da infinito perché Python 2 inserisce elenchi più grandi dei numeri.

JavaScript (ES6), 70 byte

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

Usando il curry , questa funzione salva 2 byte dalla risposta precedente.

dimostrazione

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 byte

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

Caso di prova

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

Java 7, 128 126 124 byte

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

Codice non testato e test:

Provalo qui.

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

Produzione:

4
3
1
42

Racchetta 84 byte

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

Ungolfed:

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

test:

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

Produzione:

4
3
42

Clojure, 51 byte

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

SmileBASIC, 68 byte

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

Niente di speciale qui. Gli input sono X[]eN