Rozważyć szereg xtakich jak [1 5 3 4]i numer n, na przykład 2. Napisz wszystkie wzdłużnych nsubarrays przesuwne: [1 5], [5 3], [3 4]. Niech minimax tablicy zostanie zdefiniowany jako minimum maksimów przesuwnych bloków. Więc w tym przypadku byłoby to minimum 5, 5, 4, które jest 4.

Wyzwanie

Biorąc pod uwagę tablicę xi dodatnią liczbę całkowitą n, wyślij minimax jak zdefiniowano powyżej.

Tablica xbędzie zawierać tylko dodatnie liczby całkowite. nzawsze będzie co najmniej 1i co najwyżej długość x.

Obliczenia można wykonać za pomocą dowolnej procedury, niekoniecznie jak zdefiniowano powyżej.

Code golf, najmniej bajtów wygrywa.

Przypadki testowe

x, nwynik

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

⌊/⌈/

Jest to monadyczny ciąg funkcji, który oczekuje tablicy i liczby całkowitej jako argumentów prawej i lewej, odpowiednio.

Wypróbuj z TryAPL .

Jak to działa

Ciąg dwóch funkcji jest na szczycie , co oznacza, że ​​prawy jest wywoływany jako pierwszy (z dwoma argumentami), a następnie lewy jest wywoływany nad nim (z wynikiem jako jedynym argumentem).

Monadic f/po prostu zmniejsza swój argument o f. Jednak jeśli wywoływany jest on w sposób stopniowy, f/jest n-mądry i przyjmuje rozmiar plastra jako lewy argument.

⌊/⌈/    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 bajtów)

{ew::e>:e<}

Demo online

Ruby 39 bajtów

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

Gdzie x to tablica, a n to liczba, z której porcja jest dzielona.

Pyth, 10 bajtów

hSmeSd.:QE

Wyjaśnienie:

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

Pobiera dane wejściowe w formularzu list newline int

Wypróbuj tutaj!

Lub uruchom pakiet testowy!

Lub też 10 bajtów

hSeCSR.:EE

Wyjaśnienie:

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

Pakiet testowy tutaj

Oracle SQL 11.2, 261 bajtów

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;

Nie grał w golfa

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 bajtów

YCX>X<

Wypróbuj 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

Galaretka, 6 bajtów

ṡ»/€«/

Wypróbuj online!

Jak to działa

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

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

Dziękujemy użytkownikowi 81655 za pomoc w goleniu 11 bajtów

Julia, 51 bajtów

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

Nic przełomowego. Jest to funkcja, która akceptuje tablicę i liczbę całkowitą i zwraca liczbę całkowitą. Po prostu używa podstawowego algorytmu. Byłoby o wiele krótszy, jeśli mini maxnie wymagają tablic splatting język argumentów.

Otrzymujemy każdą nakładającą się podstronę, bierzemy maksimum i bierzemy min. Wyniku.

Perl 6 , 32 bajty

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

Stosowanie:

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 bajtów

Wymaga zainstalowania zoo.

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

edytuj - 6 bajtów przez uświadomienie sobie zoo::rollmaxistnieje!

J, 9 bajtów

[:<./>./\

Podobne do odpowiedzi APL. >./\stosuje >./(maksymalnie) podzbiory (lewy arg) prawego arg. Następnie <./znajduje minimum tego, ponieważ jest ograniczone [:.

Przypadki testowe

   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 bajtów.

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

Przypadki testowe:

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 bajtów

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

Rekurencyjnie oblicza minimum dwie rzeczy: maksimum pierwszych nwpisów i funkcję rekurencyjną na liście z usuniętym pierwszym elementem. Dla podstawowego przypadku listy zawierającej mniej niż nelementy podaje pustą listę, która służy jako nieskończoność, ponieważ Python 2 umieszcza listy jako większe niż liczby.

JavaScript (ES6), 70 bajtów

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

Używając curry , funkcja ta oszczędza 2 bajty od poprzedniej odpowiedzi.

Próbny

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 bajty

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

Przypadek testowy

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

Java 7, 128 126 124 bajtów

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

Kod niepoznany i testowy:

Wypróbuj tutaj.

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

Wynik:

4
3
1
42

Rakieta 84 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wynik:

4
3
42

Clojure, 51 bajtów

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

SmileBASIC, 68 bajtów

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

Nic specjalnego. Wejściami są X[]iN