क्या कोई टक्कर है?

Question

सकारात्मक पूर्णांकों की सूची को देखते हुए निर्धारित करें कि क्या कोई ऐसा तत्व है जो या तो उसके दो पड़ोसियों से अधिक है या उसके दो पड़ोसियों (एक "टक्कर") से कम है। स्पष्ट होने के लिए सूची का पहला या अंतिम आइटम कभी नहीं हो सकता क्योंकि उनके पास केवल एक पड़ोसी है।

आपके कार्यक्रम को दो संगत मूल्यों में से एक का उत्पादन करना चाहिए, जिसमें या तो कोई सूची न हो या धक्कों वाली सूची न हो। मूल्य क्या हैं महत्वहीन हैं आप उन्हें स्वयं चुन सकते हैं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

[] -> False
[1] -> False
[1,2] -> False
[1,2,1] -> True
[1,2,2] -> False
[1,2,3] -> False
[1,2,2,1] -> False
[1,2,2,3] -> False
[1,2,1,2] -> True
[1,3,2] -> True
[3,1,2] -> True
[2,2,2] -> False

Comments

टेस्ट केस रिक्वेस्ट: 0-1-2-3 के अलावा अन्य नंबरों को भी अनुमति नहीं / अस्वीकृत?

— मैजिक ऑक्टोपस Urn

सुझाया गया परीक्षण मामला: [1,3,3](यह सुनिश्चित करता है कि डेनिस के एल्गोरिथ्म का उपयोग करने वाले उत्तर केवल वेतन वृद्धि का उपयोग करने के बजाय वेतन वृद्धि का संकेत लेते हैं)

— ETHproductions

@ETHproductions पहले से कवर नहीं है [1,2,2]? या क्या मैं कुछ न कुछ भूल रहा हूं?

— निक हार्टले

@ नीचार्टली, डेल्टास उन डेल्टास [1,2,2]के संकेतों के समान हैं लेकिन ऐसा नहीं है [1,3,3]।

— झबरा

Answer 1

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

IṠIỊẠ

रिटर्न 0 एक टक्कर, हो, तो 1 नहीं तो।

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

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

IṠIỊẠ  Main link. Argument: A (integer array)

I      Increments; take all forward differences of A.
 Ṡ     Take the signs.
       The signs indicate whether the array is increasing (1), decreasing (-1), or
       constant at the corresponding point. A 1 followed by a -1 indicates a local
       maximum, a -1 followed by a 1 a local minimum.
  I    Increments; take the forward differences again.
       Note that 1 - (-1) = 2 and (-1) - 1 = -2. All other seven combinations of
       signs map to -1, 0, or 1.
   Ị   Insignificant; map each difference d to (-1 ≤ d ≤ 1).
    Ạ  All; return 1 if all differences are insignificant, 0 if not.

Comments

"वृद्धि" क्या है? क्या बढ़ रहा है और वह क्या करता है?

— गेहूं जादूगर

@WheatWizard मुझे लगता है कि यह 05AB1E के डेल्टास (¥) कमांड के बराबर है: एक सरणी [n0, n1, n2, n3] पोप है और सरणी [n1-n0, n2-n1, n3-n2] को धकेल दिया गया है।

— कालडो

Answer 2

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

एक बूलियन देता है।

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

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

let f =

a=>a.some(x=n=>x*(x=a<n|-(a>(a=n)))<0)

console.log(f([]))              // False
console.log(f([1]))             // False
console.log(f([1,2]))           // False
console.log(f([1,2,1]))         // True
console.log(f([1,2,2]))         // False
console.log(f([1,2,3]))         // False
console.log(f([1,2,2,1]))       // False
console.log(f([1,2,2,3]))       // False
console.log(f([1,2,1,2]))       // True
console.log(f([1,3,2]))         // True
console.log(f([2,0,1]))         // True
console.log(f([2,2,2]))         // False
console.log(f([-4,100000,89]))  // True

कैसे?

