18

आपका कार्य एक कंप्यूटर प्रोग्राम या फ़ंक्शन लिखना है जो कम से कम लंबाई 2 के सकारात्मक पूर्णांक की एक सूची लेता है और निर्धारित करता है कि क्या वे "ज़िगज़ैग" हैं। एक अनुक्रम एक zigzag है यदि और केवल अगर संख्याएं उनके सामने आने वाली संख्या की तुलना में बड़ी और छोटी होने में वैकल्पिक होती हैं। उदाहरण के लिए और लेकिन और नहीं हैं। $[1,2,0,3,2]$ $[4,2,3,0,1]$ $[1,2,0,0,3,1]$ $[1,2,3,1]$

अपने निर्णय के लिए आपको प्रत्येक संभावना (zigzag और zigzag) के लिए दो अलग-अलग संगत मूल्यों में से एक का उत्पादन करना चाहिए।

आपके प्रोग्राम या फ़ंक्शन का कोड-पॉइंट भी एक zigzag होना चाहिए। इसका मतलब यह है कि जब आप कोड-पॉइंट का क्रम लेते हैं तो यह एक ज़िगज़ैग होना चाहिए।

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

— पोस्ट रॉक गार्फ हंटर
स्रोत

1

कोड बिंदुओं में प्रत्येक गैर-ज़िगज़ैग के लिए जुर्माना एक और दृष्टिकोण हो सकता है, जिसमें विभिन्न प्रकार की भाषाओं के लिए भाग लेने की अनुमति हो।

— एनजी

5

@ मैं असहमत हूं। बोनस / पेनल्टी का परिचय उपयोगकर्ताओं को कई संभावित उत्तरों (जैसे लघु एक + दंड बनाम लंबी + कोई जुर्माना) के साथ आएगा, जिससे उत्तर प्रक्रिया धीमी हो जाएगी। साथ ही, दिए गए जुर्माने की राशि काफी मनमानी होगी, जिसका अर्थ है कि स्कोरिंग प्रक्रिया वह उद्देश्य नहीं होगा।

— जुंगह्वान मिन

2

क्या हमें यूनिकोड कोड पॉइंट या एन्कोडिंग का कोड पॉइंट लेना चाहिए जिसका हम उपयोग कर रहे हैं?

— डेनिस

1

@ डेनिस आपके द्वारा उपयोग किए जा रहे एन्कोडिंग का कोड-पॉइंट।

— पोस्ट रॉक गार्फ हंटर

2

@ निश्चित रूप से, तकनीकी रूप से यह सच है। हालाँकि, हमने पहले ही यह स्थापित कर दिया था कि कोड-गोल्फ के लिए पुरस्कार देने वाला बोनस वह आदर्श नहीं है क्योंकि वे मुख्य चुनौती से हटते हैं। इस मामले में जुर्माना एक नकारात्मक बोनस होगा।

— जुंगह्वान मिन

7

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

IṠIỊẸ

रिटर्न (zigzag) या (zigzag नहीं)। $0$ $1$

जेली कोड पृष्ठ में कोड अंक । $[73, 205, 73, 176, 174]$

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

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

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

I      Increments; compute the forward differences of A.
 Ṡ     Take their signs.
       A is zigzag iff the signs are alternating.
  I    Take the increments again.
       Alternating signs result in an increment of -2 or 2.
       Non-alternating signs result in an increment of -1, 0, or 1.
   Ị   Insignificant; map each increment j to (|j| ≤ 1).
    Ẹ  Any; return 0 if all results are 0, 1 in any other case.

— डेनिस
स्रोत

4

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

f(a:b:c:d)|(>)a b,b<c=f$b:c:d |(<)a b,b>c=f$b:c:d |1>0=1>12
f[a ] =1<12
f(a:b:_)= a/= b

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

मैं हास्केल के जवाबों के संदर्भ में गेंद को लुढ़कना चाहता था। मुझे अभी तक इसमें सुधार करने का कोई रास्ता नहीं दिख रहा है, लेकिन मैं आश्वस्त हूं कि यह किया जा सकता है। मैं आगे देख रहा हूं कि लोग यहां से क्या कर सकते हैं।

— पोस्ट रॉक गार्फ हंटर
स्रोत

4

MATL , 9 बाइट्स

dt?ZSd]pA

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

मेरा पहला कभी MATL कार्यक्रम! अंत से पहले pवक्र आवश्यकता के लिए जोड़ा गया है।

स्पष्टीकरण:

d    %take the difference between successive elements of input
t    %duplicate that
?    %if that is all non-zero
  ZS %take the sign of those differences (so input is all `-1`s and `1`s now)
  d  %take the difference of that (so if there are successive `1`s or `-1`s, this will have a 0)
]    %end-if
p    %take the product of topmost stack vector (will be 0 if either the original difference or 
     % the difference-of-signs contained a 0)
