Una serie de desafíos # 1: matrices alternativas

41

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 , 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
FlipTack
fuente
¿Cuáles son los valores posibles de los elementos de la matriz?
Robert Hickman
@RobertHickman una lista de enteros positivos, dentro del tamaño int estándar de su idioma
FlipTack
oh, veo eso en la pregunta ahora. Uy y gracias.
Robert Hickman

Respuestas:

27

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.
Dennis
fuente
77
Maldita sea. ¡Y cambiar el número 2a otros números inmediatamente generaliza el desafío!
Greg Martin
3 bytes , pero Ɲno existía cuando se publicó el desafío.
caird coinheringaahing
14

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.

Mitch Schwartz
fuente
13

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

JAD
fuente
puedes ahorrarte un byte conall((a=scan())==a[1:2])
MickyT
¿Cómo ingresa los datos, como vector, lista o simplemente números individuales? He intentado escribir números individuales en la consola, pero recibo la advertencia: "Mensaje de advertencia: En el escaneo () == a [1: 2]: una longitud de objeto más larga no es un múltiplo de una longitud de objeto más corta". Aunque funciona
skan
Al escribir números únicos de hecho. Lanzará una advertencia si la longitud de entrada es impar, pero aún dará la salida correcta.
JAD
10

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]
Luis Mendo
fuente
2
Buen algoritmo! Esto haría una mala respuesta de Jelly.
Dennis
@ Dennis Gracias! Fue inspirado en parte por su enfoque Jelly
Luis Mendo
9

JavaScript (ES6), 27 bytes

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

Casos de prueba

Arnauld
fuente
8

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.

Martin Ender
fuente
7

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.

Greg Martin
fuente
7

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!

Zgarb
fuente
1
Agradable. and.(zipWith(==)=<<drop 2)Guarda un byte.
nimi
7

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.

FryAmTheEggman
fuente
1
Otra ^(\d+)?(.\d+)?(.\1\2)*(.\1)?$alternativa de 29 bytes. Esto no coincide ,1,,1.
Kritixi Lithos
1
@Kobi Gran idea, gracias! ¡Utilicé algunas de las respuestas de Kritixi (la adición de la coma al segundo grupo de captura) para guardar otro 1!
FryAmTheEggman
6

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
Mnemotécnico
fuente
es posible que desee actualizar el código en la explicación (es un
cajero automático
@ Flp.Tkc Pyth agrega implícitamente Qs al código. Los agregué en la explicación para aclarar lo que estaba sucediendo, pero en realidad no están en el código.
Mnemónico
5

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
Fatalizar
fuente
5

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
marinus
fuente
5

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

Jack munición
fuente
5

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.
  }
}
Brad Gilbert b2gills
fuente
$_[1]puede ser un byte más corto como .[1]. El cuerpo del lambda interno puede ser un byte más corto como {.[0]!=a||.[1]!=b}.
sonríe el
1
@smls No tengo idea de por qué no vi el .[1]. Tampoco !=parece funcionar si no es seguido por un espacio. Creo que $_!=3se está analizando algo así como si estuviera escrito como!( $_ = 3 )
Brad Gilbert b2gills
Ah Parece que es un error de Rakudo .
sonríe el
3

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|
+-+-+-+-+-+
Conor O'Brien
fuente
Debería poder reemplazar {.Take con $Shape.
Adám
3

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.
Mitchell Spector
fuente
1

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
Halcón
fuente
2
Llamaría a esto un duplicado de esta respuesta .
mbomb007
1

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

Azul
fuente
1

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

Anamne
fuente
Bienvenido a PPCG!
FlipTack
1

Ruby, 23 bytes

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

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
manonthemat
fuente
1

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]));
}
Dwayne Slater
fuente
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.

Grax32
fuente
0

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
    }
}
adrianmp
fuente
0

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!

rahnema1
fuente
0

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í.

NikoNyrh
fuente
0

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))
skan
fuente