हम n का पिछला मान संग्रहीत करने के लिए a का उपयोग करते हैं । हम x को 1 में सेट करते हैं अगर <n , -1 अगर a> n या 0 अगर a = n । और हम परीक्षण करते हैं कि क्या old_x * x <0 , जो केवल तभी संभव है यदि ( old_x = 1 और x = -1 ) या ( old_x = -1 और x = 1 )।

क्योंकि x को कुछ के अनाम कॉलबैक फ़ंक्शन के लिए आरंभिक किया गया है () , इसे पहले पुनरावृत्ति के दौरान NaN के लिए बाध्य किया गया है , जो परीक्षण को गलत बनाता है।

Comments

यह सख्त मोड में फेंक देगा।

— अलुआन हदाद

@ अलुआनादाद खैर, जेएस गोल्फ कोड का 99% अघोषित चरों के कारण सख्त मोड में फेंक देगा। PPCG और कोडरेव अच्छी तरह से मिश्रण नहीं करता है। : पी

— अरनुलद

यह उचित है, मैं वास्तव में गोल्फ के लिए ज्यादा नहीं हूं।

— अलुआन हदाद

फिर उस पर टिप्पणी क्यों करें

— मार्क सी।

Answer 3

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

any(<0).f(*).f(-)
f a b=zipWith a b$tail b

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

व्याख्या

पहले हमारे पास फ़ंक्शन होता है fजो एक बाइनरी फ़ंक्शन और एक सूची लेता है और सूची में प्रत्येक आसन्न जोड़ी के लिए बाइनरी फ़ंक्शन को लागू करता है।

तब हमारा मुख्य कार्य f(-)इनपुट सूची पर लागू होता है। यह अंतर सूची की गणना करता है। हम फिर f(*)सूची में हर निकटवर्ती जोड़ी को गुणा करने के लिए लागू होते हैं । अंत में हम पूछते हैं कि क्या कोई जोड़ी शून्य से कम है।

अंत सूची में एक संख्या केवल नकारात्मक हो सकती है यदि यह अंतर सूची से नकारात्मक और सकारात्मक संख्या का उत्पाद है। इस प्रकार एक नकारात्मक प्रविष्टि का उत्पादन करने के लिए (और फिर सच लौटना) मूल सूची को घटने या इसके विपरीत बढ़ने से स्विच करना चाहिए, यही है कि इसमें एक टक्कर होनी चाहिए।

Comments

खाली सूची से निपटने का अच्छा तरीका!

— लकोनी

Answer 4

पायथन 2 , 43 बाइट्स

f=lambda x,y,z,*t:0>(y-x)*(z-y)or f(y,z,*t)

रिटर्न यह सच है एक टक्कर नहीं है, त्रुटियों अगर वहाँ नहीं है अगर। ( डिफ़ॉल्ट रूप से अनुमत )

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

Answer 5

छवि पैकेज के साथ ऑक्टेव , 34 32 बाइट्स

2 बाइट्स ने @StewieGriffin को धन्यवाद दिया !

@(x)0||prod(im2col(diff(x),2))<0

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

व्याख्या

लगातार अंतर की गणना करता है, उन्हें लंबाई 2 के फिसलने वाले ब्लॉकों में व्यवस्थित करता है, प्रत्येक ब्लॉक के उत्पाद को प्राप्त करता है, और यदि ऐसा कोई उत्पाद नकारात्मक है तो परीक्षण करता है।

Comments

0||prod(...)2 बाइट्स बचाता है। आप पूरे anyभाग को छोड़ सकते हैं , और 5 बाइट्स को बचाने के लिए डिफ़ॉल्ट सत्य / मिथ्या परिभाषा का उपयोग कर सकते हैं ।

— स्टीवी ग्रिफिन

