क्या मैं एक तुच्छ सरणी हूँ?

Question

एक महत्वहीन सरणी सकारात्मक पूर्णांक का एक सरणी है, जहां निरंतर तत्वों के बीच पूर्ण अंतर सभी 1 के बराबर या उससे छोटे हैं ।

उदाहरण के लिए, निम्न सरणी महत्वहीन है:

[1, 2, 3, 4, 3, 4, 5, 5, 5, 4]

क्योंकि संगत (पूर्ण) अंतर हैं:

[1, 1, 1, 1, 1, 1, 0, 0, 1]

जो सभी 1 के बराबर या उससे छोटे हों ।

---

आपका कार्य यह निर्धारित करना है कि पूर्णांकों की एक सरणी निरर्थक है या नहीं।

• आप मान सकते हैं कि सरणी में हमेशा कम से कम दो तत्व होते हैं।
• मानक इनपुट और आउटपुट नियम लागू होते हैं। आप किसी भी उचित प्रारूप में इनपुट (और आउटपुट) ले सकते हैं।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• सत्य / मिथ्या मूल्यों को अलग और सुसंगत होना चाहिए।
• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

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

इनपुट -> आउटपुट

[१, २, ३, ४, ३, ४, ५, ५, ५, ४] -> सत्य
[१, २, ३, ४, ५, ६, 3, 3, ९,>] -> सत्य
[३, ३, ३, ३, ३, ३, ३] -> सत्य
[३, ४, ४, ४, ३, ३, ३, ४, ४, ४] -> सत्य
[१, २, ३, ४] -> सत्य 
[५, ४, ३, २] -> सत्य 
[१, ३, ५, 5, ९, 5, ५, ३, १] -> असत्य
[१, १, १, २, ३, ४, ५, ६, १ ९] -> असत्य
[३, ४, ५, ६, 5, 5, 5, ५] -> असत्य
[१, २, ४, १०, १ 4, १०, १००] -> असत्य
[१०, २०, ३०, ३०, ३०] -> असत्य

मैंने मूल्यों का उपयोग किया trueऔर false।

Comments

क्या हमारी पसंद की भाषा में सत्य / मिथ्या मूल्य वास्तव में सत्य / मिथ्या है या क्या हम किसी दो अलग और सुसंगत मूल्यों का उपयोग कर सकते हैं?

— मार्टिन एंडर

@MartinEnder कोई दो अलग और सुसंगत मूल्य। PS देर से प्रतिक्रिया के लिए क्षमा करें

पाठ कहता है कि आपको पूर्णांकों की एक सरणी दी जाएगी, लेकिन सकारात्मक पूर्णांक के केवल सारणी निरर्थक हो सकती हैं। क्या हमें नकारात्मक पूर्णांक की एक सरणी के लिए तैयार रहना चाहिए?

— मार्क एस।

Answer 1

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

IỊẠ

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

कैसे?

जेली के लिए एकदम सही चुनौती।

I। पूर्ण कार्यक्रम।

मैं वृद्धि; लगातार तत्वों के बीच अंतर प्राप्त करें।
 Ant तुच्छ; वापसी abs (संख्या) ≤ १।
  Ạ सभी; रिटर्न 1 यदि सभी तत्व सत्य हैं, तो 0 अन्यथा।

Comments

Pयह काम नहीं करेगा, क्योंकि अगर सभी अंतर 1यह उत्पादन होता 1, लेकिन अगर उनमें से एक 0यह उत्पादन होता 0? और अगर एक अंतर था, 5लेकिन एक 0यह था फिर भी क्या होगा 0?

— Tas

"सकारात्मक पूर्णांक" आवश्यकता के बारे में क्या?

— 3D1T0R

Answer 2

जावास्क्रिप्ट (ईएस 7), 33 29 बाइट्स

@JohanKarlsson को 4 बाइट्स से धन्यवाद दिया

a=>!a.some(v=>(a-(a=v))**2>1)

कैसे?

