Matrices en alternance

Un tableau alternatif est une liste de n'importe quelle longueur dans laquelle deux valeurs (pas nécessairement différentes) alternent. C'est-à-dire que tous les éléments à index pair sont égaux et que tous les éléments à index impairs sont égaux.

Votre tâche est d’écrire un programme ou une fonction qui, lorsqu’on lui donne une liste d’entiers positifs, sort / retourne truthys’il est alterné et falsysinon.

C'est du code-golf , donc le code le plus court (en octets) gagne!

Cas Edge:

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

Autres cas de test:

[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

Exemple

Voici un exemple contre lequel vous pouvez tester votre solution, écrite en Python 3 (non joué au golf):

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

Gelée , 4 octets

ḣ2ṁ⁼

Essayez-le en ligne!

Comment ça marche

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

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

Prend le tableau en tant que valeur d'octet dans une chaîne et génère \x00pour false et \x01pour true.

Essayez-le en ligne.

Cela maintient la structure

a b 1 c

sur la bande, où se ctrouve le caractère actuel, ble caractère précédent et ale précédent, tant que le tableau alterne. Si une incompatibilité est trouvée, le pointeur est déplacé vers la gauche de telle sorte que a, bet l' 1indicateur devient tous zéro, et cette situation perdurera jusqu'à ce que toutes les entrées soient consommées.

R, 24 23 octets

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

Lit un vecteur dans STDIN, prend les deux premiers éléments de ce vecteur et vérifie l’égalité. Si les longueurs de a[1:2]et ne correspondent pas, R effectuera une boucle a[1:2]pour correspondre à la longueur de a. Cela vous avertira de le faire, mais cela fonctionnera.

Étonnamment, cela fonctionne même pour les entrées vides, sans trop savoir pourquoi, mais je vais rouler avec.

Enregistré 1 octet grâce à @MickyT

MATL , 7 à 6 octets

2YCs&=

Pour les tableaux en alternance, cela produit une matrice non vide de vrais, ce qui est la vérité. Pour les matrices non-alternées, la matrice contient au moins un zéro et est donc faussée (voir ici ).

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Prenons [1 2 1 2]comme exemple l'entrée.

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 octets

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

Cas de test

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

Rétine , 25 octets

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

Essayez-le en ligne!

Au lieu de faire correspondre une entrée avec des valeurs alternatives (ce qui entraîne des effets de bord gênants dans une regex), je fais correspondre des entrées qui ne sont pas valides, puis j'annule le résultat.

L'avantage de faire correspondre une entrée non valide réside dans le fait qu'il s'agit d'une propriété pouvant être vérifiée localement et qu'il n'est pas nécessaire de traiter spécialement les entrées vides ou courtes: toute entrée est non valide si elle contient deux valeurs distinctes séparées par une position.

Ainsi, la première étape compte le nombre de correspondances \b(\d+),\d+,(?!\1\b)dont correspond une capture et capture une valeur, puis correspond à la valeur suivante et affirme ensuite que la troisième valeur de la séquence est différente. Cela donne zéro pour les entrées valides et positif pour les valeurs non valides.

La deuxième étape compte simplement le nombre de matches de ce ^0qui est 1si la première étape est revenu 0et 1autrement.

Mathematica, 29 octets

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

Un port de l'algorithme MATL de Luis Mendo. Fonction sans nom prenant une liste de nombres (ou même d’objets plus généraux) et renvoyant Trueou False. Teste si les sommes des éléments consécutifs sont toutes égales. Malheureusement Most, Restla liste est vide et doit donc être testée séparément.

Mathematica, 33 octets

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

Fonction sans nom prenant une liste de nombres (ou même d’objets plus généraux) et renvoyant Trueou False. La fonction Differences[#,1,2]prend les différences, non pas de paires consécutives d'entiers, mais de paires d'entiers distants de deux. Ensuite, nous vérifions simplement si la liste résultante ne contient que des zéros.

En bonus, pour un octet de plus (changez le 2en #2), nous obtenons une fonction qui entre une liste d’entiers et un autre entier positif #2, et vérifie si la liste d’entrée est le résultat de l’entrelacement de #2séquences constantes. Par exemple,

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

évalue à True.

Haskell, 27 à 26 octets

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

Cela donne une fonction anonyme qui résout le problème. L'idée est de supprimer les deux premiers nombres de la liste, de compresser la liste d'origine en utilisant l'égalité et de vérifier que le résultat ne contient que Trues. Essayez-le en ligne!

Merci à nimi pour 1 octet!

La rétine ,39 32 28 octets

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

Essayez-le en ligne!

Sauvegardé 7 octets grâce à Martin ! A sauvé 3 autres grâce à Kobi ! Et à Kritixi pour une idée pour un autre 1.

Nous sélectionnons éventuellement un nombre qui occupe la totalité de l'entrée, une paire de nombres ou une paire de nombres suivis par la même paire un nombre quelconque de fois et n'incluant éventuellement pas le deuxième nombre à la toute fin. Pourrait économiser 2 octets si l'entrée était unaire.

Pyth, 9 octets

q<*<Q2lQl

Explication

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 octets

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

Essayez-le en ligne!

Explication

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

⊢≡⍴⍴2⍴⊢

Explication:

• 2⍴⊢: remodeler le tableau d'entrée par 2
• ⍴⍴: remodeler le résultat en fonction de la taille d'origine de l'entrée, en répétant les éléments
• ⊢≡: voir si le résultat est égal à l'entrée d'origine

Cas de test:

      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 octets

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

Ceci est une expression lambda pour un Predicate< int[ ] >

Explication: initialisez le résultat à 0. Pour chaque élément, séparez OU le résultat avec la différence entre l'élément en cours et l'élément 2 est indiqué plus tôt. retourne truesi le résultat est égal à 0. Sinon, retournefalse

Perl 6 ,  49 43  42 octets

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

L'essayer

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

L'essayer

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

L'essayer

Étendu:

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

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

Essayez-le en ligne!

J, 8 octets

-:$$2&{.

Explication

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

Cas de test

   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 octets

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

Essayez-le en ligne! ou Vérifiez les cas de test. -1 octet grâce à Zgarb.

bash, 56 54 38 octets

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

Enregistrez ceci en tant que script et transmettez la liste des nombres en tant qu'arguments (pour une liste à n éléments, vous passerez n arguments). La sortie est le code de sortie: 0 (pour vrai) si la liste est en alternance et 1 (pour faux) sinon.

(Le retour de la sortie dans le code de sortie est autorisé dans les méthodes d'E / S standard PPCG.)

Cela fonctionne de manière récursive:

• Si la liste contient moins de 3 éléments, quittez avec le code retour 0;
• sinon si le 1er élément! = le 3ème élément, quittez avec le code de retour 1;
• sinon exécutez le programme de manière récursive sur la liste en supprimant le premier élément.

Python 2.7, 38 octets

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

Cas de test:

>> 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 octets, sans compétition

2<Ql{q

Essayez-le ici!

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

Autoriser le nœud de remodelage à prendre une liste ainsi qu'une chaîne

Shenzen IO (Assembler), 83 76 octets, non en concurrence

Shenzen io est un jeu de puzzle dans lequel vous pouvez coder votre code dans un langage spécial pour assembleur.

Malheureusement, vous ne pouvez utiliser que des entiers compris entre -999 et 999 en tant qu'entrées ou sorties et il est impossible de savoir si un tableau est terminé. J'ai donc supposé que le tableau était écrit sur une ROM qui s'enroule après la lecture de la dernière cellule. Cela signifie que seuls les tableaux peuvent être utilisés, ce qui explique leur non-concurrence.

Code:

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

Explication:

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

Désolé si tout ceci est déroutant, ceci est ma première réponse code-golf.

EDIT: suppression de 7 octets en remplaçant les boucles par du code run-once

Ruby, 23 octets

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

Ruby, 131 119 octets

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 aattend un tableau xet renvoie true s'il existe 0 ou 1 valeur unique pour les éléments indexés impairs et 0 ou 1 valeur unique pour les éléments indexés pairs du tableau.

Notable Byte-Safers

• utilisation de lambda sur def
• !arr[1] contre. arr.length < 2
• & contre &&

Cas de test

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 octets

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

Courir avec:

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 octets

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

Filtrez le tableau pour afficher les valeurs qui ne correspondent pas à la première valeur pour evens et à la deuxième valeur pour les probabilités. S'il n'y a pas de résultat, retourne vrai.

Japt, 7 à 6 octets

eUîU¯2

Essayez-le ou lancez tous les cas de test

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

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

Fonction anonyme qui reçoit un tableau entier et renvoie 1 si le tableau est alternatif et 0 sinon.

Programme complet avec fonction non golfée et cas de test:

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 octets

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

L'entrée est un tableau de cellules d'entiers positifs.

Essayez-le en ligne!

Clojure, 70 octets

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

Vérifie que le nombre distinct de chaque deuxième élément est égal à 1 et traite les collections vides en tant que cas particulier. Aussi essayé de nombreuses approches basées sur reduceet group-bymais pas beaucoup de chance là-bas.

Une autre option avec R: 36 octets.

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

Et je pense avoir trouvé une version beaucoup plus courte: 15 octets

all(!diff(x,2))