A    %convert positive products to 1 (since OP specifies "you should output one of two different consistent values for each possibility ")

— sundar - मोनिका को बहाल करना
स्रोत

धन्यवाद! हाँ, जैसा कि मैंने उत्तर में उल्लेख किया है, मैंने इसे केवल ज़िगज़ैग आवश्यकता के लिए जोड़ा है (क्योंकि कोड को खुद ज़िगज़ैग जाना है)। ]जाहिरा तौर पर ऐसा है, तो बड़े अक्षरों और छोटे अक्षरों के बीच रहता है dकरने के लिए ]और ]करने के लिए Aदोनों की गई decrements, जिसकी अनुमति नहीं है के लिए होगा। इसलिए pमुख्य रूप से दोनों के बीच एक कोडपाइ इन्क्रीमेंट है।

— सूंदर -

1

ओह, मैं पूरी तरह से उस आवश्यकता के बारे में भूल गया था। यह उत्तर को अधिक प्रभावशाली बनाता है!

— लुइस मेंडू

4

पायथन 2 , 225 223 161 139 बाइट्स

^{डेको के लिए जैकब}^{-62 बाइट्स के लिए}^{-2 बाइट्स धन्यवाद}

e={eval }.pop()
p ="i"+"n"+"p"+"u"+"t ( "
s=e(p +")")
e(p +"` a"+"l"+"l([(x<y>z)+(x>y<z)f"+"o"+"r x,y,z i"+"n zip(s,s [1: ],s [2: ])])` )")

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

धमाकेदार एल्गोरिथ्म के लिए क्रेडिट इस जवाब पर जाता है

input, print, exec, defऔर lambdaऊबड़ नहीं कर रहे हैं तो मैं केवल गया evalजो संग्रहीत किया जाता है पर छोड़ दिया, e
वहाँ प्रतिबंध बाईपास के लिए 2 मुख्य तरीके, रखकर कर रहे हैं "+"या गैर ऊबड़ जोड़े के बीच, मैं पूर्व (के लिए चुना प्रत्येक उपयोग के लिए कम है, लेकिन इसे replace(' ','')अधिक बाइट्स के परिणामस्वरूप परिणाम की आवश्यकता होगी )
चूंकि printऊबड़ नहीं है, मैं इसे सीधे उपयोग नहीं कर सकता, और चूंकि यह एक कवक नहीं है जो मैं इसे अंदर उपयोग नहीं कर सकता eval(), इसलिए मुझे input(result)परिणाम का उत्पादन करने के लिए उपयोग करना पड़ा

— छड़ी
स्रोत

अच्छा लगा। आप के ' ' * 0लिए स्थानापन्न कर सकते हैं ' ' [1: ]।

— जैकब

आप input(text)STDOUT पर लिखने के लिए उपयोग कर सकते हैं ।

— डेनिस

4

के (ngn / k) , 23 बाइट्स

{*/ 0 >1_ *':1_ -': x }

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

— NGN
स्रोत

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

— जकार्ही

@ Zacharý k कोड खुद उनके बिना

— ऊब

उससे तुम्हारा क्या मतलब है? क्या यह ngn / k है जो रिक्त स्थान को

— मिटाता है

3

@ Zacharý यह चुनौती प्रतिबंधित-स्रोत है , और प्रतिबंध यह है कि कोड एक zigzag होना चाहिए।

— निकोलस

वूप्स, वह भी भूल गया।

— जकार्ही

3

ओम v2 , 5 बाइट्स

δyδ½Å

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

$[131,121,131,16,165]$

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

Fully। - पूर्ण कार्यक्रम / एकल-तर्क ब्लॉक।
signsy - इनपुट के डेल्टास के संकेत 
  of - संकेतों के अंतर। 2 या -2 के अनुक्रमों में परिणाम होता है
        ऊबड़ arrays, संकेत के रूप में वैकल्पिक, -1-1 = -2 या 1 दे - (- 1) = 2।
    All - जांचें कि क्या सभी तत्व सत्य परिणाम देते हैं जब ...
   Ved - हल किया हुआ।

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

2

जाप `-!` , 16 14 बाइट्स

ठीक है, यह सुंदर नहीं है, लेकिन मैं सिर्फ यह काम करता हूँ खुश हूँ!

trueज़िग-ज़ैग के लिए आउटपुट या falseयदि नहीं।

ä'- m'g ä'a èÍ

कोशिश करो

