Matrices Alternas

Una matriz alterna es una lista de cualquier longitud en la que dos valores (no necesariamente diferentes) se alternan. Es decir, todos los elementos indexados pares son iguales, y todos los elementos indexados impares son iguales.

Su tarea es escribir un programa o función que, cuando se le da una lista de enteros positivos, genera / devuelve truthysi es alternativo o falsyno.

Este es el código de golf , por lo que gana el código más corto (en bytes).

Casos de borde:

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

Otros casos de prueba:

[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

Ejemplo

Aquí hay un ejemplo con el que puede probar su solución, escrito en Python 3 (no golfizado):

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

Jalea , 4 bytes

ḣ2ṁ⁼

Pruébalo en línea!

Cómo funciona

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

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

Toma la matriz como valores de byte en una cadena y emite \x00falso y \x01verdadero.

Pruébalo en línea.

Esto mantiene la estructura.

a b 1 c

en la cinta, donde cestá el carácter actual, bes el carácter anterior y aes el carácter anterior anterior, siempre que la matriz esté alternando. Si se encuentra una falta de coincidencia, el puntero se mueve hacia la izquierda de tal manera que a, by la 1bandera se convierte en cero, y esta situación continuará hasta que se consuma toda la entrada.

R, 24 23 bytes

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

Lee un vector en STDIN, toma los dos primeros elementos de ese vector y verifica la igualdad. Si las longitudes de a[1:2]y a no coinciden, R se repetirá a[1:2]para coincidir con la longitud de a. Dará una advertencia sobre hacerlo, pero funcionará.

Sorprendentemente, esto incluso funciona para entradas vacías, no estoy seguro de por qué, pero lo rodaré.

Guardado 1 byte gracias a @MickyT

MATL , 7 6 bytes

2YCs&=

Para matrices alternas esto genera una matriz de unidades no vacía, lo cual es cierto. Para matrices no alternas, la matriz contiene al menos un cero y, por lo tanto, es falsa (ver aquí ).

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Tomemos [1 2 1 2]como ejemplo la entrada.

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 bytes

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

Casos de prueba

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 bytes

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

Pruébalo en línea!

En lugar de hacer coincidir una entrada con valores alternos (lo que lleva a algunos efectos de borde molestos en una expresión regular), estoy haciendo coincidir las entradas que no son válidas y luego niego el resultado después.

El beneficio de hacer coincidir una entrada no válida es que esta es una propiedad que se puede verificar localmente, y no necesita tratar especialmente la entrada vacía o corta: cualquier entrada es inválida si contiene dos valores distintos que están separados por una posición.

Entonces, la primera etapa cuenta el número de coincidencias de las \b(\d+),\d+,(?!\1\b)cuales coincide y captura un valor, luego coincide con el siguiente valor y luego afirma que el tercer valor en secuencia es diferente. Esto da cero para entradas válidas y algo positivo para valores no válidos.

La segunda etapa simplemente cuenta el número de coincidencias de ^0que es 1si la primera etapa volvió 0y 1lo contrario.

Mathematica, 29 bytes

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

Un puerto del algoritmo MATL de Luis Mendo. Función sin nombre que toma una lista de números (o incluso objetos más generales) y devuelve Trueo False. Comprueba si las sumas de elementos consecutivos son todas iguales. Lamentablemente Mosty Restahogarse en la lista vacía, por lo que debe probarse por separado.

Mathematica, 33 bytes

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

Función sin nombre que toma una lista de números (o incluso objetos más generales) y devuelve Trueo False. La función Differences[#,1,2]toma las diferencias, no de pares consecutivos de enteros, sino de pares de enteros a una distancia de dos. Luego, solo verificamos si la lista resultante no tiene más que ceros.

Como beneficio adicional, para un byte más (cambie el 2a #2), obtenemos una función que ingresa una lista de enteros y otro entero positivo #2, y verifica si la lista de entrada es el resultado de entrelazar #2secuencias constantes periódicamente entre sí. Por ejemplo,

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

evalúa a True.

Haskell, 27 26 bytes

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

Esto se evalúa como una función anónima que resuelve el desafío. La idea es eliminar los dos primeros números de la lista, comprimir con la lista original usando igualdad y verificar que el resultado solo contenga Trues. Pruébalo en línea!

Gracias a nimi por 1 byte!

retina ,39 32 28 bytes

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

Pruébalo en línea!

¡Guardado 7 bytes gracias a Martin ! ¡Salvé otros 3 gracias a Kobi ! Y a Kritixi por una idea para otro 1.

Opcionalmente, hacemos coincidir un número que ocupa la entrada completa, cualquier par de números, o cualquier par de números, seguido del mismo par cualquier número de veces y, opcionalmente, no incluye el segundo número al final. Podría guardar 2 bytes si la entrada fuera unaria.

Pyth, 9 bytes

q<*<Q2lQl

Explicación

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 bytes

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

Pruébalo en línea!

Explicación

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

⊢≡⍴⍴2⍴⊢

Explicación:

• 2⍴⊢: reforma la matriz de entrada en 2
• ⍴⍴: da nueva forma al resultado por el tamaño original de la entrada, repitiendo elementos
• ⊢≡: ver si el resultado de eso es igual a la entrada original

Casos de prueba:

      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 bytes

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

Esta es una expresión lambda para un Predicate< int[ ] >

Explicación: inicialice el resultado a 0. Para cada elemento, Biteise O el resultado con la diferencia entre el elemento actual y el elemento 2 indica anteriormente. devolver truesi el resultado es igual a 0. De lo contrario, devolverfalse

Perl 6 ,  49 43  42 bytes

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

Intentalo

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

Intentalo

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

Intentalo

Expandido:

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

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

Pruébalo en línea!

J, 8 bytes

-:$$2&{.

Explicación

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

Casos de prueba

   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 bytes

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

Pruébalo en línea! o Verificar los casos de prueba. -1 byte gracias a Zgarb.

bash, 56 54 38 bytes

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

Guarde esto como una secuencia de comandos y pase la lista de números como argumentos (para una lista de n elementos, pasará n argumentos). La salida es el código de salida: 0 (para verdadero) si la lista está alternando, y 1 (para falso) de lo contrario.

(La devolución de salida en el código de salida está permitida en los métodos de E / S estándar PPCG).

Esto funciona de forma recursiva:

• Si la lista tiene menos de 3 elementos, salga con el código de retorno 0;
• si no es el primer elemento! = el tercer elemento, salga con el código de retorno 1;
• de lo contrario, ejecute el programa recursivamente en la lista con el primer elemento eliminado.

Python 2.7, 38 bytes

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

Casos de prueba:

>> 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 bytes, sin competencia

2<Ql{q

Pruébalo aquí!

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

Permitir que el nodo de remodelación tome una lista y una cadena

Shenzen IO (ensamblador), 83 76 bytes, sin competencia

Shenzen io es un juego de rompecabezas donde puedes codificar tu código en un lenguaje ensamblador especial.

Desafortunadamente, solo puede usar enteros entre -999 y 999 como entradas o salidas, y no hay forma de saber si una matriz ha terminado. Así que supuse que la matriz se escribió en una ROM que se envuelve después de leer la última celda. Esto significa que solo se pueden usar matrices, lo cual es la razón por la que no es compatible.

Código:

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

Explicación:

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

Lo siento si algo de esto es confuso, esta es mi primera respuesta de código de golf.

EDITAR: eliminó 7 bytes reemplazando bucles por código de ejecución única

Ruby, 23 bytes

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

Rubí, 131 119 bytes

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 aespera una matriz xy devuelve verdadero si hay 0 o 1 valores únicos para los elementos indexados impares y 0 o 1 valores únicos para los elementos indexados pares en la matriz.

Byte-safers notables

• uso de lambda sobre def
• !arr[1] vs. arr.length < 2
• & vs &&

Casos de prueba

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 bytes

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

Corre con:

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 bytes

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

Filtrar matriz para mostrar valores que no coinciden con el primer valor para pares y el segundo valor para probabilidades. Si no hay ningún resultado, devuelve verdadero.

Japt, 7 6 bytes

eUîU¯2

Pruébalo o ejecuta todos los casos de prueba

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

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

Función anónima que recibe una matriz entera y devuelve 1 si la matriz es alterna y 0 en caso contrario.

Programa completo con función no protegida y casos de prueba:

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

Octava, 51 bytes

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

La entrada es un conjunto de celdas de enteros positivos.

Pruébalo en línea!

Clojure, 70 bytes

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

Comprueba que el recuento distintivo de cada segundo elemento es 1, y maneja colecciones vacías como un caso especial. También probé muchos enfoques basados ​​en reducey group-byno mucha suerte allí.

Otra opción con R: 36 bytes.

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

Y creo que he encontrado una versión mucho más corta: 15 bytes

all(!diff(x,2))