चुनौतियां # 1 की एक सरणी: वैकल्पिक ऐरे

Question

वैकल्पिक ऐरे

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

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो जब सकारात्मक पूर्णांकों की सूची देता है, तो आउटपुट / रिटर्न truthyयदि यह वैकल्पिक है और falsyअन्यथा।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है!

एज मामले:

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

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

[1,2,1,2]      -> True
[3,4,3]        -> True
[10,5,10,5,10] -> True
[10,11]        -> True
[9,9,9,9,9]    -> True

[5,4,3,5,4,3]   -> False
[3,2,1,2,1,2]   -> False
[1,2,1,2,1,1,2] -> False
[2,2,3,3]       -> False
[2,3,3,2]       -> False

उदाहरण

यहाँ एक उदाहरण है जिसके खिलाफ आप अपने समाधान का परीक्षण कर सकते हैं, जिसे पायथन 3 में लिखा गया है (गोल्फ नहीं):

def is_alternating(array):
    for i in range(len(array)):
        if array[i] != array[i%2]:
            return False
    return True

Comments

सरणी के तत्वों के संभावित मूल्य क्या हैं?

— रॉबर्ट हिकमैन

— @RobertHickman

ओह, मुझे लगता है कि अब सवाल में। उफ़ और धन्यवाद।

— रॉबर्ट हिकमैन

Answer 1

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

ḣ2ṁ⁼

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

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

ḣ2ṁ⁼  Main link. Argument: A (array)

ḣ2    Head 2; truncate A after its second element. If A has two or less elements,
      this returns A itself.
  ṁ   Mold; cyclically repeat the elements of the previous result to create an
      array that has the same shape/length as A.
   ⁼  Test the result for equality with A.

Comments

अरे नहीं। और 2अन्य नंबरों को बदलना तुरंत चुनौती को सामान्य करता है!

— ग्रेग मार्टिन

3 बाइट्स , लेकिन Ɲचुनौती मौजूद होने पर मौजूद नहीं थी।

— caird coinheringaahing

Answer 2

ब्रेनफक, 34 बाइट्स

,>,>+>,
[
  [<+<<->>>-]
  +<[-<<]
  >[>]
  ,
]
<.

सरणी को एक स्ट्रिंग में बाइट मान के रूप में लेता है, और \x00असत्य के लिए और \x01सत्य के लिए आउटपुट करता है।

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

यह संरचना को बनाए रखता है

a b 1 c

टेप पर, जहां cवर्तमान वर्ण bहै, पिछला वर्ण है, और aपिछला पिछला वर्ण है, जब तक कि सरणी वैकल्पिक है। एक बेमेल पाया जाता है, सूचक बाईं ऐसे में ले जाया जाता है कि a, b, और 1झंडा सब शून्य हो जाते हैं, और जब तक सभी इनपुट सेवन किया जाता है इस स्थिति जारी रहेगा।

Answer 3

आर, 24 23 बाइट्स

all((a=scan())==a[1:2])

एक वेक्टर को STDIN में पढ़ता है, उस वेक्टर के पहले दो तत्वों को लेता है, और समानता की जांच करता है। यदि की लंबाई a[1:2]और मैच नहीं करते हैं, तो आर a[1:2]लंबाई के साथ मेल खाएगा। यह ऐसा करने के बारे में एक चेतावनी देगा, लेकिन यह काम करेगा।

हैरानी की बात है कि यह खाली इनपुट के लिए भी काम करता है, निश्चित रूप से क्यों नहीं, लेकिन मैं इसके साथ रोल करूंगा।

@MickyT को 1 बाइट धन्यवाद दिया

Comments

आप अपने आप को एक बाइट के साथ बचा सकते हैंall((a=scan())==a[1:2])

— मिकी

आप वेक्टर, सूची या केवल एकल संख्या के रूप में डेटा कैसे इनपुट करते हैं? मैंने कंसोल पर एकल नंबर टाइप करने की कोशिश की है, लेकिन मुझे चेतावनी मिलती है: "चेतावनी संदेश: स्कैन में () == [[1: 2]: लंबी वस्तु लंबाई छोटी वस्तु लंबाई की एक बहु नहीं है"। हालांकि यह काम करता है।

— स्कैन

वास्तव में एकल नंबर लिखकर। यदि इनपुट लंबाई विषम है, तो यह चेतावनी को फेंक देगा, लेकिन यह अभी भी सही आउटपुट देगा।

