Alternatif Diziler

Bir alternatif dizisi iki (farklı olması zorunlu değildir) değerleri değişken olan her hangi bir uzunlukta bir listesidir. Diğer bir deyişle, tüm çift dizinlenmiş öğeler eşittir ve tüm tek dizinlenmiş öğeler eşittir.

Göreviniz, pozitif tamsayıların bir listesi verildiğinde truthy, değişken ve falsyaksi takdirde çıktı veren / dönen bir program veya işlev yazmaktır .

Bu kod-golf , bu yüzden en kısa kod (bayt cinsinden) kazanır!

Kenar Kılıfları:

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

Diğer Test Durumları:

[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

Örnek

Çözümünüzü Python 3 ile yazılmış (golf oynamayan) karşı test edebileceğiniz bir örnek:

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

Jöle , 4 bayt

ḣ2ṁ⁼

Çevrimiçi deneyin!

Nasıl çalışır

ḣ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 bayt

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

Diziyi bir dizedeki bayt değerleri olarak alır ve \x00false ve \x01true için çıktılar .

Çevrimiçi deneyin.

Bu yapıyı korur

a b 1 c

kasette, cgeçerli karakter bolan önceki karakterdir ve önceki değişkendir, önceki karakterdir a. Bir uyumsuzluk bulunursa, işaretçi o sol böyle taşınır a, bve 1bayrak her sıfır hale gelir ve tüm giriş tükenene kadar bu durum devam edecektir.

R, 24 23 bayt

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

Bir vektörü STDIN'e okur, o vektörün ilk iki öğesini alır ve eşitliği kontrol eder. Uzunlukları a[1:2]ve a eşleşmiyorsa, R, a'nın a[1:2]uzunluğuna uyacak şekilde dönecektir . Bunu yapmak için bir uyarı verecek, ancak işe yarayacak.

Şaşırtıcı bir şekilde bu, boş girdi için bile işe yarıyor, neden olduğundan emin değilim, ancak bununla başlayacağım.

@MickyT sayesinde 1 bayt kaydedildi

MATL , 7 6 bayt

2YCs&=

Alternatif diziler için bu, boş olanların boş olmayan bir matrisini çıkarır; Alternatif olmayan diziler için matris en az bir sıfır içerir ve bu nedenle sahtedir ( buraya bakın ).

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

En alalım [1 2 1 2]örnek girdi olarak.

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 bayt

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

Test durumları

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

Retina , 25 bayt

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

Çevrimiçi deneyin!

Bir girişi alternatif değerlerle eşleştirmek yerine (bu, bir regex'te rahatsız edici kenar etkilerine yol açar), geçerli olmayan girişleri eşleştirir ve sonra sonucu olumsuzlar.

Geçersiz bir girişi eşleştirmenin yararı, bunun bir özellik olarak yerel olarak kontrol edilebileceği ve boş veya kısa girişi özel olarak ele alması gerekmediğidir: herhangi bir giriş, ayrı bir konumdaki iki ayrı değer içeriyorsa geçersizdir.

Böylece, ilk aşama \b(\d+),\d+,(?!\1\b)bir değeri yakalayan ve yakalayan eşleşme sayısını sayar , ardından bir sonraki değeri eşleştirir ve ardından sıradaki üçüncü değerin farklı olduğunu iddia eder. Bu, geçerli girişler için sıfır ve geçersiz değerler için pozitif bir şey verir.

İkinci aşama basitçe ait eşleşme sayısını sayar ^0hangi 1ilk aşama döndü eğer 0ve 1aksi.

Mathematica, 29 bayt

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

Luis Mendo'nun MATL algoritmasının bir limanı. Adsız işlev, bir sayılar listesi (veya daha genel nesneler) alarak ve Trueveya False. Ardışık elemanların toplamının hepsinin eşit olup olmadığını test eder. Ne yazık ki Mostve Restboş listede boğulma, böylece ayrı ayrı test edilmelidir.

Mathematica, 33 bayt

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

Adsız işlev, bir sayılar listesi (veya daha genel nesneler) alarak ve Trueveya False. İşlev birbirini takip eden tamsayı çiftleri Differences[#,1,2]değil, iki mesafedeki tamsayı çiftleri arasındaki farkları alır . Sonra sadece sonuçta ortaya çıkan listenin içinde sıfırdan başka bir şey olup olmadığını kontrol ederiz.

Ek olarak, bir tane daha bayt için (değiştirmek 2için #2), bir işlev olsun giriş tamsayı ve bir pozitif tamsayı bir liste #2girişi listesi serpiştirme sonucu olup olmadığını ve kontroller #2periyodik birbirleriyle sabit dizileri. Örneğin,

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

olarak değerlendirir True.

Haskell, 27 26 bayt

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

Bu, sorunu çözen isimsiz bir işlevi değerlendirir. Buradaki fikir listedeki ilk iki sayıyı bırakmak, eşitliği kullanarak orijinal listeyi sıkıştırmak ve sonucun sadece Trues içerdiğini kontrol etmektir . Çevrimiçi deneyin!

1 bayt için nimi için teşekkürler!

retina ,39 32 28 bayt

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

Çevrimiçi deneyin!

Martin sayesinde 7 byte kurtarıldı ! Başka 3 sayesinde Kaydedilen Kobi ! Ve başka bir fikir için Kritixi'ye 1.

İsteğe bağlı olarak, girişin tamamını, herhangi bir sayı çiftini veya aynı çiftin ardından gelen herhangi bir sayı çiftini ve isteğe bağlı olarak en sondaki ikinci sayıyı içermeyen herhangi bir sayı çiftini eşleştiren bir sayı ile eşleşiriz. Giriş bir arada ise 2 bayt kaydedilebilir.

Pyth, 9 bayt

q<*<Q2lQl

açıklama

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 bayt

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

Çevrimiçi deneyin!

açıklama

:{         }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 bayt

⊢≡⍴⍴2⍴⊢

Açıklama:

• 2⍴⊢: giriş dizisini 2 ile yeniden şekillendir
• ⍴⍴: sonucu, girdilerin orijinal boyutuna göre tekrar şekillendirir, elemanları tekrar eder
• ⊢≡: Bunun sonucunun orijinal girdiyle aynı olup olmadığına bakınız.

Test durumları:

      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 bayt

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

Bu, bir lambda ifadesidir. Predicate< int[ ] >

Açıklama: sonucu 0 olarak ilklendirin. Her eleman için, Biteise VEYA geçerli eleman ile eleman 2 arasındaki fark ile sonucu daha önce gösterir. return truesonuç 0'a eşittir Aksi takdirde iadefalse

Perl 6 ,  49 43  42 bayt

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

Dene

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

Dene

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

Dene

Expanded:

{
  !              # 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 bayt

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

Çevrimiçi deneyin!

J, 8 bayt

-:$$2&{.

açıklama

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

Test durumları

   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 bayt

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

Çevrimiçi deneyin! veya Testcas'ları doğrulayın. Zgarb sayesinde -1 bayt.

bash, 56 54 38 bayt

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

Bunu bir komut dosyası olarak kaydedin ve sayıların listesini argüman olarak iletin (bir n-eleman listesi için n argümanını ileteceksiniz). Çıktı, çıkış kodudur: liste değişiyorsa 0 (doğru) ve aksi halde 1 (yanlış için).

(PPCG standart I / O yöntemlerinde çıkış kodunda geri dönüşe izin verilir.)

Bu özyinelemeli çalışır:

• Listede 3 öğeden daha az öğe varsa, dönüş kodu 0 ile çıkın;
• Aksi halde, 1. element! = 3. element ise, dönüş kodu 1 ile çıkın;
• Başka bir program kaldırılmışsa listedeki ilk eleman kaldırılmış olarak programı tekrar tekrar çalıştırın.

Python 2.7, 38 bayt

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

Test Durumları:

>> 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 bayt, rekabetçi olmayan

2<Ql{q

Burada dene!

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

Yeniden şekillendirme düğümünün bir dizenin yanı sıra bir liste almasına izin ver

Shenzen IO (Assembler), 83 76 bayt, rekabetçi olmayan

Shenzen io size özel assembler-ish dilinde kod yazabileceğiniz bir bulmaca oyunudur.

Ne yazık ki, sadece -999 ve 999 arasındaki tamsayıları giriş veya çıkış olarak kullanabilirsiniz ve bir dizinin bittiğini söylemenin bir yolu yoktur. Bu yüzden dizinin, son hücreyi okuduktan sonra etrafına sarılmış bir ROM üzerine yazılmış olduğunu varsaydım. Bu, sadece dizilerin bile kullanılabileceği anlamına gelir, bu da rekabet etmemesinin sebebidir.

Kod:

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

Açıklama:

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

Bunlardan herhangi biri kafa karıştırıcıysa üzgünüm, bu benim ilk kod-golf cevabım.

EDIT: döngüleri run-once koduyla değiştirerek 7 bayt kaldırıldı

Ruby, 23 bayt

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

Ruby, 131 119 bayt

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

Lambda abir dizi bekler xve tek indeksli elemanlar için 0 veya 1 benzersiz değer ve dizideki çift indeksli elemanlar için 0 veya 1 benzersiz değer varsa doğru döndürür.

Önemli byte-güvenli

• lambda kullanımı def
• !arr[1] vs. arr.length < 2
• & vs &&

Test durumları

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

Dart, 46 bayt

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

Çalıştır:

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 bayt

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

Dizilerin, ilkler ve ilkler için 2. değerle eşleşmeyen değerleri göstermesi için filtre dizisi. Herhangi bir sonuç yoksa, doğru dönün.

Japt, 7 6 bayt

eUîU¯2

Deneyin veya tüm test durumlarını çalıştırın

           :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 bayt

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

Bir tamsayı dizisi alan ve dizi değişiyorsa 1, aksi takdirde 0 döndüren adsız işlev.

Ungolfed fonksiyon ve test vakaları ile tam program:

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

Octave, 51 bayt

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

Giriş, pozitif tam sayıların hücre dizisidir.

Çevrimiçi deneyin!

Clojure, 70 bayt

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

Her 2. maddenin ayrı sayısının 1 olduğunu kontrol eder ve boş koleksiyonları özel bir durum olarak ele alır. Ayrıca dayalı birçok yaklaşımlar denenmiş reduceve group-byama fazla şans var.

R ile başka bir seçenek: 36 bayt.

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

Ve sanırım çok daha kısa bir sürüm buldum: 15 byte

all(!diff(x,2))