जब के लिए मजबूर Number, कम से कम दो तत्वों के सरणियों का मूल्यांकन किया जाता है NaN। द्वारा इनपुट पुनः उपयोग एक के रूप में चर पिछले मान पकड़े, की पहली यात्रा कुछ () हमेशा में जो परिणाम ([V0, v1, ...] - एक [0]) ** 2 = NaN , कोई फर्क नहीं पड़ता एक मूल्य [को ०] । इसलिए, पहला परीक्षण हमेशा मिथ्या है और वास्तविक तुलना 2 पुनरावृत्ति पर शुरू होती है, जैसे वे करने के लिए हैं।

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

let f =

(a,p)=>!a.some(v=>(p-(p=v))**2>1)

console.log(f([1, 2, 3, 4, 3, 4, 5, 5, 5, 4])) // true
console.log(f([1, 2, 3, 4, 5, 6, 7, 8, 9, 8])) // true
console.log(f([3, 3, 3, 3, 3, 3, 3]         )) // true
console.log(f([3, 4, 4, 4, 3, 3, 3, 4, 4, 4])) // true
console.log(f([1, 2, 3, 4]                  )) // true
console.log(f([5, 4, 3, 2]                  )) // true
console.log(f([1, 3, 5, 7, 9, 7, 5, 3, 1]   )) // false
console.log(f([1, 1, 1, 2, 3, 4, 5, 6, 19]  )) // false
console.log(f([3, 4, 5, 6, 7, 8, 7, 5]      )) // false
console.log(f([1, 2, 4, 10, 18, 10, 100]    )) // false
console.log(f([10, 20, 30, 30, 30]          )) // false

Comments

29 बाइट्स:a=>!a.some(v=>(a-(a=v))**2>1)

— जोहान कर्ल्ससन

@JohanKarlsson आह हाँ, इनपुट में कम से कम 2 तत्व होने की गारंटी है, इसलिए यह सुरक्षित है। आपका बहुत बहुत धन्यवाद!

— Arnauld

Answer 3

पायथन 3 , 40 बाइट्स

f=lambda n,*t:t==()or-2<n-t[0]<=1==f(*t)

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

Answer 4

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

Max@Abs@Differences@#<2&

Comments

#==Clip@#&@*Differencesएक बाइट कम है

— मिशा लावरोव

Answer 5

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

x=input()
while-2<x.pop(0)-x[0]<2:1

अन्यथा स्थिति कोड 0 के साथ, बेहिसाब सरणियों के लिए स्थिति कोड 1 के साथ मौजूद है ।

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

Answer 6

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

ΛεẊ-

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

स्पष्टीकरण:

ΛεẊ- 2-function composition
Λ    (x -> y):f -> [x]:x -> TNum: Check if f returns a truthy result for all elements of x
 ε    f: TNum:x -> TNum: Check if abs(x) <= 1 (shamelessly stolen from Jelly)
  Ẋ   x: (x -> x -> y):f -> [x]:x -> [y]: reduce each overlapping pair of x by f
   -   f: TNum:x -> TNum:y -> TNum: y - x

Answer 7

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

@(x)all(diff(x).^2<2)

बेनामी फ़ंक्शन जो एक संख्यात्मक वेक्टर और ouputs को इनपुट करता है 1यदि महत्वहीन या 0अन्यथा।

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

Answer 8

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

all((<2).abs).(zipWith(-)=<<tail)

इसे ऑनलाइन आज़माएं! -1 बाइट थैंक्यू @ user1472751

---

बिंदु मुक्त समाधान एक दो फिर से केवल एक बाइट ( @ डेनिस से -1 बाइट के लिए धन्यवाद ) पुनरावर्ती विकल्प से कम है:

f(a:b:r)=2>(a-b)^2&&f(b:r)
f _=1>0

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

Answer 9

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

._MI.+

सभी परीक्षण मामलों की जाँच करें।

---

पायथ , 8 बाइट्स

.A<R2aVt

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

व्याख्या

._MI.+   Full program.

    .+   Deltas.
   I     Is invariant under...
._M      Mapping with Sign. 0 if n == 0, -1 if n < 0, 1 if n > 0.

---

.A<R2aVt    Full program.

      Vt    Vectorize function, applied on the input zipped with the tail of the input.
     a      Absolute difference.
  <R2       For each, check if it is smaller than 2.
.A          All.

Comments

मुझे नहीं पता कि मैंने I#इसके बजाय क्यों सोचा M।

— स्टीवन एच।

Answer 10