— JAD

Answer 4

MATL , 7 6 बाइट्स

2YCs&=

बारी-बारी से सरणियों के लिए यह एक गैर-रिक्त मैट्रिक्स का उत्पादन करता है, जो सत्य है। गैर-वैकल्पिक सरणियों के लिए मैट्रिक्स में कम से कम एक शून्य होता है, और इस प्रकार मिथ्या है ( यहां देखें )।

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

व्याख्या

[1 2 1 2]उदाहरण इनपुट के रूप में लेते हैं ।

2YC   % Implicit input. Build matrix whose columns are overlapping blocks of 
      % length 2. If input has size less than 2 this gives an empty array
      % STACK: [1 2 1;
                2 1 2]
s     % Sum of each column. For an empty array this gives 0
      % STACK: [3 3 3]
&=    % Matrix of all pairwise equality comparisons. Implicit display
      % STACK: [1 1 1;
                1 1 1;
                1 1 1]

Comments

अच्छा एल्गोरिथ्म! यह एक मतलब जेली जवाब देना होगा।

— डेनिस

@ डेनिस धन्यवाद! यह आंशिक रूप से आपके जेली दृष्टिकोण से प्रेरित था

— लुइस मेन्डो

Answer 5

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

a=>!a.some((v,i)=>a[i&1]-v)

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

let f =

a=>!a.some((v,i)=>a[i&1]-v)

console.log(f([]));              // -> True
console.log(f([1]));             // -> True
console.log(f([1,1]));           // -> True
console.log(f([1,2,1]));         // -> True
console.log(f([1,2,1,2]));       // -> True
console.log(f([10,5,10,5,10]));  // -> True
console.log(f([10,11]));         // -> True
console.log(f([9,9,9,9,9]));     // -> True
console.log(f([5,4,3,5,4,3]));   // -> False
console.log(f([3,2,1,2,1,2]));   // -> False
console.log(f([1,2,1,2,1,1,2])); // -> False
console.log(f([2,2,3,3]));       // -> False
console.log(f([2,3,3,2]));       // -> False

Answer 6

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

