อาร์เรย์สำรอง

อาร์เรย์สลับเป็นรายการยาว ๆ ในการที่สอง (ไม่จำเป็นต้องแตกต่างกัน) มีค่าสลับ กล่าวคือทุกรายการที่มีการทำดัชนีเท่ากันและรายการที่มีการทำดัชนีทั้งหมดจะเท่ากัน

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งเมื่อได้รับรายการจำนวนเต็มบวกผลลัพธ์ / ผลตอบแทน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

ตัวอย่าง

นี่คือตัวอย่างที่คุณสามารถทดสอบวิธีแก้ปัญหาของคุณเขียนใน Python 3 (ไม่ใช่กอล์ฟ):

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

เยลลี่ขนาด 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.

brainfuck, 34 ไบต์

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

รับค่าอาร์เรย์เป็นค่าไบต์ในสตริงและเอาต์พุต\x00สำหรับเท็จและ\x01เป็นจริง

ลองออนไลน์

สิ่งนี้จะรักษาโครงสร้าง

a b 1 c

บนเทปโดยที่cอักขระปัจจุบันbคืออักขระก่อนหน้าและaเป็นอักขระก่อนหน้านี้ตราบใดที่อาร์เรย์สลับกัน หากไม่ตรงกันจะพบตัวชี้ถูกย้ายไปทางซ้ายดังกล่าวว่าa, bและ1ธงกลายเป็นศูนย์และสถานการณ์นี้จะดำเนินต่อไปจนกว่าทุกการป้อนข้อมูลที่มีการบริโภค

R, 24 23 ไบต์

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

อ่านเวกเตอร์เป็น STDIN รับองค์ประกอบสององค์ประกอบแรกของเวกเตอร์นั้นและตรวจสอบความเท่าเทียมกัน หากความยาวของa[1:2]และ a ไม่ตรงกัน R จะวนซ้ำa[1:2]เพื่อจับคู่กับความยาวของ a มันจะให้คำเตือนเกี่ยวกับการทำเช่นนั้น แต่มันจะทำงาน

น่าแปลกใจว่าสิ่งนี้ใช้ได้กับอินพุตที่ว่างเปล่า แต่ไม่แน่ใจว่าทำไม แต่ฉันจะหมุนไปด้วย

บันทึก 1 ไบต์ขอบคุณ @MickyT

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]

JavaScript (ES6), 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

เรติน่า 25 ไบต์

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

ลองออนไลน์!

แทนที่จะจับคู่อินพุตด้วยค่าที่สลับกัน (ซึ่งนำไปสู่เอฟเฟกต์ขอบที่น่ารำคาญใน regex) ฉันกำลังจับคู่อินพุตที่ไม่ถูกต้องแล้วลบล้างผลลัพธ์ในภายหลัง

ประโยชน์ของการจับคู่อินพุตที่ไม่ถูกต้องคือคุณสมบัตินี้สามารถตรวจสอบได้ภายในเครื่องและไม่จำเป็นต้องจัดการอินพุตว่างหรือสั้นพิเศษ: อินพุตใด ๆ จะไม่ถูกต้องหากมีสองค่าที่แตกต่างกันซึ่งอยู่ในตำแหน่งเดียว

ดังนั้นด่านแรกจะนับจำนวนแมตช์ของ \b(\d+),\d+,(?!\1\b)ที่จับคู่และจับหนึ่งค่าจากนั้นจับคู่ค่าถัดไปจากนั้นยืนยันว่าค่าที่สามในลำดับนั้นแตกต่างกัน สิ่งนี้ให้ศูนย์สำหรับอินพุตที่ถูกต้องและสิ่งที่เป็นบวกสำหรับค่าที่ไม่ถูกต้อง

ขั้นตอนที่สองเพียงนับจำนวนการแข่งขัน^0ซึ่งเป็น1ถ้าขั้นตอนแรกกลับมา0และ1อื่น ๆ

Mathematica, 29 ไบต์

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

พอร์ตของอัลกอริทึม MATL ของ Luis Mendo ฟังก์ชั่นที่ไม่มีชื่อการรายการหมายเลข (หรือแม้กระทั่งวัตถุทั่วไปมากขึ้น) และกลับมาหรือTrue Falseทดสอบว่าผลรวมขององค์ประกอบต่อเนื่องเท่ากันหรือไม่ น่าเสียดายMostและRestทำให้หายใจไม่ออกในรายการที่ว่างดังนั้นจะต้องมีการทดสอบแยกต่างหาก

Mathematica, 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ประเมิน

Haskell, 27 26 ไบต์

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

สิ่งนี้ประเมินว่าเป็นฟังก์ชันที่ไม่ระบุตัวตน แนวคิดคือการวางตัวเลขสองตัวแรกจากรายการซิปด้วยรายการดั้งเดิมโดยใช้ความเท่าเทียมกันและตรวจสอบว่าผลลัพธ์มีเพียงTrues ลองออนไลน์!

ขอบคุณ nimi สำหรับ 1 ไบต์!

จอตาตา39 32 28 ไบต์

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