प्रोटॉन , 41 बाइट्स

a=>all(-2<a[i]-a[i+1]<2for i:0..len(a)-1)

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

-16 बाइट्स मिस्टर एक्सकोडर
-2 बाइट्स
-6 बाइट्स की बदौलत मिस्टर एक्सकोडर की बदौलत

Comments

49 बाइट्स (-16 बाइट्स)

— मिस्टर एक्सकोडर

@ Mr.Xcoder मुझे लगता है कि अंतरिक्ष <2 forअचूक हो सकता है।

— जोनाथन फ्रेच

@JonathanFrech वहाँ कोई जगह नहीं है?

— श्री Xcoder

@ Mr.Xcoder ओह, मुझे नहीं पता कि मैं उन सभी पागल समारोह श्रृंखलाओं के साथ क्या सोच रहा था। धन्यवाद! : डी

— हाइपरनेत्रिनो

Answer 11

जाप , 6 बाइट्स

äa e<2

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

व्याख्या

ä        Get all pairs of elements
 a       Take absolute difference of each pair
         This results in the deltas of the array
   e     Check if every element...
    <2   Is less than 2

Answer 12

C # (.NET कोर) , 51 45 44 + 18 बाइट्स

-1 जेपी स्टिग नीलसन को धन्यवाद

a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4)

बाइट काउंट में ये भी शामिल हैं:

using System.Linq;

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

स्पष्टीकरण:

a =>                      // Take an array of integers as input
    a.Zip(                // Combine each element with corresponding one from:
        a.Skip(1),        //     the input array without first element
        (x, y) => x - y   //     get their difference
    )
    .All(x => x * x < 4)  // Check if all differences are less than 2
                          // (We only care about 0 and 1, and so happens that when they're squared, it works like Abs! Magic!)

Comments

थोड़ा सुधार: a=>a.Zip(a.Skip(1),(x,y)=>x-y).All(x=>x*x<4)यह नकार से बचता है !।

— जेपी स्टिग नीलसन

@JeppeStigNielsen भयानक, धन्यवाद!

— ग्रेजगोरज पुलावस्की

Answer 13

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

{?(2>all(.[]Z-.skip)>-2)}

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

यह बहुत पठनीय होना चाहिए। यहां केवल कम स्पष्ट बात यह है कि Zछोटी सूची समाप्त होने पर ज़िप ऑपरेटर ज़िप बंद कर देगा (हम दाईं ओर सूची के पहले तत्व को हटाते हैं) और खाली सबस्क्रिप्ट .[], जिसे ज़ेन स्लाइस कहा जाता है, पूरी सूची देता है। .skipपहले तत्व के बिना सूची लौटाता है।

Comments

क्या वे दो रिक्त स्थान वास्तव में आवश्यक हैं?

— जोनाथन फ्रेच

@JonathanFrech: सही शायद कोई नहीं। इसके अलावा मुझे सिर्फ यह एहसास हुआ कि .rotateयहां जरूरत नहीं है।

— रामलीज

बिल्ली, यहां तक ​​कि बाईं ओर भी हटाया जा सकता है। मुझे वास्तव में समझ नहीं आ रहा है कि व्हॉट्सएप की आवश्यकता कहां है और यह कहां नहीं है ...

— रामलीज

आप -2<इसके बजाय लिख सकते हैं -1≤और <2इसके बजाय ≤1चार और बाइट्स बचा सकते हैं।

— सीन

एर, मुझे लगता है कि आपको वास्तव में गलत तरीके 2>...>-2से व्याख्या करने से बचने के लिए तुलनाओं को उल्टा करना होगा <।

— सीन

Answer 14

आर , 30 26 बाइट्स

cat(all(diff(scan())^2<2))

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

Comments

मुझे लगता function(a)all(diff(a)^2<2)है कि 3 बाइट्स बचाता है।

— बीएलटी

आप कंसोल से इनपुट ले सकते हैं:all(diff(scan())^2<2)

— flodel

@BLT अच्छा बिंदु!

— user2390246

@flodel का उपयोग करते समय आउटपुट को स्पष्ट रूप से प्रिंट करने की आवश्यकता के बारे में कुछ हालिया चर्चा थी scan, लेकिन यह अभी भी एक बाइट बचाता है!

