क्या यह एक अभ्यास सेट है?

Question

हम सभी जानते हैं कि बहुत सारे व्यायाम केवल आपके शरीर के आधे हिस्से को प्रभावित करते हैं, इसलिए आपको उन्हें दो बार करना होगा, एक बार प्रत्येक पक्ष के लिए। इस तरह के अभ्यासों में दो समकक्ष होते हैं, एक बाईं ओर और दूसरा दाईं ओर। हालांकि, दो समकक्षों को लगातार निष्पादित करने की आवश्यकता नहीं है, जब तक कि दोनों पक्षों के लिए अभ्यास एक ही क्रम में नहीं होते हैं। आप अपने व्यायाम कार्यक्रम में दोनों पक्षों के बीच स्विच कर सकते हैं, लेकिन यह एक तरफ से कुछ अभ्यास शुरू करने और दूसरे के साथ कुछ करने के लिए समझ में नहीं आएगा।

चुनौती

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

एक व्यायाम सेट शून्य या अधिक व्यायाम भागों के साथ एक ही अग्रणी पक्ष एक साथ समाप्‍त होता है।

इनपुट के रूप में गैर-शून्य पूर्णांक की एक सूची को देखते हुए, यह निर्धारित करें कि क्या यह एक व्यायाम सेट है। पूर्णांक जरूरी अद्वितीय नहीं हैं। सूची की लंबाई भी जरूरी नहीं है।

आपका समाधान किसी भी मानक खामियों का उपयोग नहीं कर सकता है । आप आउटपुट के लिए किसी भी दो अलग-अलग संगत मूल्यों का उपयोग कर सकते हैं। यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान जीतता है।

उदाहरण

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]एक व्यायाम भाग का एक उदाहरण है। पहला आधा हिस्सा है [-5, -1, -7, -6, -5], और आखिरी आधा हिस्सा है [5, 1, 7, 6, 5], जो कि पहले छमाही में प्रत्येक पूर्णांक है। इसके अतिरिक्त, पहले आधे के पूर्णांक सभी एक ही संकेत के हैं। यह व्यायाम भाग का प्रमुख पक्ष है -1।

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]एक व्यायाम सेट का एक उदाहरण है। इसके व्यक्तिगत व्यायाम के अंग हैं [3, 6, 5, -3, -6, -5]और [1, 6, 4, 3, -1, -6, -4, -3], और वे दोनों अग्रणी पक्ष हैं1 ।

[4, -4, -5, 5]केवल मान्य व्यायाम भागों से युक्त होने के बावजूद, पहले भाग के बाद से कोई व्यायाम सेट नहीं होता है [4, -4], इसमें अग्रणी पक्ष होता है 1, जबकि दूसरा भाग, [-5, 5]अग्रणी पक्ष होता है -1।

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

मान्य परीक्षण मामले:

[]
[1, -1]
[1, -1, 1, -1]
[-6, 6, -5, -4, -3, 5, 4, 3]
[-1, -5, -8, 1, 5, 8, -7, -6, -5, -3, 7, 6, 5, 3]
[-1, -5, -8, 1, 5, 8, -1, 1]

अमान्य परीक्षण मामले:

[1]
[1, -2]
[1, 2, -3, -1, -2, 3]
[1, 2, 3, -3, -1, -2]
[-1, -5, -8, 1, 5, 8, 7, 6, 5, 3, -7, -6, -5, -3]
[1, 2, 3, 5, 1, 2, 3, 5]
[1, 2, -5, 4, -6, 5, 5, -6]
[1, 2, -1, 3, -2, -3]
[1, -2, 1]
[-1, -1, 1]
[1, -1, 1]

Comments

खाली मामला एक झुंझलाहट है। और चुनौती के शब्दों की व्याख्या करने के लिए मुझे यकीन नहीं है कि क्या "एक तरफ व्यायाम नहीं करने" का एक वैध तरीका है "या तो एक तरफ या दूसरे का" यह एक व्यायाम सेट है? " लेकिन सच कहूं तो मैं सिर्फ रोना हूं।

— एन जी एम

@ngm केवल इस बारे में टिप्पणी करने वाला था .. खाली सूची एक कष्टप्रद बढ़त मामला है .. व्यक्तिगत रूप से मैं बताता हूं कि इनपुट में कम से कम एक आइटम शामिल है। उस अच्छी चुनौती के अलावा, हालांकि!

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

@ngm यह सत्य के रूप में है। इसे उचित विश्राम मानें। ;)

— एरिक आउटगोल्फ

यह जानना अच्छा है कि मैं एक ही समय में गोल्फ और व्यायाम कर सकता हूं।

— एन जी एम

@ngm " यह अच्छा है पता करने के मैं एक ही समय में गोल्फ और व्यायाम कर सकते हैं। " हम में से अधिक मिला चुनौतियों में से उन लोगों के तरह । ;)

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

