स्थानीय मैक्सिमा निकालें

Question

सकारात्मक पूर्णांक की एक सरणी को देखते हुए, उन सभी तत्वों की एक सरणी का उत्पादन करें जो आसन्न वाले से अधिक या बराबर हैं। अधिकांश तत्वों में दो आसन्न तत्व होंगे; पहला और अंतिम तत्व विशेष मामले हैं, क्योंकि उनके पास केवल एक आसन्न तत्व है।

आप मान सकते हैं कि सरणी में कम से कम दो तत्व हैं।

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

Input               | Output
[4,2,6,12,4,5,4,3]  | [4,12,5]
[1,2]               | [2]
[1,2,3,2,1]         | [3]
[3,2,1,2,3]         | [3,3]
[4,4]               | [4,4]
[2,4,4,4,1]         | [4,4,4]
[2,3,3,4]           | [3,4]
[4,3,3,4]           | [4,4]

यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है!

Comments

@PeterTaylor मुझे लगता है कि इसका मतलब क्या है "आउटपुट में शामिल होने वाले पहले या आखिरी तत्व के लिए, ..."

— xnor

@PeterTaylor xnor सही है।

— पावेल

सम्बंधित

— पीटर टेलर

इसके अलावा संबंधित: स्थानीय चरम सीमाओं का पता लगाना

— Wrzlprmft

क्या मैं टेस्टकेस के [4,3,3,4]रूप में प्रस्तावित कर सकता हूं । मेरा समाधान नहीं हुआ कि बहुत दुख की बात है।

— JAD

Answer 1

जेली ,  13 12  11 बाइट्स

0;;0»3\f"⁸Ẏ

एक सकारात्मक लिंक की एक विवादास्पद लिंक लेने और फ़िल्टर की गई सूची को केवल उन लोगों को वापस करना जो उनके सभी पड़ोसियों से अधिक या बराबर हैं।

इसे ऑनलाइन आज़माएं!

---

पिछला 12 बटर :

0;INżI>0ḄNMị

पिछला 13 बटर :

0;;0ṡ3M€ċ€2Tị

---

कैसे?

0;;0»3\f"⁸Ẏ - Link: list of positive integers, A
0;          - a zero concatenated with A
  ;0        - concatenate a zero
     3\     - 3-wise reduce with:
    »       -   maximum (yields a list of the maximums in each overlapping window of 3)
         ⁸  - chain's left argument, A
        "   - zip with:
       f    -   filter keep (i.e. keep the maximal if it is [in] the [length 1 list 
            -                     of the] respective original element)
          Ẏ - flatten by one level

Comments

वैसे मुझे लगता है कि 3-वार कटौती का उपयोग करने का एक तरीका हो सकता है लेकिन मैंने इसे काम नहीं किया है।

— जोनाथन एलन

मैं सही था - अधिकतम रंजक के साथ एक 3-वार कम, »- हालांकि 10 के बारे में कैसे ..?

— जोनाथन एलन

Answer 2

पायथन , 54 बाइट्स

f=lambda l,*p:l and l[:p<=l[:1]>=l[1:2]]+f(l[1:],l[0])

इसे ऑनलाइन आज़माएं!

I / O सूचियों के बजाय टुपल्स के साथ है।

---

पायथन , 57 बाइट्स

f=lambda l,p=0:l and l[:[p]<=l[:1]>=l[1:2]]+f(l[1:],l[0])

इसे ऑनलाइन आज़माएं!

ऑल्ट 57:

f=lambda l,p=0:l and l[l<[max(p,*l[:2])]:1]+f(l[1:],l[0])

Answer 3

गणितज्ञ 22 बाइट्स

