Betrachten wir eine Anordnung , xwie beispielsweise [1 5 3 4]und eine Anzahl n, beispielsweise 2. Schreiben Sie alle längs- nSchiebe Subarrays: [1 5], [5 3], [3 4]. Die Minimax des Arrays sei definiert als das Minimum der Maxima der Gleitblöcke. Also in diesem Fall wäre es das Minimum von 5, 5, 4, was ist 4.

Herausforderung

Geben Sie bei einem Array xund einer positiven Ganzzahl ndie oben definierte Minimax aus.

Das Array xenthält nur positive ganze Zahlen. nwird immer mindestens 1und höchstens die Länge von x.

Die Berechnung kann durch ein beliebiges Verfahren erfolgen, das nicht unbedingt wie oben definiert ist.

Code Golf, gewinnt die wenigsten Bytes.

Testfälle

x, nErgeben sich

[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

⌊/⌈/

Dies ist ein monadischer Funktionszug, der Array und Integer als rechtes bzw. linkes Argument erwartet.

Probieren Sie es mit TryAPL .

Wie es funktioniert

Ein Zug von zwei Funktionen ist eine Spitze , was bedeutet, dass die rechte zuerst (mit beiden Argumenten) und die linke darüber (mit dem Ergebnis als alleinigem Argument) aufgerufen wird.

Eine Monade f/reduziert einfach ihre Argumentation um f. Wenn es jedoch dyadisch aufgerufen wird, f/wird es n- fach reduziert und die Slice-Größe als linkes Argument verwendet.

⌊/⌈/    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<}

Online-Demo

Ruby 39 Bytes

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

Dabei ist x das Array und n die Zahl, nach der das Array aufgeteilt werden soll.

Pyth, 10 Bytes

hSmeSd.:QE

Erläuterung:

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

Nimmt Eingaben in das Formular auf list newline int

Probieren Sie es hier aus!

Oder führen Sie eine Testsuite aus!

Oder auch 10 Bytes

hSeCSR.:EE

Erläuterung:

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

Test Suite hier

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;

Nicht golfen

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<

Probieren Sie es 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

Gelee, 6 Bytes

ṡ»/€«/

Probieren Sie es online!

Wie es funktioniert

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

Vielen Dank an user81655 für die Hilfe bei der Reduzierung von 11 Bytes

Julia, 51 Bytes

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

Nichts zu bahnbrechend. Dies ist eine Funktion, die ein Array und eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt. Es wird nur der grundlegende Algorithmus verwendet. Es wäre viel kürzer, wenn minundmax nicht splatting Arrays in Argumente erforderlich ist.

Wir erhalten jedes überlappende Subarray, nehmen das Maximum und das Minimum des Ergebnisses.

Perl 6 , 32 Bytes

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

Verwendung:

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

Erfordert die Installation des Zoos.

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

bearbeiten - 6 Bytes durch Realisieren zoo::rollmaxvorhanden!

J 9 Bytes

[:<./>./\

Ähnlich wie bei der APL-Antwort. >./\gilt >./(maximal) für die (left arg) -Untergruppen des rechten Arg. Dann <./findet man das Minimum davon, da es mit einer Kappe versehen ist[: .

Testfälle

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

Testfälle:

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

Berechnet rekursiv das Minimum von zwei Dingen: das Maximum der ersten nEinträge und die rekursive Funktion in der Liste, bei der das erste Element entfernt wurde. Gibt für einen Basisfall der Liste mit weniger als nElementen die leere Liste an, die als unendlich dient, da Python 2 Listen als größer als Zahlen einfügt.

JavaScript (ES6), 70 Byte

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

Bei Verwendung von currying werden mit dieser Funktion 2 Bytes der vorherigen Antwort eingespart.

Demo

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

Testfall

%[{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 & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

4
3
1
42

Schläger 84 Bytes

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

Testen:

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

Ausgabe:

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

Nichts besonderes hier. Eingänge sind X[]undN