Рассмотрим массив, xнапример, [1 5 3 4]и число n, например 2. Написать все длина- nраздвижного подмассива: [1 5], [5 3], [3 4]. Пусть минимакс массива определен как минимум максимумов скользящих блоков. Так что в этом случае это будет минимум 5, 5, 4, который есть 4.

Вызов

Учитывая массив xи положительное целое число n, выведите минимакс, как определено выше.

Массив xбудет содержать только положительные целые числа. nвсегда будет по крайней мере 1и самое большее длина x.

Вычисление может быть выполнено любой процедурой, не обязательно такой, как определено выше.

Код гольф, побеждает меньше байтов.

Контрольные примеры

x, n, Результат

[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

Дьялог АПЛ, 4 байта

⌊/⌈/

Это последовательность монадических функций, которая ожидает массив и целое число как правый и левый аргументы, соответственно.

Попробуйте это с TryAPL .

Как это устроено

Последовательность из двух функций является atop , это означает, что сначала вызывается правая (с обоими аргументами), а затем вызывается левая (с единственным аргументом в результате).

Монадика f/просто уменьшает свой аргумент на f. Однако, если вызывается двоично, f/n-мудрое уменьшение, и принимает размер среза в качестве левого аргумента.

⌊/⌈/    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 байт)

{ew::e>:e<}

Онлайн демо

Рубин 39 байт

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

Где x - это массив, а n - номер, по которому массив разбивается на части.

Pyth, 10 байт

hSmeSd.:QE

Объяснение:

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

Принимает вход в виде list newline int

Попробуй это здесь!

Или запустить тестовый пакет!

Или также 10 байтов

hSeCSR.:EE

Объяснение:

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

Тестовый пакет здесь

Oracle SQL 11.2, 261 байт

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 байтов

YCX>X<

Попробуйте онлайн!

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

Желе, 6 байт

ṡ»/€«/

Попробуйте онлайн!

Как это устроено

ṡ»/€«/  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 байта

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

Спасибо user81655 за помощь сбрить 11 байтов

Юлия, 51 байт

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

Ничего особенного. Это функция, которая принимает массив и целое число и возвращает целое число. Он просто использует основной алгоритм. Это было бы намного короче, если бы minи maxне требовало разбивать массивы на аргументы.

Мы получаем каждый перекрывающийся подмассив, берем максимум и берем минимум результата.

Perl 6 , 32 байта

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

Использование:

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 байт

Требуется зоопарк для установки.

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

редактировать - 6 байт, понимая, zoo::rollmaxсуществует!

J, 9 байт

[:<./>./\

Похоже на ответ APL. >./\применяет >./(максимум) к (левому аргументу) -подмножествам правого аргумента. Затем <./находит минимум этого, поскольку он ограничен [:.

Контрольные примеры

   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 байт.

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

Тестовые случаи:

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 байт

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

Рекурсивно вычисляет минимум двух вещей: максимум первых nзаписей и рекурсивную функцию в списке с удаленным первым элементом. Для базового случая списка, имеющего меньше nэлементов, выдается пустой список, который служит бесконечностью, поскольку Python 2 помещает списки как числа, превышающие числа.

JavaScript (ES6), 70 байт

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

Используя карри , эта функция сохраняет 2 байта из предыдущего ответа.

демонстрация

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 байта

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

Прецедент

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

Java 7, 128 126 124 байтов

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 & тестовый код:

Попробуй это здесь.

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

Выход:

4
3
1
42

Ракетка 84 байта

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

Тестирование:

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

Выход:

4
3
42

Clojure, 51 байт

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

SmileBASIC, 68 байт

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

Здесь нет ничего особенного. Входы X[]иN