Pick[#,MaxDetect@#,1]&

Comments

संयोग से, यह उच्च आयाम सरणियों पर भी काम करेगा।

— केली लोल्डर

Answer 4

हास्केल, 50 49 42 बाइट्स

f l=[j|i:j:k:_<-scanr(:)[0]$0:l,k<=j,i<=j]

इसे ऑनलाइन आज़माएं!

scanr(:)[0]की पूंछ की एक सूची बनाता है (0:l), एक अंतिम के साथ प्रत्येक 0, उदाहरण के लिए l = [4,3,3,4]: [[0,4,3,3,4,0],[4,3,3,4,0],[3,3,4,0],[3,4,0],[4,0],[0]]जो पैटर्न का मिलान नहीं हुआ खिलाफ है i:j:k:_कम से कम 3 तत्व है जो नाम हैं साथ सभी सूचियों को निकालने के लिए i, jऔर k। रखो jअगर इसकी> = iऔर j।

संपादित करें: अर्जन जोहान्सन ने 7 बाइट्स बचाए। धन्यवाद!

Comments

i:j:k:_<-scanr(:)[0]$0:lछोटा है। ("मानक" tails=scanr(:)[]चाल को थोड़ा समायोजित करना ।)

— अर्जन जोहान्सन

@ UsedrjanJohansen: ओह, मैंने खुद से पहले उस ट्रिक का इस्तेमाल किया है, लेकिन किसी तरह यहां चूक हुई। आपका बहुत बहुत धन्यवाद!

— nimi

Answer 5

Dyalog APL, 31 30 28 22 21bytes

{⍵/⍨(⌈/=2⌷⊢)¨3,/∊0⍵0}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण (मैं चीजों को समझाने में अच्छा नहीं हूँ):

0⍵0       - [0,input,0]   (it looks like a face!)
∊         - flatten
3,/       - split into overlapping sections of length 3.
(⌈/=2⌷⊢)¨ - Whether the middle element is the maximum (applied to every section)
⍵/⍨       - index

Answer 6

हास्केल , 40 बाइट्स

p%(h:t)=[h|h>=p,[h+1]>t]++h%t
_%e=e
(0%)

इसे ऑनलाइन आज़माएं!

Answer 7

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

a=>a.filter((e,i)=>!(e<a[i-1]|e<a[i+1]))

Answer 8

पायथन 3 , 84 75 * 71 बाइट्स

lambda l,k=[0]:[j for x,j in enumerate(l)if(k+l+k)[x+2]<=j>=(k+l+k)[x]]

इसे ऑनलाइन आज़माएं!

---

* @ LeakyNun ने एक चतुर ऑपरेटर चाल का उपयोग करके 9 बाइट्स बचाए।

Comments

lambda l,k=[0]:[l[i]for i in range(len(l))if(k+l+k)[i+2]<=l[i]>=(k+l+k)[i]]

— लीकी नून

Answer 9

जेली , 15 बाइट्स

2ị⁼Ṁ
0;;0ṡ3Ç€Tị

इसे ऑनलाइन आज़माएं!

Answer 10

05AB1E , 15  14  13 बाइट्स

ü‹0¸«sĆÁü›+_Ï

इसे ऑनलाइन आज़माएं!

व्याख्या

ü‹             # pairwise comparison for less than
  0¸«          # append 0
     s         # swap input to top of stack
      Ć        # enclose, append the head of the list
       Á       # rotate right
        ü›     # pairwise comparison for greater than
          +    # add the two boolean lists
           _   # logical negate
            Ï  # keep only elements of input that are true in the resulting list

पिछले 15 बाइट समाधान

¬s¤)˜Œ3ùεZQ1è}Ï

इसे ऑनलाइन आज़माएं!

व्याख्या

¬                # get head of input
 s¤              # get tail of input
   )˜            # wrap stack in flattened list
                 # produces the input list with the first and last element duplicated
     Œ3ù         # push sublists of length 3
        ε        # apply transformation on each triple
         ZQ      # ... check each element for equality to the max
          1è     # ... get the middle element
            }    # end transform
             Ï   # keep only elements of input that are true in the resulting list

Answer 11

आर, 44 बाइट्स

pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])

जो फ़ंक्शन का मूल्यांकन करता है:

function (x) 
x[(x >= c(0, x) & x >= x[-1])[1:sum(x | 1)]]