M`\b(\d+),\d+,(?!\1\b)
^0

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

वैकल्पिक मानों के साथ एक इनपुट के मिलान के बजाय (जो रेगेक्स में कुछ कष्टप्रद बढ़त प्रभावों की ओर जाता है), मैं ऐसे इनपुट से मिलान कर रहा हूं जो मान्य नहीं हैं और फिर बाद में परिणाम को नकारते हैं।

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

तो पहला चरण उन मैचों की संख्या को गिनता है, \b(\d+),\d+,(?!\1\b)जो एक मूल्य से मेल खाते हैं और फिर एक मान कैप्चर करते हैं, और फिर यह मान लेते हैं कि अनुक्रम में तीसरा मान भिन्न है। यह वैध इनपुट के लिए शून्य और अमान्य मानों के लिए कुछ सकारात्मक देता है।

दूसरा चरण केवल उन मैचों की संख्या को गिनाता ^0है 1यदि पहला चरण वापस आ गया है 0और 1अन्यथा।

Answer 7

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

#=={}||Equal@@(Most@#+Rest@#)&

लुइस मेंडो के MATL एल्गोरिथ्म का एक बंदरगाह। संख्या (या और भी सामान्य वस्तुओं) की सूची लेने और लौटने Trueया False। टेस्ट कि क्या निरंतर तत्वों की रकम सभी समान हैं। दुर्भाग्य से Mostऔर Restखाली सूची पर चोक, ताकि अलग से परीक्षण किया जा सके।

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

Differences[#,1,2]~MatchQ~{0...}&

संख्या (या और भी सामान्य वस्तुओं) की सूची लेने और लौटने Trueया False। यह फंक्शन Differences[#,1,2]अंतरों को लेता है, पूर्णांक के लगातार जोड़े के नहीं , बल्कि पूर्णांक के जोड़े को दो अंतर से अलग करते हैं। फिर हम केवल यह जांचते हैं कि परिणामी सूची में शून्य के अलावा कुछ नहीं है या नहीं।

एक बोनस के रूप में, एक और बाइट के लिए (बदलने 2के लिए #2), हम एक समारोह मिलता है कि आदानों पूर्णांकों और एक अन्य पूर्णांक सकारात्मक की एक सूची #2है, और जाँच करता है कि इनपुट सूची interleaving का परिणाम है #2समय-समय पर एक-दूसरे के साथ लगातार दृश्यों। उदाहरण के लिए,

Differences[#,1,#2]~MatchQ~{0...}&[{1,2,3,4,5,1,2,3,4,5,1,2},5]

का मूल्यांकन करता है True।

Answer 8

हास्केल, 27 26 बाइट्स

and.(zipWith(==)=<<drop 2)

यह एक अनाम फ़ंक्शन का मूल्यांकन करता है जो चुनौती को हल करता है। विचार सूची से पहले दो नंबरों को छोड़ना है, समानता का उपयोग करके मूल सूची के साथ ज़िप करें, और जांचें कि परिणाम में केवल Trueएस होता है । इसे ऑनलाइन आज़माएं!

1 बाइट के लिए निम्मी को धन्यवाद!

Comments

@ Flp.Tkc यह सिर्फ एक प्रकार का संकेत की जरूरत है

— Zgarb

अच्छा लगा। and.(zipWith(==)=<<drop 2)एक बाइट बचाता है।

— नीमी

Answer 9

रेटिना ,39 32 28 बाइट्स

^(\d*)((,\d+)(,\1(\3|$))*)?$

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

मार्टिन को धन्यवाद दिया 7 बाइट्स बचाए ! एक और 3 कोबी के लिए धन्यवाद बचा लिया ! और एक और 1 के लिए एक विचार के लिए क्रिस्सी ।

हम वैकल्पिक रूप से एक संख्या से मेल खाते हैं, जो पूरे इनपुट, संख्याओं की किसी भी जोड़ी या संख्याओं के किसी भी जोड़े का अनुसरण करता है और किसी भी संख्या में किसी भी जोड़ी का चयन करता है और वैकल्पिक रूप से दूसरे नंबर को बहुत अंत में शामिल नहीं करता है। यदि इनपुट अनियंत्रित था तो 2 बाइट्स बचा सकता है।

Comments

एक और ^(\d+)?(.\d+)?(.\1\2)*(.\1)?$29 बाइट विकल्प। यह मेल नहीं खाता ,1,,1।

— क्रिक्टी लिथोस

@ कोबी महान विचार, धन्यवाद! मैंने एक और 1 को बचाने के लिए कृतिका के उत्तर (दूसरे कैप्चर ग्रुप में अल्पविराम के अलावा) का उपयोग किया!

— फ्राईअमईएग्मैन

Answer 10

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

q<*<Q2lQl

व्याख्या

q<*<Q2lQlQQ   Implicitly add enough Qs to make the code run

   <Q2        Take the first two elements of the input
  *   lQ      Repeat those len(input) times
 <      lQ    Take the first len(input) elements
q         Q   Check if those are equal to the input

Comments

आप स्पष्टीकरण में कोड को अपडेट करना चाह सकते हैं (यह अलग एटीएम है)

— 22

@ Flp.Tkc Pyth ने स्पष्ट रूप Qसे कोड में s जोड़ा है । मैंने उन्हें स्पष्टीकरण में जोड़ा कि यह स्पष्ट करने के लिए कि क्या चल रहा था, लेकिन वे वास्तव में कोड में नहीं हैं।

— Mnemonic

Answer 11

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

:{~c#Tbh#Co}f#=

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

व्याख्या

:{         }f       Find all results of the predicate below
             #=     They must all be equal

  ~c#T              Deconcatenate the input into three lists
      bh#C          The middle list has two elements
        #Co         Order that couple of elements as the output

Answer 12

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

⊢≡⍴⍴2⍴⊢

स्पष्टीकरण:

• 2⍴⊢: इनपुट सरणी को 2 से फिर से खोलें
• ⍴⍴: इनपुट के मूल आकार, दोहराए जाने वाले तत्वों द्वारा परिणाम को फिर से आकार दें
• ⊢≡: देखें कि क्या इसका परिणाम मूल इनपुट के बराबर है

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

      true←(1 2 1 2)(10 5 10 5 10)(10 11)(9 9 9 9 9)
      false←(5 4 3 5 4 3)(3 2 1 2 1 2)(1 2 1 2 1 1 2)(2 2 3 3)(2 3 3 2)
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ true
1 1 1 1
      ( ⊢≡⍴⍴2⍴⊢ ) ¨ false
0 0 0 0 0

Answer 13

जावा 8, 63 बाइट्स

i->{int r=0,x=1;for(;++x<i.length;)r|=i[x]-i[x-2];return r==0;}

यह एक लंबोदर अभिव्यक्ति है a Predicate< int[ ] >

स्पष्टीकरण: परिणाम को 0. शुरू करें। प्रत्येक तत्व के लिए, Biteise या वर्तमान तत्व और तत्व 2 के बीच के अंतर के साथ परिणाम पहले संकेत देता है। वापसी trueअगर परिणाम बराबर होता है। अन्यथा वापस लौटेंfalse

Answer 14

पर्ल 6 ,  49 43  42 बाइट्स

{!grep {![==] @_},roundrobin |.rotor: 2,:partial}

कोशिश करो

{!.grep: ->\a,\b=$_[1] {sum .[0,1]Z!==a,b}}

कोशिश करो

{!.grep: ->\a,\b=.[1] {sum .[0,1]Z!==a,b}}

कोशिश करो

विस्तारित:

{
  !              # invert

  .grep:         # find any mismatches

  ->
    \a,
    \b = .[1]   # optional second parameter with default of second value from input
  {
    sum          # count up the values that don't match

    .[ 0, 1 ]    # the first two values from the input
    Z[![==]]     # zip not equal
    a, b         # the current two values under test.
  }
}

Comments

$_[1]के रूप में एक बाइट कम हो सकता है .[1]। भीतरी लंबोदर का शरीर एक बाइट के रूप में छोटा हो सकता है {.[0]!=a||.[1]!=b}।

— SMLS

@smls मुझे नहीं पता कि मैंने क्यों नहीं देखा .[1]। !=अगर यह एक स्थान का पालन नहीं करता है तो भी काम नहीं करता है। मुझे लगता है कि कुछ ऐसा $_!=3लिखा जा रहा है जैसे कि लिखा गया हो!( $_ = 3 )

— ब्रैड गिल्बर्ट b2gills

आह। ऐसा लगता है कि यह एक Rakudo बग है ।

— smls

Answer 15

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

lambda x:(x[:2]*len(x))[:len(x)]==x

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

Answer 16

जे, 8 बाइट्स

-:$$2&{.

व्याख्या

-:$$2&{.  input: (y)
    2&{.  the first two elements of y
   $      shaped like
  $       the shape of y
-:        and check if they match

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

   f =: -:$$2&{.
   ]true =: '' ; 1 ; 1 1 ; 1 2 1 ; 1 2 1 2 ; 10 5 10 5 10 ; 10 11 ; 9 9 9 9 9
++-+---+-----+-------+------------+-----+---------+
||1|1 1|1 2 1|1 2 1 2|10 5 10 5 10|10 11|9 9 9 9 9|
++-+---+-----+-------+------------+-----+---------+
   f each true
+-+-+-+-+-+-+-+-+
|1|1|1|1|1|1|1|1|
+-+-+-+-+-+-+-+-+
   ]false =: 5 4 3 5 4 3 ; 3 2 1 2 1 2 ; 1 2 1 2 1 1 2 ; 2 2 3 3 ; 2 3 3 2
+-----------+-----------+-------------+-------+-------+
|5 4 3 5 4 3|3 2 1 2 1 2|1 2 1 2 1 1 2|2 2 3 3|2 3 3 2|
+-----------+-----------+-------------+-------+-------+
   f each false
+-+-+-+-+-+
|0|0|0|0|0|
+-+-+-+-+-+

Comments

आपको {.टेक विद $शेप को बदलने में सक्षम होना चाहिए ।

— Adám

Answer 17

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

f(a:x@(_:b:_))=a==b&&f x
f a=1<3

इसे ऑनलाइन आज़माएं! या वृषण का सत्यापन करें। -1 बाइट ज़गरब को धन्यवाद।

Comments

@ डेनिस फ़ंक्शन के लिए काम करता है [], लेकिन किसी कारण के लिए ghc सही प्रकार का अनुमान नहीं लगा सकता है []। यह काम करता है अगर अन्य परीक्षण मामले के साथ एक साथ परीक्षण किया गया है, तो टेस्टकेस को सत्यापित करें

— लैकोनी

ठीक है, मैं हास्केल को अच्छी तरह से नहीं जानता।

— डेनिस

एक बाइट के साथ सहेजेंf(a:x@(_:b:_))=a==b&&f x

— ज़र्गब

Answer 18

बैश, 56 54 38 बाइट्स

[ -z $3 ]||((($1==$3))&&(shift;$0 $*))

इसे एक स्क्रिप्ट के रूप में सहेजें, और तर्कों के रूप में संख्याओं की सूची पास करें (एक n- तत्व सूची के लिए, आप n तर्क पास करेंगे)। आउटपुट एग्ज़िट कोड है: 0 (सत्य के लिए) यदि सूची वैकल्पिक है, और 1 (गलत के लिए) अन्यथा।

(बाहर निकलने के कोड में रिटर्निंग आउटपुट को पीपीसीजी मानक I / O विधियों में अनुमति दी गई है।)

यह पुनरावर्ती कार्य करता है:

• यदि सूची में 3 से कम तत्व हैं, तो रिटर्न कोड 0 से बाहर निकलें;
• और यदि 1 तत्व! = तीसरा तत्व, तो रिटर्न कोड 1 से बाहर निकलें;
• और पहले हटाए गए तत्व के साथ सूची पर पुनरावर्ती रूप से प्रोग्राम चलाएं।

Answer 19

पायथन 2.7, 38 बाइट्स

>> i=lambda a:(a[:2]*len(a))[0:len(a)]==a

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

>> print i([1,2,1,2])
>> True
>> print i([10,5,10,5,10]
>> True
>> print i([5,4,3,5,4,3])
>> False
>> print i([3,2,1,2,1,2])
>> False

Comments

मैं इसे इस उत्तर का डुप्लिकेट कहूंगा ।

— mbomb007

Answer 20

पाइके, 6 बाइट्स, नॉनकमेटिंग

2<Ql{q

यहाँ कोशिश करो!

2<     -   inp[:2]
    {  -  reshape(^, v)
  Ql   -   len(inp)
     q - ^ == inp

सूची के साथ-साथ एक स्ट्रिंग लेने के लिए नोड नोड को अनुमति दें

Answer 21

शेनजेन आईओ (असेंबलर), 83 76 बाइट्स, नॉनकंपेटिंग

शेनज़ेन io एक पहेली गेम है जहाँ आप एक विशेष असेंबलर-ईश भाषा में आपको कोड दे सकते हैं।

दुर्भाग्य से, आप केवल इनपुट या आउटपुट के रूप में 999 और 999 के बीच पूर्णांक का उपयोग कर सकते हैं, और यह बताने का कोई तरीका नहीं है कि कोई सरणी समाप्त हो गई है या नहीं। इसलिए मैंने मान लिया कि सरणी एक ROM पर लिखी गई थी जो आखिरी सेल पढ़ने के बाद चारों ओर घूमती है। इसका मतलब यह है कि केवल सरणियों का भी उपयोग किया जा सकता है, जो कि इसके गैर-कारण होने का कारण है।

कोड:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b

स्पष्टीकरण:

  # calling for x0 will cause rom to move 1 cell forward

 @ mov x0 dat # Moves value to variable dat (only run once)
 @ mov x0 acc # Moves rom position forward and moves x0 to acc           
  teq x0 dat  # See if dat equals x0  
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0 
- jmp b       # jump to b: (same case as prev line)

क्षमा करें, यदि इनमें से कोई भी भ्रमित है, तो यह मेरा पहला कोड-गोल्फ उत्तर है।

EDIT: रन-वन कोड द्वारा लूप्स को बदलकर 7 बाइट्स निकाले गए

Comments

PPCG में आपका स्वागत है!

— फ्लिपकैक

Answer 22

रूबी, 23 बाइट्स

->a{a[2..-1]==a[0..-3]}

Answer 23

रूबी, 131 119 बाइट्स

a=->x{!(x.values_at(*x.each_index.select{|i|i.even?}).uniq)[1]&!(x.values_at(*x.each_index.select{|i|i.odd?}).uniq[1])}

लैम्ब्डा aएक सरणी की अपेक्षा करता है xऔर यदि विषम अनुक्रमित तत्वों के लिए 0 या 1 अद्वितीय मान हैं और सरणी में समान अनुक्रमित तत्वों के लिए 0 या 1 अनन्य मान हैं, तो यह सही है।

उल्लेखनीय बाइट-सेफ़र्स

• लैम्ब्डा का उपयोग def
• !arr[1] बनाम arr.length < 2
• & बनाम &&

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

p a[[]]
p a[[1]]
p a[[1,1]]
p a[[1,2,1]]
p a[[1,2,1,2]]
p a[[3,4,3]]
p a[[10,5,10,5,10]]
p a[[10,11]]
p a[[9,9,9,9,9]]

#false
p a[[5,4,3,5,4,3]]==false
p a[[3,2,1,2,1,2]]==false
p a[[1,2,1,2,1,1,2]]==false
p a[[2,2,3,3]]==false
p a[[2,3,3,2]]==false

Answer 24

डार्ट, 46 बाइट्स

(l){var i=0;return l.every((x)=>x==l[i++%2]);}

साथ दौड़ो:

void main() {
  var f = (l){var i=0;return l.every((x)=>x==l[i++%2]);};
  print(f([1,2,1,2,1]));
}

Answer 25

सी #, 54 बाइट्स

using System.Linq;p=>!p.Where((v,i)=>v!=p[i%2]).Any();

उन मानों को दिखाने के लिए फ़िल्टर करें जो evens के लिए पहले मूल्य और बाधाओं के लिए 2 मान से मेल नहीं खाते हैं। यदि कोई परिणाम नहीं हैं, तो सही लौटें।

Answer 26

जाप, 7 6 बाइट्स

eUîU¯2

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

           :Implicit input of array U
   U¯2     :Get the first 2 elements of U
 Uî        :Repeat that array to the length of U
e          :Test for equality with the original U

Answer 27

सी #, 66 बाइट्स

a=>{int r=1,i=0;for(;i<a.Length;)if(a[i]!=a[i++%2])r=0;return r;};

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

फुल प्रोग्राम के साथ पूरा कार्यक्रम और परीक्षण के मामले:

using System;

public class Program
{
    public static void Main()
    {
        Func<int[], int> f =
        a =>
        {
            int r = 1,  // return value. 1 is true, by default
                i = 0;  // iterator
            for ( ; i<a.Length ; )  // for each array element
                if ( a[i] != a[i++%2] ) // if the even (or odd) elements are not the same
                    r = 0;      // a falsy (0) value will be assigned to the return element
            return r;       // returning if the array is alternating or not
        };

        // test cases:
        Console.WriteLine("Edge cases (all TRUE):");
        Console.WriteLine(f(new int[]{}));      //  True
        Console.WriteLine(f(new int[]{1}));     //  True
        Console.WriteLine(f(new int[]{1,1}));   //  True
        Console.WriteLine(f(new int[]{1,2,1})); //  True

        Console.WriteLine("Some other TRUE test cases:");
        Console.WriteLine(f(new int[]{1,2,1,2}));      // True
        Console.WriteLine(f(new int[]{10,5,10,5,10})); // True
        Console.WriteLine(f(new int[]{10,11}));        // True
        Console.WriteLine(f(new int[]{9,9,9,9,9}));    // True

        Console.WriteLine("Some FALSE test cases:");
        Console.WriteLine(f(new int[]{5,4,3,5,4,3}));   // False
        Console.WriteLine(f(new int[]{3,2,1,2,1,2}));   // False
        Console.WriteLine(f(new int[]{1,2,1,2,1,1,2})); // False
        Console.WriteLine(f(new int[]{2,2,3,3}));       // False
        Console.WriteLine(f(new int[]{2,3,3,2}));       // False
    }
}

Answer 28

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

@(L)numel(L)<3||(f=@(n)isequal(L{n:2:end}))(1)&f(2)

इनपुट धनात्मक पूर्णांक का एक सेल ऐरे है।

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

Answer 29

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

(fn[c](let[n #(max(count(set(take-nth 2 %)))1)](=(n c)(n(rest c))1))))

जाँचता है कि हर 2 आइटम की अलग गिनती 1 है, और एक विशेष मामले के रूप में खाली संग्रह को संभालती है। इसके अलावा कई पर आधारित दृष्टिकोण की कोशिश की reduceऔर group-byनहीं बल्कि बहुत किस्मत वहाँ।

Answer 30

आर के साथ एक और विकल्प: 36 बाइट्स।

all(rep_len(head(x,2),length(x))==x)

और मुझे लगता है कि मुझे एक बहुत छोटा संस्करण मिला है: 15 बाइट्स

all(!diff(x,2))