डारन, 5 बाइट्स बचाने से आपका समाधान मेरे से कम हो जाएगा :( छवि पैकेज का अच्छा उपयोग। मुझे नहीं पता था कि यह टीआईओ पर है।

— स्टिव ग्रिफिन

@StewieGriffin चूंकि चुनौती के लिए दो संगत मूल्यों की आवश्यकता होती है, जिन्हें मैं नहीं हटा सकता any। 0||विचार के लिए धन्यवाद !

— लुइस मेंडो

Answer 6

आर, 48 बाइट्स

function(x)any(apply(embed(diff(x),2),1,prod)<0)

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

उदाहरण के लिए c (1,4,1,4) का उपयोग करके यह चरण-दर-चरण कैसे काम करता है:

> x=c(1,4,1,4)
> diff(x)
[1]  3 -3  3
> embed(diff(x),2)
     [,1] [,2]
[1,]   -3    3
[2,]    3   -3
> apply(embed(diff(x),2),1,prod)
[1] -9 -9
> any(apply(embed(diff(x),2),1,prod)<0)
[1] TRUE

एक बोनस के रूप में, यहां पैकेज का उपयोग करके समान लंबाई और अवधारणा का एक समाधान है zoo:

function(x)any(zoo::rollapply(diff(x),2,prod)<0)

Comments

साफ! स्वयं पर ध्यान दें: याद रखना embedमौजूद है। यह बहुत बुरा है कि rowProdsऔर colProdsउपनाम के रूप में मौजूद नहीं है।

— Giuseppe

@Giuseppe हताशा से बाहर वास्तव में जाँच की कि क्या वे मौजूद हैं :) लेकिन वास्तव में बस rowSumsऔर rowMeans...

— plannapus

अच्छी तरह से, कम से कम डॉक्स के माध्यम से देख रहे हैं, .colSumsअतिरिक्त इनपुट के आधार पर एक मैट्रिक्स में इनपुट को फिर से खोलेगा, जिसमें संभवतः कहीं एक गोल्फ अनुप्रयोग है .... अब मुझे बस एक ढूंढना है!

— ग्यूसेप

@ गिसेप: matrixStatsपैकेज में कार्यों पर एक नज़र है ।

— माइकल एम

@MichaelM दुर्भाग्य से पैकेज नाम की लंबाई के कारण यह इसे प्रतिस्पर्धी नहीं बनाता (57 बाइट्स:) function(x)any(matrixStats::colProds(embed(diff(x),2)))<0। लेकिन कोड गोल्फ के अलावा किसी भी चीज़ के लिए, यह पैकेज वास्तव में एक खजाना है।

— प्लेनैपस

Answer 7

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

f(p:r@(c:n:_))=(c-p)*(c-n)>0||f r

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

True अगर वहाँ एक टक्कर है, त्रुटियों अगर वहाँ नहीं है।

Comments

l`zip3`tail l$drop 2lसिर्फ एक बाल छोटा है मुझे आश्चर्य है कि क्या पैटर्न मिलान किसी भी तरह कम है?

— लिन

Answer 8

पर्ल 6 , 39 बाइट्स

{so~(.[1..*]Zcmp$_)~~/'re L'|'s M'/}

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

$_इस अनाम फ़ंक्शन का सूची तर्क है। .[1..*]एक ही सूची है, लेकिन पहला तत्व गिरा दिया गया है। ऑपरेटर के Zcmpसाथ दो सूचियों को जोड़ देता है cmp, जिसके परिणामस्वरूप Orderमूल्यों की एक सूची होती है। उदाहरण के लिए, इनपुट सूची के लिए 1, 2, 2, 2, 1इस सूची में परिणाम होगा More, Same, Same, Less।

अब हमें बस यह जानना चाहिए कि उस सूची में दो आसन्न तत्व हैं More, Lessया नहीं Less, More। मैंने जिस ट्रिक का उपयोग किया है, वह सूची को स्पेस-सीमांकित स्ट्रिंग के साथ परिवर्तित करना है ~, फिर परीक्षण करें कि इसमें या तो सबस्ट्रिंग है re Lया नहीं s M। (पहला व्यक्ति सिर्फ e Lइसलिए नहीं हो सकता क्योंकि Sameवह "ई" के साथ समाप्त होता है।)

स्मार्ट मैच ऑपरेटर या तो एक Matchवस्तु (यदि मैच सफल हुआ) या Nil(यदि ऐसा नहीं हुआ) लौटाता है , तो soजो कुछ भी यह एक बूलियन मान में परिवर्तित होता है।

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 40 बाइट्स

MatchQ[{___,x_,y_,z_,___}/;x<y>z||x>y<z]

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