की तुलना में xहै c(0,x), इसलिए xदाईं ओर एक स्थिति को स्थानांतरित कर दिया गया है। साथ ही तुलना xकरता है x[-1], इसलिए एक स्थिति बाईं ओर स्थानांतरित हो गई है। ये दोनों TRUEअगर वहाँ एक अधिकतम है। &और इन बूलियन्स के AND को लेने के लिए। आर के वैक्टर की रैपिंग प्रकृति के कारण जब वे समान लंबाई के नहीं होते हैं, तो हमें परिणाम को लंबाई में छोटा करना पड़ता है x, जिसे लेने से पता चलता है sum(x|1)। हम तब बूलियन वेक्टर में प्लग करते हैं, केवल उसी के वास्तविक सूचकांक लेते हैं xऔर वापस लौटते हैं।

ध्यान दें, क्योंकि ये तार्किक संचालन असमान लंबाई वाले वैक्टर के साथ किया जाता है, आर शिकायत करेगा। बहुत। लेकिन चेतावनी के बीच सही उत्पादन होगा:

> pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])(c(4,2,6,12,4,5,4,3))
[1]  4 12  5
Warning messages:
1: In x >= c(0, x) :
  longer object length is not a multiple of shorter object length
2: In x >= x[-1] :
  longer object length is not a multiple of shorter object length
3: In x >= c(0, x) & x >= x[-1] :
  longer object length is not a multiple of shorter object length

Answer 12

आर , 42 बाइट्स

function(x)x[c(d<-diff(x),0)<=0&c(0,d)>=0]

इसे ऑनलाइन आज़माएं!

2 बाइट्स JAD के घोल से कम । diffक्रमिक मतभेदों की गणना करता है; फिर दोनों पड़ोसियों की तुलना में केवल प्रविष्टियाँ रखें।

Answer 13

अजगर , 20 बाइट्स

-.b*YqYeSN.:++0Q03Q0

गोल्फ होने के लिए ...

परीक्षण सूट।

Answer 14

आर , 68 बाइट्स

function(a)a[a==sapply(1:length(a),function(i)max(c(0,a,0)[i+0:2]))]

इसे ऑनलाइन आज़माएं!

Comments

pryr::f(expression)की तुलना में एक समारोह घोषित करने के लिए एक छोटा तरीका है function(a)expression।

— JAD

इसके अलावा, sum(a|1)एक शॉर्टकट है length(a)।

— JAD

एक छोटे दृष्टिकोण के लिए मेरा समाधान देखें।

— JAD

Answer 15

PHP , 67 बाइट्स

for(;$g=$argv[+$i];$l=$g)$g<$l|$g<$argv[++$i]?:$r[]=$g;print_r($r);

इसे ऑनलाइन आज़माएं!

Answer 16

रेटिना , 51 बाइट्स

\d+
$*
^

M!`(?<=(^|1+) )(\1\d*)\b(?! 1\2)
^¶

%`1

इसे ऑनलाइन आज़माएं

Answer 17

क्यू, 39 बाइट्स

{x where x = -1 _ next 3 mmax x,last x}

Comments

मैंने पहले कभी इस भाषा के बारे में नहीं सुना है। क्या आप जानते हैं कि मैं कहीं भी इसे डाउनलोड या डाउनलोड कर सकता हूं?

— पावल

ज़रूर, kx.com , डॉक्स: code.kx.com

— स्कीव

Answer 18

स्टैक्स , 10 बाइट्स

úâH◄(☼bM•Å

इसे चलाएं और डीबग करें

यह आउटपुट आउटपुट पर न्यूलाइन अलग मूल्यों के रूप में उत्पादन करता है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

f       filter each value in input using the rest of the program; implicitly printing kept values
  x0|S  input pre- and post-pended with zero
  3B    split into batches of 3
  i@    get the i-th batch, where i is the iteration index
  |M=   is the current value equal to the max from the batch?

इसको चलाओ

अपडेट किया गया: बस एक 9-बाइट समाधान मिला। बाद में स्पष्टीकरण अपडेट करेंगे:

स्टैक्स , 9 बाइट्स

▀▓ûa¥╓╧↨⌐

इसे चलाएं और डीबग करें

Answer 19

पर्ल 5 -a , 37 बाइट्स

map{$_>=$F[++$i]&$_>=$p&&say;$p=$_}@F

इसे ऑनलाइन आज़माएं!