Bir dizi göz önünde xgibi [1 5 3 4]ve bir sayı n, örneğin 2. Tüm uzunluk- yaz nsürgülü Altdizilim: [1 5], [5 3], [3 4]. Dizinin minimaksının kayan blokların maksimumu olarak tanımlanmasına izin verin . Yani bu durumda, asgari 5, 5, 4, yani 4.

Meydan okuma

Bir dizi xve pozitif bir tamsayı verildiğinde n, yukarıda tanımlanan şekilde minimax çıktısını alın.

Dizi xyalnızca pozitif tamsayılar içerecektir. nher zaman en azından 1en fazla uzunluğu olacak x.

Hesaplama, yukarıda açıklandığı gibi olmayan herhangi bir prosedürle yapılabilir.

Kod golf, en az bayt kazanır.

Test senaryoları

x, n, Sonuç

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

⌊/⌈/

Dizi ve tamsayıyı sağ ve sol argümanlar olarak bekleyen monadik bir fonksiyon dizisidir.

TryAPL ile deneyin .

Nasıl çalışır

İki fonksiyonların Bir tren bir olduğunu tepesinde , ardından sol bir (tek argüman olarak sonuçla) bunun üzerine denir doğru bir (her iki argümanlarla) ilk olarak adlandırılır, yani.

Bir monadik f/argümanını basitçe azaltır f. Bununla birlikte, ikili olarak çağrılırsa, f/n-akıllıca azalır ve dilim boyutunu sol argümanı olarak alır.

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

{ew::e>:e<}

Çevrimiçi demo

Yakut 39 bayt

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

Burada x dizidir ve n diziyi yığınlayacak sayıdır.

Pyth, 10 bayt

hSmeSd.:QE

Açıklama:

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

Formda girdi alır list newline int

Burada deneyin!

Veya bir Test Paketi çalıştırın!

Ya da 10 bayt

hSeCSR.:EE

Açıklama:

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

Test Suite'i burada

Oracle SQL 11.2, 261 bayt

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 bayt

YCX>X<

Çevrimiçi deneyin!

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

Jöle, 6 bayt

ṡ»/€«/

Çevrimiçi deneyin!

Nasıl çalışır

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

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

11 baytın tıraş edilmesine yardımcı olduğu için user81655'e teşekkürler

Julia, 51 bayt

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

Çok çığır açan bir şey yok. Bu, bir diziyi ve bir tamsayıyı kabul eden ve bir tamsayı döndüren bir işlevdir. Sadece temel algoritmayı kullanır. Dizileri argümanlara atlatmayı gerektirmezse minve çok daha kısa olurdu max.

Üst üste binen her alt diziyi alırız, maksimumu alırız ve sonucun dakikasını alırız.

Perl 6 , 32 bayt

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

Kullanımı:

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 bayt

Hayvanat bahçesinin kurulmasını gerektirir.

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

edit - 6 bayt gerçekleştirerek zoo::rollmaxvar!

J, 9 bayt

[:<./>./\

APL yanıtına benzer. sağ argümanın (sol arg) alt kümelerine (maksimum) >./\uygulanır >./. Sonra, <./en azını bulur, çünkü sınırlıdır [:.

Test senaryoları

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

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

Test senaryoları:

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 bayt

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

En az iki şeyi özyinelemeli olarak hesaplar: ilk ngirdilerin maksimumu ve listedeki ilk öğenin kaldırıldığı özyinelemeli işlev. Listeden daha az nelemanı olan bir temel durum için, Python 2 listeleri sayıdan daha büyük koyduğu için sonsuzluk görevi gören boş listeyi verir.

JavaScript (ES6), 70 bayt

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

Körelme kullanarak , bu işlev önceki yanıttan 2 bayt kaydeder.

gösteri

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 bayt

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

Test durumu

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

Java 7, 128 126 124 bayt

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

Test edilmemiş ve test kodu:

Burada deneyin.

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

Çıktı:

4
3
1
42

Raket 84 bayt

(λ(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 yapmak:

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

Çıktı:

4
3
42

Clojure, 51 bayt

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

SmileBASIC, 68 bayt

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

Burada özel bir şey yok. Girişler X[]veN