Answer 10

रूबी , 55 46 बाइट्स

->a{a.each_cons(3).any?{|x,y,z|(y-x)*(y-z)>0}}

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

एक मेमना एक सरणी को स्वीकार करता है और बूलियन लौटता है।

-9 बाइट्स: बदलें (x<y&&y>z)||(x>y&&y<z)साथ (y-x)*(y-z)>0(धन्यवाद करने के लिए GolfWolf )

->a{
  a.each_cons(3)              # Take each consecutive triplet
    .any?{ |x,y,z|            # Destructure to x, y, z
      (y-x)*(y-z) > 0         # Check if y is a bump
    }
}

Comments

मुझे लगता है कि आप |इसके बजाय उपयोग कर सकते हैं ||, जिससे आप 1 बाइट बचा सकते हैं।

— यति

46 बाइट्स

— क्रिस्टियन लुपस्कू

1 बाइट को '0 <(yx) * y- = z'

— GB

Answer 11

PostgreSQL 173 बाइट्स

SELECT DISTINCT ON(a)a,x>j and x>k OR x<least(j,k)FROM(SELECT a,x,lag(x,1,x)OVER(w)j,lead(x,1,x)OVER(w)k FROM d WINDOW w AS(PARTITION BY rn ORDER BY xn))d ORDER BY 1,2 DESC;
     a     | c 
-----------+---
 {1}       | f
 {1,2}     | f
 {1,2,1}   | t
 {1,2,1,2} | t
 {1,2,2}   | f
 {1,2,2,1} | f
 {1,2,2,3} | f
 {1,2,3}   | f
 {1,3,2}   | t
 {2,2,2}   | f
 {3,1,2}   | t
(11 rows)

Comments

नमस्कार और साइट पर आपका स्वागत है। मैं PostgreSQL से परिचित नहीं हूं, लेकिन आप अपने द्वारा उपयोग किए जाने वाले व्हाट्सएप की मात्रा को कम करने में सक्षम हो सकते हैं। सामान्य तौर पर अधिकांश भाषाओं में आपके द्वारा उपयोग किए जाने वाले रिक्ति के अधिकांश प्रकार की आवश्यकता नहीं होती है।

— गेहूं जादूगर

@WheatWizard यह डेटाबेस में नमूना डेटा है, यह अप्रासंगिक है।

— इवान कैरोल

फिर आपका कोड क्या है? हम इनपुट के बजाय इनपुट को सीधे कोड में डालने की अनुमति नहीं देते हैं। यदि ऐसा है तो यहां आपको इसे फिर से लिखना चाहिए ताकि यह एक मानक विधि के माध्यम से इनपुट ले सके ।

— गेहूं जादूगर

आपके द्वारा दिए गए लिंक से @WheatWizard, codegolf.meta.stackexchange.com/a/5341/23085

— इवान कैरोल

ठीक है अगर वह इनपुट प्रारूप आप उपयोग कर रहे हैं तो वह ठीक है। सौभाग्य से यहां गोल्फिंग करना, लोगों को कम इस्तेमाल की जाने वाली भाषाओं में गोल्फ देखना अच्छा लगता है।

— गेहूं जादूगर

Answer 12

जावा 8, 108 104 101 86 84 79 72 बाइट्स

a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

-2 बाइट्स @ OlivierGrégoire की बदौलत ।
-13 बाइट्स @Nevay को धन्यवाद ।

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

Comments

84 बाइट्स । मैंने पुनरावृति क्रम को बदल दिया (नीचे जा रहा है), दो गुणन ऑपरेंडों को अदला-बदली किया और फिर एक शानदार को निकाल सकता है -1।

— ओलिवियर ग्रेजायर

79 बाइट्स: a->{int i=a.length;for(;i-->2;)i|=(a[i]-a[--i])*(a[i]-a[i-1])>>-1;return-~i|3;}( सत्य मामलों के लिए रिटर्न -1, 3फाल्सी मामलों के लिए) - या, अगर रिटर्न मूल्य 55 बाइट्स के रूप में एक अपवाद की उपस्थिति / अनुपस्थिति का उपयोग कर रहा है:a->{for(int i=0;++i>0;)i|=(a[i-1]-a[i])*(a[i]-a[i+1]);}