ลองออนไลน์!

บันทึกไปแล้ว 7 ไบต์ขอบคุณMartin ! บันทึกอีก 3 รายการขอบคุณKobi ! และเพื่อKritixiสำหรับความคิดอีก 1

เราเลือกที่จะจับคู่หมายเลขที่มีทั้งอินพุตคู่ของตัวเลขใด ๆ หรือคู่ของตัวเลขใด ๆ ตามด้วยคู่เดียวกันจำนวนเท่า ๆ กันและเลือกที่จะไม่รวมหมายเลขที่สองในตอนท้าย สามารถบันทึก 2 ไบต์หากอินพุตอยู่ในสภาวะไม่พร้อมกัน

Pyth, 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

Brachylogขนาด 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

APL, 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

Java 8, 63 ไบต์

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

นี่คือการแสดงออกแลมบ์ดาสำหรับ Predicate< int[ ] >

คำอธิบาย: เริ่มต้นผลลัพธ์เป็น 0 สำหรับแต่ละองค์ประกอบ Biteise หรือผลลัพธ์ที่มีความแตกต่างระหว่างองค์ประกอบปัจจุบันและองค์ประกอบ 2 บ่งชี้ก่อนหน้านี้ ส่งคืนtrueถ้าผลลัพธ์เท่ากับ 0 มิฉะนั้นส่งคืนfalse

Perl 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.
  }
}

Python 2 , 35 ไบต์

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

ลองออนไลน์!

J, 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|
+-+-+-+-+-+

Haskell , 33 32 ไบต์

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

ลองออนไลน์! หรือตรวจสอบ testcases -1 ไบต์ขอบคุณ Zgarb

bash, 56 54 38 ไบต์

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

บันทึกเป็นสคริปต์และส่งผ่านรายการตัวเลขเป็นอาร์กิวเมนต์ (สำหรับรายการองค์ประกอบ n คุณจะผ่านอาร์กิวเมนต์ n) เอาท์พุทเป็นรหัสทางออก: 0 (สำหรับจริง) ถ้ารายการจะสลับและ 1 (สำหรับเท็จ) เป็นอย่างอื่น

(อนุญาตให้ส่งคืนเอาต์พุตในโค้ดออกได้ในวิธีการ I / O มาตรฐาน PPCG)

งานนี้ซ้ำ:

• หากรายการมีองค์ประกอบน้อยกว่า 3 ให้ออกด้วยรหัสส่งคืน 0;
• อื่นถ้าองค์ประกอบที่ 1! = องค์ประกอบที่ 3 แล้วออกด้วยรหัสส่งคืน 1;
• มิฉะนั้นให้เรียกใช้โปรแกรมซ้ำในรายการโดยลบองค์ประกอบแรกออก

Python 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

Pyke, 6 ไบต์, ไม่ใช่การแข่งขัน

2<Ql{q

ลองที่นี่!

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

อนุญาตให้โหนดก่อร่างใหม่เพื่อทำรายการเช่นเดียวกับสตริง

Shenzen IO (แอสเซมเบลอร์), 83 76 ไบต์, ไม่ใช่การเข้ารหัส

Shenzen 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)

ขออภัยหากสิ่งใดทำให้เกิดความสับสนนี่เป็นคำตอบรหัสสนามกอล์ฟครั้งแรกของฉัน

แก้ไข: ลบออก 7 ไบต์โดยแทนที่ลูปด้วยรหัสเรียกใช้ครั้งเดียว

Ruby, 23 ไบต์

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

Ruby, 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
• & VS &&

กรณีทดสอบ

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

โผ 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]));
}

C #, 54 ไบต์

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

กรองอาร์เรย์เพื่อแสดงค่าที่ไม่ตรงกับค่าแรกของเหตุการณ์และค่าที่ 2 สำหรับอัตราต่อรอง หากไม่มีผลลัพธ์ใด ๆ ให้ส่งคืนจริง

Japt, 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

C #, 66 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อซึ่งได้รับอาร์เรย์จำนวนเต็มและส่งกลับ 1 ถ้าอาร์เรย์สลับกันและ 0 เป็นอย่างอื่น

โปรแกรมเต็มรูปแบบพร้อมฟังก์ชั่น ungolfed และกรณีทดสอบ:

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
    }
}

อ็อกเทฟ 51 ไบต์

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

อินพุตเป็นอาร์เรย์เซลล์ของจำนวนเต็มบวก

ลองออนไลน์!

Clojure 70 ไบต์

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

ตรวจสอบว่าการนับที่แตกต่างกันของทุกรายการที่ 2 คือ 1 และจัดการคอลเลกชันที่ว่างเปล่าเป็นกรณีพิเศษ นอกจากนี้ยังพยายามหลายวิธีขึ้นอยู่กับreduceและgroup-byแต่ไม่มากมีโชค

ตัวเลือกอื่นที่มี R: 36 ไบต์

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

และฉันคิดว่าฉันพบรุ่นที่สั้นกว่ามาก: 15 ไบต์

all(!diff(x,2))