— user2390246

Answer 15

05AB1E , 5 बाइट्स

¥Ä2‹P

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

व्याख्या

¥        # calculate deltas
 Ä       # absolute values
  2‹     # smaller than 2
    P    # product

Comments

@ ओएक्सएक्स: मुझे डर नहीं है। यह [5,2]उदाहरण के लिए काम नहीं करेगा ।

— इमिंजा

Answer 16

ओम v2 , 4 बाइट्स

Δ2<Å

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

कैसे?

Δ2<Å   ~ Full program.

Δ      ~ Absolute deltas.
 2<    ~ Is smaller than 2?
   Å   ~ Check if all elements are truthy.

Answer 17

पॉवरशेल , 62 बाइट्स

param($a)$l=$a[0];($a|?{$_-$l-in1..-1;$l=$_}).count-eq$a.count

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

PowerShell में एक .mapया .someसमान कमांड नहीं है, इसलिए यहां हम व्यक्तिगत रूप से प्रत्येक डेल्टा की जांच कर रहे हैं।

हम इनपुट लेते हैं $aऔर $lपहले तत्व के बराबर सेट करते हैं। फिर हम $aप्रत्येक तत्व के माध्यम से लूप करते हैं और |?{...}अंतर $_-$lको -inसीमा तक ले जाते हैं 1,0,-1। हम फिर $lवर्तमान तत्व के बराबर सेट करते हैं। तो अब हमारे पास उन तत्वों का एक संग्रह है जहां उनके पिछले पड़ोसी के बीच डेल्टा है। हम उस .countपर ध्यान देते हैं और यह -eqजांचते हैं कि क्या यह .countएक पूरे के रूप में सरणी का ual है । यदि यह है, तो प्रत्येक डेल्टा 1 या उससे कम है, इसलिए यह एक महत्वहीन सरणी है। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

Comments

आप परम से छुटकारा पाने के लिए 1 बाइट बचा सकते हैं और कर सकते हैं$l=($a=$args)[0]

— 20

@briantist हालांकि काम नहीं करता है। उदाहरण के लिए। ऐसा इसलिए है क्योंकि यह $lआपके सुझाव में संपूर्ण इनपुट सरणी होने की सेटिंग कर रहा है।

— AdmBorkBork

मुझे लगता है कि आपको केवल TIO में तर्क देने के तरीके को बदलने की आवश्यकता है (प्रत्येक तत्व को अलग से निर्दिष्ट करने की आवश्यकता है)। जिस तरह से आपके पास अभी है, उसका पहला तत्व $argsस्वयं संपूर्ण सरणी है। उदाहरण

— रिश्वतवादी

यह धोखा महसूस करता है ...

— AdmBorkBork

मुझे लगता है कि यह वास्तव में उपयोग करने का सही तरीका है $args। यदि आप एक स्क्रिप्ट या फ़ंक्शन को रिक्त स्थान के रूप में अलग किए गए तर्कों की एक श्रृंखला के साथ कहते हैं, तो यह अलग-अलग तत्वों के रूप में आएगा $argsऔर TIO के लिए कि इसका अनुकरण कैसे किया जाए। मैंने व्यक्तिगत रूप से इसे कई बार पहले भी इस्तेमाल किया है, लेकिन प्रत्येक को अपनी :)

— रिश्वत

Answer 18

पायथन 3 , 45 बाइट्स

lambda k:all(-2<x-y<2for x,y in zip(k,k[1:]))

इसे ऑनलाइन आज़माएं! या परीक्षण सूट की कोशिश करो।

-2 बाइट्स के लिए जोनाथन फ्रेच को धन्यवाद ।

Comments

abs(x-y)<2-> -2<x-y<2।

— जोनाथन फ्रेच

Answer 19

जावा (ओपनजेडके 8) , 78 बाइट्स

a->{int p=0,i=1;for(;i<a.length;p+=Math.abs(a[i]-a[i++-1])>1?1:0);return p<1;}

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

Answer 20

MATL ,6 5 बाइट्स

d|2<A

Giuseppe के लिए -1 बाइट धन्यवाद

इसे ऑनलाइन आज़माएं! या सभी परीक्षण-मामलों को सत्यापित करें