— नेवय

72 बाइट्स:a->{int i=a.length,p=0;for(;i-->1;)i|=p*(p=a[i]-a[i-1])>>-1;return-i>1;}

— नेवई

Answer 13

आर , 58 56 बाइट्स

function(x)any(abs(diff(sign(diff(c(NA,x)))))>1,na.rm=T)

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

सहेजे गए 2 बाइट्स Giuseppe की बदौलत

Comments

आप {}-2 बाइट्स के लिए ब्रेसिज़ से छुटकारा पा सकते हैं ।

— ग्यूसेप

इसके अलावा, मुझे लगता है कि आप 42 बाइट्स के लिए स्टेवी ग्रिफिन के दृष्टिकोण को पोर्ट कर सकते हैं

— Giuseppe

@Giuseppe, मुझे लगता है कि स्टिवे ने मेरे तरीके को चित्रित किया, इस अंतर के साथ कि मेरा खाली वेक्टर को ठीक से परीक्षण के मामलों में सूचीबद्ध किया जा सकता है।

— मतलाब

c()है NULLजो पूर्णांकों का खाली वेक्टर के रूप में ही नहीं है, integer(0), MATLAB में जबकि []एक है double, डिफ़ॉल्ट रूप से, लेकिन आप इसे इस तरह रखना चाहते हैं, जो पूरी तरह से उचित है।

— ग्यूसेप

Answer 14

जे , 16 15 बाइट्स

-1 बाइट फ्रोवेफ्रॉग के लिए धन्यवाद

1 e.0>2*/\2-/\]

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

मूल: 16 बाइट्स

0>[:<./2*/\2-/\]

2-/\] - प्रत्येक आसन्न वस्तुओं के अंतर

2*/\ - प्रत्येक आसन्न वस्तुओं के उत्पाद

[:<./ - न्यूनतम

0> - नकारात्मक है?

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

Comments

हैलो ! क्या इसे इस सरल स्पष्ट रूप से छोटा नहीं किया जा सकता है 0> </। 2 * / \ 2 - / \ (13 बाइट्स)?

— मथियास डॉलीडन

@ मैथियास डोलिडोन दुभाषिया में काम करता है लेकिन पीपीसीजी में यहां कुछ इनपुट होने पर फ़ंक्शन (जे क्रिया) प्रदान करना आम है। यदि क्रिया tacit एक है, तो हम असाइनमेंट f=.बाइट्स की गणना नहीं करते हैं । कृपया ध्यान रखें कि मैं अपेक्षाकृत नया उपयोगकर्ता हूं :)

— गैलेन इवानोव

तो मैं हूं, और आपने मेरे लिए नियम स्पष्ट कर दिया है। धन्यवाद ! :)

— मैथियास डॉलीडन

1 e.0>2*/\2-/\]

— फ्रॉन्फ्रोग में

@ FrownyFrog धन्यवाद! ऐसा लगता है कि मैं शायद ही कभी ई का उपयोग करता हूं। :)

— गैलन इवानोव

Answer 15

जाप , 11 बाइट्स

-5 बाइट्स @ETHproductions के लिए धन्यवाद

ä- mÌäa d>1

इसे ऑनलाइन आज़माएं! | परीक्षण के मामलों

यह डेनिस के एल्गोरिथ्म का उपयोग करता है

Answer 16

जाप , 9 बाइट्स

ä- ä* d<0

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

ओलिवर के जवाब का एक मैशअप कई अन्य उत्तरों द्वारा उपयोग किए गए दृष्टिकोण के साथ।

Answer 17

अटैची , 39 बाइट्स

Any&:&{_*~?Sum[__]}@Slices&2@Sign@Delta

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

बहुत खुश है कि यह कैसे निकला।

व्याख्या

यह चार कार्यों की एक रचना है:

Delta
Sign
Slices&2
Any&:&{_*~?Sum[__]}

Deltaतत्वों के बीच अंतर पाता है। =