Answer 1

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

a,b=x=[[],[]];k=0
for n in input():x[n>0]+=n*n,n*k>0;k=n
print a==b

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

Answer 2

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

ṁṠŒg$+2/FẸ

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

Answer 3

जावा 8, 186 183 185 बाइट्स

a->{int i=a.length-1,t,j;boolean r=i%2>0,f;if(i<0)return!r;for(f=a[i]<0;i>0;){for(r&=f==(t=a[j=i])<0;j>0&&t>>>31==a[--j]>>>31;);for(t=i-j,i-=2*t;j>=0&j>i;)r&=a[j+t]==-a[j--];}return r;}

+2 बाइट्स आकार 3 के परीक्षण मामलों के लिए बग-फिक्स के कारण ( मेरे TIO- लिंक के अंत में 1और लगभग सभी क्रमपरिवर्तन -1)।

निश्चित रूप से गोल्फ हो सकता है .. चुनौती को बिंदु दिखता है, लेकिन इसे लागू करना बहुत कठिन है। विशेष रूप से परीक्षण के मामले [4,-4,-5,5]को ठीक करने के लिए कष्टप्रद था .. लेकिन यह अब काम करता है। क्या यहाँ से नीचे गोल्फ जाएगा।

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

स्पष्टीकरण:

a->{                   // Method with integer-array parameter and boolean return-type
  int i=a.length-1,j,  //  Index integers (`i` starting at the last index)
      t;               //  Temp integer
  boolean r=i%2>0,     //  Result-boolean, starting at true if the input-list is even
          f;           //  Flag-integer
  if(i<0)              //  If the input was empty (edge case)
    return!r;          //   Return true
  for(f=a[i]<0;        //  Set the flag-boolean to "Is the current item negative?"
      i>0;){           //  Loop down over the array
    for(r&=f==(t=a[j=i])<0;
                       //   Set `s` to the current number
                       //   And verify if the initial flag and `s` have the same sign
        j>0            //   Loop `j` from `i` down as long as `j` is larger than 0,
        &&t>>>31==a[--j]>>>31;);
                       //   and both `s` and the current item have the same sign
                       //    Decreasing `j` by 1 every iteration
    for(t=i-j,         //   Set `t` to `i-j` (amount of same signed adjacent values)
        i-=2*t;        //   Decrease `i` by two times `t`
        j>=0           //   Loop as long as `j` is larger than or equal to 0,
        &j>i;)         //   and also larger than `i`
      r&=a[j+t]==-a[j--];}
                       //    Verify if the pairs at index `j+t` and `j`
                       //    are negatives of each other
  return r;}           //  Return if `r` is still true (if all verifications succeeded)

Answer 4

आर , 91 बाइट्स

संख्याओं के एक व्हाट्सएप-अलग वेक्टर को इनपुट करता है। FALSEवैध और TRUEअमान्य के लिए आउटपुट ।

x=scan()
y=x<0
z=rle(y)
"if"(sum(x|1),any(x[y]+x[!y],z$v==rev(z$v),z$l[!0:1]-z$l[!1:0]),F)

rle सकारात्मक और नकारात्मक मूल्यों के अनुक्रम के इस मामले में, रन लंबाई एन्कोडिंग देता है।

पूरी तरह से और पूरी तरह से अनुचित खाली बढ़त मामले;) एक whopping 15 बाइट्स कहते हैं।

कई बाइट्स @Giuseppe द्वारा शेव की गईं।

यहाँ एक 92 बाइट संस्करण को एक फ़ंक्शन के रूप में व्यक्त किया गया है जो परीक्षण के लिए बेहतर है:

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

Answer 5

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

अनुकूलित संस्करण, डेनिस पायथन जवाब से प्रेरित है ।

रिटर्न 0 या 1 ।

a=>a.map(b=p=x=>b[+(x<0)]+=[x*x,p*(p=x)>0])|b[1]==b[0]

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

---

मूल संस्करण, 74 बाइट्स

a=>a.map(x=>b[i^=p*(p=x)<0&&-~(b[i]+=0)]+=[,x*x],b=[p=0,i=0])|b[1]+0==b[0]

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

कैसे?

हम बी [0] में सभी व्यायाम भागों के पहले हिस्सों को स्टोर करते हैं और दूसरे हिस्सों में बी [1] , बी [0] और बी [१] के बीच स्विच करते हुए हर बार संकेत बदल रहे हैं। संकेत से छुटकारा पाने के लिए प्रविष्टियां चुकता की जाती हैं। हम प्रत्येक प्रविष्टि को अल्पविराम से जोड़ते हैं और प्रत्येक भाग को 0 के साथ प्रत्यय देते हैं ।

मूल रूप से बिना किसी लागत के 'खाली इनपुट' एज मामले को संभालने के लिए कुछ अतिरिक्त तर्क हैं (स्रोत कोड के अंत के पास टिप्पणी देखें)।