कोडपॉइंट्स [228,39,45,32,109,39,103,32,228,39,97,32,232,205]ऊपर दिए गए लिंक में परीक्षण के रूप में शामिल हैं और शामिल हैं ।

व्याख्या

                   :Implicit input of array
ä'-                :Consecutive differences
    m'g            :Map signs
        ä'a        :Consecutive absolute differences
             Í     :Subtract each from 2
            è      :Count the truthy (non-zero) elements
                   :Implicitly negate and output resulting boolean.

— झबरा
स्रोत

@KamilDrakari, आम तौर पर आप सही होंगे लेकिन दुख की बात है कि वे चुनौती के प्रतिबंधित-स्रोत आवश्यकताओं को पूरा करने के लिए आवश्यक हैं । अन्यथा यह 10 बाइट्स हो सकता है ।

— झबरा

ओह, मैंने नहीं देखा कि यह प्रतिबंधित-स्रोत था। मेरा बुरा

— कामिल दकरी

@KamilDrakari, चिंता मत करो; ऐसा लगता है कि आप केवल एक ही नहीं थे।

— झबरा

1

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

IṠµaIẠ

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

रिटर्न 1truthy के लिए, 0falsy के लिए।

कोडपाइंट : [73, 205, 9, 97, 73, 171]( वैध )

— द एग्रीकॉल
स्रोत

1

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

{ [*] ($_[{1…*} ] Z<@$_)Z+^ ($_[{1…*} ] Z>@$_[{2…*} ])}

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

कोड बिंदु हैं:

(123 32 91 42 93 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 60 64 36 95 41 90 43 94 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 62 64 36 95 91 123 50 8230 42 125 32 93 41 125)

और हाँ, उन लोगों को वहाँ में यूनिकोड वर्ण हैं। यह कुछ स्थानों और घुंघराले ब्रेस में मिश्रित होने के साथ, कमोबेश मेरा मूल समाधान है।

— मजाक कर रहा है
स्रोत

1

05AB1E , 10 बाइट्स

¥DÄ/¥(Ä2QP

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

व्याख्या

¥           # calculate deltas of input
 DÄ/        # divide each by its absolute value
    ¥       # calculate deltas
     (      # negate each
      Ä     # absolute value of each
       2Q   # equals 2
         P  # product

कोड बिंदु हैं: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

— Emigna
स्रोत

1

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

a=> a.map(n=> e&=!~(p | q)| q <(q=p)^ p <(p=n), e=p=q=~ 0)|e

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

कोड अंक:

61 3d 3e 20 61 2e 6d 61 70 28 6e 3d 3e 20 65 26
3d 21 7e 28 70 20 7c 20 71 29 7c 20 71 20 3c 28
71 3d 70 29 5e 20 70 20 3c 28 70 3d 6e 29 2c 20
65 3d 70 3d 71 3d 7e 20 30 29 7c

— Arnauld
स्रोत

2

सौभाग्य mapसे ज़िगज़ैग है!

— नील

0

05AB1E , 8 बाइट्स

¥.±¥Ä2/P

1.0ज़िगज़ैगिंग के लिए और 0.0गैर-ज़िगज़ैगिंग दृश्यों के लिए रिटर्न ।

कोड अंक हैं [164,108,176,164,195,2,109,25]में 05AB1E कोड पेज ।

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

स्पष्टीकरण:

¥           # Take the deltas of the (implicit) input-list
            #  i.e. [1,2,0,3,2,3] → [1,-2,3,-1,1]
 .±         # Calculate the sign for each of them (-1 if a<0; 0 if 0; 1 if a>0)
            #  i.e. [1,-2,3,-1,1] → [1,-1,1,-1,1]
   ¥        # Calculate the deltas of those
            #  i.e. [1,-1,1,-1,1] → [-2,2,-2,2]
    Ä       # Take the absolute value of each
            #  i.e. [-2,2,-2,2] → [2,2,2,2]
     2/     # Divide them by 2
            #  i.e. [2,2,2,2] → [1.0,1.0,1.0,1.0]
            # (`;` {halve} would have been shorter, but doesn't comply to the challenge)
       P    # Take the product of the list resulting in either 1.0 or 0.0
            #  i.e. [1.0,1.0,1.0,1.0] → 1.0

— केविन क्रूज़सेन
स्रोत

एक ऊबड़ सवारी के लिए

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

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

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

MATL , 9 बाइट्स

पायथन 2 , 225 223 161 139 बाइट्स

के (ngn / k) , 23 बाइट्स

ओम v2 , 5 बाइट्स

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

जाप -! , 16 14 बाइट्स

व्याख्या

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

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

05AB1E , 10 बाइट्स

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

05AB1E , 8 बाइट्स

जाप `-!` , 16 14 बाइट्स