फिर, Signप्रत्येक अंतर पर लागू होता है, जिससे हमें 1एस, 0एस और -1एस की एक सरणी मिलती है । =

फिर, Slices&2सभी जोड़े को अंतर देते हुए, सरणी से लंबाई के दो स्लाइस देते हैं।

अंत में, Any&:&{_*~?Sum[__]}इनपुट के लिए बराबर है x:

Any[&{_*~?Sum[__]}, x]
Any[[el] -> { el[0] and not (el[0] + el[1] = 0) }, x]

यह उन तत्वों की खोज करता है जो शून्य के योग हैं लेकिन शून्य नहीं हैं। यदि इस तरह के तत्वों की कोई जोड़ी मौजूद है, तो एक टक्कर है।

Answer 18

MATL , 8 बाइट्स

dZSd|1>a

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

Answer 19

भूसी , 7 बाइट्स

V<0Ẋ*Ẋ-

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

व्याख्या

V<0Ẋ*Ẋ-  Implicit input, say [2,5,5,1,4,5,3]
     Ẋ-  Consecutive differences: [3,0,-4,3,1,-2]
   Ẋ*    Consecutive products: [0,0,-12,3,-2]
V<0      Is any of them negative? Return 1-based index: 3

Answer 20

ऑक्टेव , 33 बाइट्स

@(x)0||abs(diff(sign(diff(x))))>1

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

स्पष्टीकरण:

@(x)                           % Anonymous function taking x as input
                  diff(x)       % Takes the difference between consecutive elements
             sign(diff(x))      % The sign of the differences
        diff(sign(diff(x)))     % The difference between the signs
    abs(diff(sign(diff(x)))>1   % Check if the absolute value is 2
@(x)abs(diff(sign(diff(x)))>1   % Output as matrices that are treated truthy or falsy

Answer 21

ब्रेकीलॉग , 10 बाइट्स

s₃.¬≤₁∧¬≥₁

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

सफलता ( true.) अगर कोई टक्कर है, और विफल है ( false.) अगर कोई टक्कर नहीं है।

व्याख्या

यह पहले से ही काफी पठनीय है:

s₃.           There is a substring of the input…
  .¬≤₁        …which is not non-decreasing…
      ∧       …and…
       ¬≥₁    …which is not non-increasing

Answer 22

05AB1E , 7 बाइट्स

¥ü‚P0‹Z

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

व्याख्या

¥         # calculate delta's
 ü‚       # pair each element with the next element
   P      # product of each pair
    0‹    # check each if less than 0
      Z   # max

Comments

वहाँ एक 1-बाइट विकल्प नहीं था 0‹जो मूल रूप से एक नकारात्मक संकेत के लिए संख्या की जांच करता है?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: dकेवल उस स्टैक के शीर्ष की जाँच करने के लिए उपयोग किया जाता है [0-9], जो कि यहाँ हम चाहते हैं के विपरीत है। लेकिन अब यह अधिक बुद्धिमान है और नकारात्मक / तैरता भी संख्या के रूप में गिना जाता है।

— Emigna

अह्ह्ह्ह… कसम aने इशारा देख लिया negativeऔर सच्ची या कुछ लौटा दी… लेकिन मुझे लगता है कि तुम सही हो, मुझे तुम्हारी dचाल याद आ रही है ।

— मैजिक ऑक्टोपस Urn

Answer 23

ब्रेकीलॉग , 10 बाइट्स

s₃s₂ᶠ-ᵐ×<0

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

@ फैटलिज़ के मौजूदा 10 बाइट उत्तर के रूप में लगभग साफ और सुरुचिपूर्ण नहीं है, लेकिन यह काम करता है!

s₃   % There exists a substring of three elements [I,J,K] in the array such that

s₂ᶠ  % When it's split into pairs [[I,J],[J,K]]

-ᵐ   % And each difference is taken [I-J, J-K]

×    % And those differences are multiplied (I-J)*(J-K)
     % (At a bump, one of those will be negative and the other positive. 
     % At other places, both differences will be positive, or both negative, 
     %  or one of them 0 - ultimately resulting in a non-negative product.)

<0   % The product is negative

Answer 24

भूसी , 9 बाइट्स

▼mεẊ-Ẋo±-

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

डेनिस के एल्गोरिथ्म का उपयोग करता है।

Answer 25

पर्ल 5 , 54 + 2 ( -pa) = 56 बाइट्स

map$\|=$F[$_-1]!=(sort{$a-$b}@F[$_-2..$_])[1],2..$#F}{

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

Answer 26

पायथन 2 , 60 बाइट्स

lambda l:any(p>c<n or p<c>n for p,c,n in zip(l,l[1:],l[2:]))

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

बहुत ज्यादा एक ही बात है, सोचा था कि यह छोटा होगा ...

पायथन 2 , 63 बाइट्स

f=lambda l:l[3:]and(l[0]>l[1]<l[2]or l[0]<l[1]>l[2]or f(l[1:]))

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

Comments

इसके बजाय गुणा का उपयोग करते हुए 58 बाइट्स

— Shieru Asakoto

Answer 27

पाइट , 11 7 बाइट्स

₋ʁ*0<Ʃ±

आउटपुट 1 अगर कोई टक्कर है, तो 0 अन्यथा

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

गेहूं जादूगर के हास्केल उत्तर का पोर्ट

---

पुराना तरीका (11 बाइट्स):

₋±₋Å1≤ĐŁ↔Ʃ=

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

अगर कोई टकराता है तो झूठा लौटाता है, सच है अन्यथा

पोर्ट ऑफ डेनिस 'जेली जवाब

Answer 28

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 37 36 बाइट्स

FreeQ[(d=Differences)@Sign@d@#,-2|2]&

परीक्षण मामले के उत्तर के विपरीत देता है (गलत और सच उलट)। !सामान्य रूप में स्विच करने के लिए एक को प्राथमिकता दें ।

या

Abs@(d=Differences)@Sign@d@#~FreeQ~2&

इसके अलावा उत्पादन उलट है, इसलिए सामान्य रूप के FreeQसाथ बदलें MatchQ।

स्पष्टीकरण: अनुक्रम के अंतर का संकेत लें। Iff के परिणामस्वरूप अनुक्रम में {1, -1} या {-1,1} शामिल हैं, एक टक्कर है। पूर्ण मान का अंतर किसी भी स्थिति में {1, -1} या {-1,1} के 2 है।

निरपेक्ष मूल्य लेने के बजाय अंतिम सूची को चुकता करके एक और बाइट को काटें:

FreeQ[(d=Differences)@Sign@d@#^2,4]&

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

Answer 29

पर्ल, 35 बाइट्स

के लिए शामिल +3है-p

bump.pl:

#!/usr/bin/perl -p
s%\S+ %$a*1*($a=$&-$')%eg;$_=/-/

ऐसे दोड़ो:

bump.pl <<< "3 1 2"

Answer 30

जूलिया 0.6 , 57 56 बाइट्स

l->any(p>c<n||p<c>n for(p,c,n)=zip(l,l[2:end],l[3:end]))

मूल रूप से बस पूरी तरह से अमानवीय के अजगर जवाब। उपयोगकर्ता 71546 से -1 बाइट

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

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

f(x,y,z,a...)=x>y<z||x<y>z||f(y,z,a...)

लिस्फी की पुनरावृत्ति शैली, उर्फ ​​डेनिस का अजगर जवाब। trueजब कोई टक्कर मौजूद होती है, तो वापस आता है, अन्यथा एक त्रुटि फेंकता है। यह शायद 42 बाइट्स का होना चाहिए क्योंकि आपको कॉल करते समय इसे अलग करना होगा। उदाहरण के लिए a=[1,2,1]आप के रूप में फोन f(a...)। f(a)=f(a...)उस जरूरत को दूर करेगा, लेकिन लंबा है। मुझे बेहतर पुनरावर्ती प्राप्त करने की आवश्यकता है, और मुझे वास्तव में कोड लिखना पसंद नहीं है जो एक त्रुटि फेंकता है।

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

Comments

लगता है कि अंतरिक्ष के बाद forआवश्यक नहीं है;)

— शायरु असाकोतो