a =>                    // given the input array a[]
  a.map(x =>            // for each x in a[]:
    b[i ^=              //   access b[i]:
      p * (p = x)       //     we keep track of the previous entry in p
      < 0 &&            //     if p and x have opposite signs:
      -~(b[i] += 0)     //       append a '0' to b[i] and update i: 0 -> 1, 1 -> 0
    ] += [, x * x],     //   append a comma followed by x² to b[i]
    b = [p = 0, i = 0]  //   start with p = 0, i = 0 and b = [0, 0]
  ) |                   // end of map()
  b[1] + 0              // this will append a '0' to b[1] if it was turned into a string
                        // or let it unchanged if it's still equal to zero (integer),
                        // which handles the 'empty input' edge case
  == b[0]               // compare the result with b[0]

Answer 6

पायथन 2 , 147 130 113 112 106 बाइट्स

from itertools import*
def f(s):l=[map(abs,g)for v,g in groupby(s+[0],0 .__cmp__)];print l[1::2]==l[:-1:2]

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

---

बचाया:

• -27 बाइट्स, डेनिस के लिए धन्यवाद

Comments

lambda n:cmp(n,0)बन सकता है 0 .__cmp__। all(a==b for a,b in zip(l[::2],l[1::2]))बन सकता है l[:-1:2]==l[1::2]।

— डेनिस

Answer 7

रेटिना 0.8.2 , 57 बाइट्स

^\b|,\b
$&=
(.)(\d+),(?=\1)
$2_
-|=

.$
$&,
^((\w+,)\2)*$

इसे ऑनलाइन आज़माएं! अल्पविराम से अलग किए गए इनपुट को ले जाता है, लेकिन लिंक में हेडर शामिल होता है जो परीक्षण मामलों की प्रक्रिया करता है। स्पष्टीकरण:

^\b|,\b
$&=

प्रत्येक सकारात्मक पूर्णांक से पहले एक मार्कर डालें।

(.)(\d+),(?=\1)
$2_

उसी चिह्न के पूर्णांक के बीच अल्पविराम को अंडरस्कोर में बदलें।

-|=

शेष चिह्न हटाएं।

.$
$&,

यदि इनपुट खाली नहीं है तो अल्पविराम लगाएं।

^((\w+,)\2)*$

जांचें कि स्ट्रिंग में समान पूर्णांकों के रनों के जोड़े हैं।

Answer 8

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

x=input()
o=[];p=[]
for a,b in zip(x,x[1:]):
 if 0<a*x[0]:
	p+=a,-a
	if b*a<0:o+=p[::2]+p[1::2];p=[]
print o==x

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

Answer 9

जावास्क्रिप्ट (Node.js) , 155 बाइट्स

b=>eval('i=b.length-1;r=i%2;0>i&&!r;for(f=0>b[i];0<i;){for(r&=f==(s=0>b[j=i]);0<j&&s&0>b[--j]|!s&0<b[j];);t=i-j;for(i-=2*t;0<=j&j>i;)r&=b[j+t]==-b[j--]}r')

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

---

प्रेरणा @ केविनक्रूजसेन का जवाब था

इसके अलावा मेरे लिए 2 परीक्षण मामलों को सही करने के लिए धन्यवाद

Comments

के बाद से तुम्हारा मेरी जावा जवाब से प्रेरित है, आप बदलना चाहिए r=0<iकरने के लिए r=i%2, परीक्षण के मामले के बाद से [1,-1,1]और [-1,1,-1]समय पर असफल रहे हैं। हालांकि, JS के लिए बाइट-काउंट समान है।

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

@KevinCruijssen: धन्यवाद, किया

— मुहम्मद सलमान

Answer 10

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

Ç¥├W╦╣∩T~≥▌╨c

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

Answer 11

ब्रेकीलॉग , १ 18 14 बाइट्स

~c{ḍz{ṅᵈ¹ṡ}ᵛ}ᵛ

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

सहेजे गए 4 बाइट्स @ErikTheOutgolfer की बदौलत।

व्याख्या

                    Succeed if and only if:
~c                  You can deconcatenate the input list…
  {         }ᵛ      …and verify that for each of the sublists:
   ḍ                  Split it in half
    z                 Zip the elements of each half together
     {    }ᵛ          Verify that for each couple:
      ṅᵈ¹               The first integer is the negation of the second one
         ṡ              Take the sign of the first one
                      All signs should be equal in a sublist
                    All leading signs of the sublists should be equal

Answer 12

APL (Dyalog Classic) , 48 बाइट्स

{0::1⋄0≠+/ר⍵:0⋄(~0∊⊢∨2|⍳∘⍴)2{⍺≡-⍵}/⍵⊂⍨1,2≠/ר⍵}

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