Comments

मुझे लगता है कि प्रति मेटा आम सहमति केd|2< बजाय आप उपयोग कर सकते हैं , एक शून्य मान के साथ एक सरणी MATL में गलत है।

— Giuseppe

या d|2<Aअपने मूल उत्तर के करीब कुछ के लिए।

— ग्यूसेप

@Giuseppe नहीं वे नहीं कर सकते: सत्य / झूठे मूल्यों को अलग और सुसंगत होना चाहिए ।

— मिस्टर एक्सकोडर

@ Mr.Xcoder "सत्य के लिए सभी 1s का एक सरणी" और "एक सरणी जिसमें कम से कम एक शून्य के लिए गलत" है, अलग और सुसंगत नहीं है?

— ग्यूसेप

@Giuseppe " सत्य के लिए सभी 1s की एक सरणी" और "एक सरणी जिसमें कम से कम एक शून्य के लिए गलत" है, अलग और सुसंगत नहीं है? - नहीं, यह स्वीकार्य नहीं है, क्योंकि वे असंगत हैं।

Answer 21

anyfix , 9 बाइट्स

I€A€2<»/&

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

I€A€2<»/&  Main Link
I          Deltas
 €         For each element
  A        Take its absolute value
   €  »    For each element
    2<     Is it less than two?
       /   Reduce over
        &  Logical AND

यह ज्यादातर 05AB1E समाधान का एक बंदरगाह है सिवाय भयानक के क्योंकि किसी भी उपसर्ग में ऑटोव्यूनीकरण और अन्य शांत चीजें नहीं हैं

Answer 22

सी, 61 56 बाइट्स

पांच बाइट बचाने के लिए @scottinet को धन्यवाद!

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);return r;}

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

सी (जीसीसी), 47 बाइट्स

r;f(a,n)int*a;{for(r=1;--n;r=(*a-*++a)/2?0:r);}

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

Comments

और अगर इसकी अनुमति है / यदि आपको ऐसा लगता है, तो आप इसे वापस करने के बजाय परिणाम को संग्रहीत करके 9 और बाइट्स बचा सकते हैं r। :-)

— स्कूटनीट

@scottinet मैंने उस पर विचार किया, लेकिन यह सी के साथ काम करने के बावजूद ऐसा नहीं है। हालांकि इसकी अनुमति है, इसलिए मुझे लगता है कि मैं इसे वैकल्पिक संस्करण के रूप में शामिल करूंगा।

— Steadybox

@scottinet किसी फ़ंक्शन के अंत में एक वैरिएबल असाइन करना फ़ंक्शन के रिटर्न एड्रेस में उस मूल्य को डालता है, जिससे यह महसूस होता है कि यह मान लौटा रहा है। हालाँकि, यह व्यवहार C विशिष्टताओं का हिस्सा नहीं है, जिससे काम करने के लिए ग्वारेंटेड नहीं है। यह कुछ अनुकूलन करने वाले संकलक झंडे के साथ भी टूट सकता है।

— जोनाथन फ्रेच

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

— जोनाथन फ्रैच

@JonathanFrech भाषाओं को उनके कार्यान्वयन द्वारा यहां परिभाषित किया गया है, इसलिए यदि आपके पास एक कंपाइलर है जो लगातार परिणाम उत्पन्न करता है तो उत्तर वैध है, भले ही औपचारिक रूप से यूबी हो।

— क्वेंटिन

Answer 23

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

#(every? #{-1 0 1}(map -(rest %)%))

कितना साफ है?

Answer 24

टीआई-बेसिक, 6 7 बाइट्स

