किसी सरणी का न्यूनतम न्यूनतम गणना करें

Question

एक सरणी पर विचार करें xजैसे [1 5 3 4]और एक नंबर n, उदाहरण के लिए 2। सभी length- लिखें nरपट subarrays: [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

Answer 1

Dyalog एपीएल, 4 बाइट्स

⌊/⌈/

यह एक मोनैडिक फ़ंक्शन ट्रेन है जो सरणी और पूर्णांक को दाएं और बाएं तर्क, सम्मान की अपेक्षा करती है।

इसे TryAPL के साथ आज़माएँ ।

यह काम किस प्रकार करता है

दो कार्यों की एक ट्रेन एक शीर्ष है , जिसका अर्थ है कि सही एक को पहले (दोनों तर्कों के साथ) कहा जाता है, फिर बाएं वाले को इसके ऊपर (एकमात्र तर्क के रूप में परिणाम के साथ) कहा जाता है।

एक राक्षसी 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.

Comments

रुकिए ... आप पहले से कम हो चुकी चीज़ को कैसे कम करते हैं? क्या यह सिर्फ एक विलक्षण तत्व नहीं है?

— Cycece

@Cyoce एन-वार कम करने से अधिकतम की एक सरणी मिलती है। उदाहरण के लिए 2 ⌈/ 1 2 3 4, अधिकतम की गणना करता है (1 2) (2 3) (3 4), इसलिए यह वापस आ जाता है 2 3 4।

— डेनिस

ठीक है। मुझे लगा कि इसका मतलब है कि एक एन-वार कम ने पहले एन तत्वों को लिया और उन्हें फ़ंक्शन के साथ कम किया, उदाहरण के लिए 2-वार कम करना एक सामान्य कमी है

— Cyoce

कितने बाइट्स के ⌊रूप में गिना जाना चाहिए ? 1 या 2?

— njpipeorgan

@njpipeorgan एन्कोडिंग पर निर्भर करता है। एपीएल अपनी ही विरासत कोड पेज (जो कई दशकों से यूनिकोड पहले का है) है, और यह encodes ⌊और ⌈एक एकल बाइट प्रत्येक के रूप में।

— डेनिस

Answer 2

CJam (11 बाइट्स)

{ew::e>:e<}

ऑनलाइन डेमो

Comments

एक पूर्ण कार्यक्रम होगा q~ew::e>:e<, जो 11 बाइट्स भी है

— GamrCorps

Answer 3

रूबी 39 बाइट्स

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

जहां x सरणी है और n द्वारा सरणी को chunk करने के लिए संख्या है।

Comments

क्या आपका मतलब नहीं है each_cons?

— नहीं कि चार्ल्स

Answer 4

अजगर, 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]

यहां टेस्ट सूट

Answer 5

ओरेकल 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;

संयुक्त राष्ट्र के 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;

Answer 6

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

Answer 7

जेली, 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.

Answer 8

जावास्क्रिप्ट (ईएस 6), 84 83 72 बाइट्स

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

11 बाइट्स से दाढ़ी बनाने में मदद करने के लिए user81655 का धन्यवाद

Comments

सभी सकारात्मक होने के नाते:(x,y,M=Math.max)=>-M(...x.slice(y-1).map((a,i)=>-M(...x.slice(i,i+y))))

— edc65

Answer 9

जूलिया, 51 बाइट्स

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

कुछ भी नहीं भयानक। यह एक फ़ंक्शन है जो एक सरणी और पूर्णांक को स्वीकार करता है और एक पूर्णांक देता है। यह सिर्फ बुनियादी एल्गोरिथ्म का उपयोग करता है। यह एक बहुत छोटा होगा अगर minऔर maxतर्क में splatting सरणियों की आवश्यकता नहीं थी।

हम प्रत्येक ओवरलैपिंग सबर्रे प्राप्त करते हैं, अधिकतम लेते हैं, और परिणाम का मिनट लेते हैं।

Answer 10

पर्ल 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

Answer 11

आर, 41 35 बाइट्स

चिड़ियाघर स्थापित करने की आवश्यकता है।

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

संपादित करें - एहसास zoo::rollmaxहोने से 6 बाइट्स मौजूद हैं!

Answer 12

जे, 9 बाइट्स

[:<./>./\

एपीएल जवाब के समान। (बाएँ arg) >./\पर लागू होता है >./(बाएं arg)-दाएँ arg की सदस्यता। फिर, <./इसका न्यूनतम पता लगाता है, क्योंकि यह छाया हुआ है[: ।

परीक्षण के मामलों

   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

Answer 13

पायथन 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

Answer 14

अजगर 2, 50 बाइट्स

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

पुनरावर्ती रूप से दो चीजों की न्यूनतम गणना करता है: पहली nप्रविष्टियों की अधिकतम , और पहले तत्व को हटाकर सूची पर पुनरावर्ती कार्य करता है। nतत्वों की तुलना में कम होने की सूची के आधार मामले के लिए , खाली सूची देता है, जो अनंत के रूप में कार्य करता है क्योंकि पायथन 2 संख्या से अधिक के रूप में सूचियां डालता है।

Answer 15

जावास्क्रिप्ट (ईएस 6), 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`}`)

Answer 16

गणितज्ञ, २३ बाइट्स

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

परीक्षण का मामला

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

Answer 17

जावा 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

Answer 18

रैकेट 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

Answer 19

क्लोजर, 51 बाइट्स

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

Answer 20

स्माइलबासिक, 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