prod(2>abs(ΔList(Ans

या, 5 बाइट्स यदि त्रुटियों को वैध रिटर्न मान के रूप में गिना जाता है ( ERR:ARGUMENTयदि महत्वहीन है, तो रिटर्न ERR:DOMAIN)

augment(sin⁻¹(ΔList(Ans

Comments

यह संभवतया abs(ΔList(Ans1 से अधिक होना चाहिए (जैसे {5,3,1} या परीक्षण के मामले में {3,4,5,6,7,8,7,5}}) नहीं मिलता है पता चला।

— मिशा लावरोव

@ मिशालोवर धन्यवाद, आप सही कह रहे हैं!

— ओखी

Answer 25

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

(a,u)=>!a.some(e=>(e-=(u=e))>1|e<-1)

संपादित करें: @ Arnauld की चाल चोरी करके 1 बाइट को बचाया।

Comments

आप currying इस्तेमाल कर सकते हैं:a=>u=>!a.some(e=>(e-=(u=e))>1|e<-1)

— Bálint

Answer 26

पायथ, 7 बाइट्स

._I#I.+

परीक्षण सूट

सच्चा / झूठा लौटाता है।

स्पष्टीकरण:

     .+ Deltas, returns differences between consecutive values.
._      Signum, returns the sign of a number (1, 0, or -1).  Note that this should
             be equal to the input for insignificant arrays.
  I     Tests if it is equal to the input...
   #    For each in the input, and filter out those that aren't...
    I   And make sure none have been filtered out.

Answer 27

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

Differences@#~MatchQ~{(1|0|-1)..}&

व्याख्या

                                 & (* Function *)
Differences                        (* which takes the consecutive differences*)
           @#                      (* of the input list *)
             ~MatchQ~              (* and returns whether it matches *)
                     {(1|0|-1)..}  (* a list consisting of one or more 1s, 0s, or -1s *)

Answer 28

जावा (ओपनजेडके 8) , 60 बाइट्स

a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;}

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

• 5 बाइट्स @Nayay को धन्यवाद!

Comments

आप rलूप में उपयोग कर सकते हैं (p-n)केवल एक बार गणना करने के लिए , >>1हो सकता है /2या हटाया जा सकता है यदि आप |इसके बजाय का उपयोग करते हैं +: a->{int r=1,p=a[0];for(int i:a)r|=(r=p-(p=i))*r;return r<2;}(60 बाइट्स)।

— नेवई

चीयर्स @ नवे, धन्यवाद! परफेक्ट गोल्फिंग, हमेशा की तरह ;-)

— ओलिवियर ग्रैगोइरे

क्या आप मुझे समझा सकते हैं कि यह कैसे काम करता है? धन्यवाद!

— ब्लरस्ट्रीम

Answer 29

स्विफ्ट 4, 52 बाइट्स

{!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

परीक्षण सूट:

let isInsignificant: (_ array: [Int]) -> Bool = {!zip($0.dropFirst(),$0).map(-).contains{1<abs($0)}}

let testcases: [(input: [Int], expected: Bool)] = [
    (input: [1, 2, 3, 4, 3, 4, 5, 5, 5, 4], expected: true),
    (input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 8], expected: true),
    (input: [3, 3, 3, 3, 3, 3, 3],          expected: true),
    (input: [3, 4, 4, 4, 3, 3, 3, 4, 4, 4], expected: true),
    (input: [1, 2, 3, 4],                   expected: true ),
    (input: [5, 4, 3, 2],                   expected: true ),
    (input: [1, 3, 5, 7, 9, 7, 5, 3, 1],    expected: false),
    (input: [1, 1, 1, 2, 3, 4, 5, 6, 19],   expected: false),
    (input: [3, 4, 5, 6, 7, 8, 7, 5],       expected: false),
    (input: [1, 2, 4, 10, 18, 10, 100],     expected: false),
    (input: [10, 20, 30, 30, 30],           expected: false),
]


for (caseNumber, testcase) in testcases.enumerated() {
    let actual = isInsignificant(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

Answer 30

एपीएल, 13 बाइट्स

{×/(|2-/⍵)<2}

पहले एपीएल उत्तर \ _ /

नोट: मैं हाइपर न्यूट्रिनो के स्वामित्व वाला एक बॉट हूं। मैं मुख्य रूप से चैट टेस्टिंग के लिए मौजूद हूं।

व्याख्या

{×/(|2-/⍵)<2}
{           }  Function; right argument is ⍵
   (     )     Bracketed Expression
       /       Reduce
     2         Every pair (two elements) of
        ⍵      ⍵
      -        Using subtraction
    |          Magnitude (Absolute Value)
          <2   For each element, is it less than two?
  /            Reduce over
 ×             Multiplication (Product) (All)

Comments

- 11 मौन के रूप में बाइट्स∧/2>(|2-/⊢)

— ऊरीएल