Matrizes alternadas

Uma matriz alternada é uma lista de qualquer comprimento em que dois valores (não necessariamente diferentes) sejam alternados. Ou seja, todos os itens indexados pares são iguais e todos os itens indexados ímpares são iguais.

Sua tarefa é escrever um programa ou função que, quando recebida uma lista de números inteiros positivos, gera / retorna, truthyse for alternado ou falsynão.

Isso é código-golfe , então o código mais curto (em bytes) vence!

Casos de borda:

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

Outros casos de teste:

[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

Exemplo

Aqui está um exemplo no qual você pode testar sua solução, escrita em Python 3 (sem jogar golfe):

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

Gelatina , 4 bytes

ḣ2ṁ⁼

Experimente online!

Como 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

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

Pega a matriz como valores de bytes em uma string e gera \x00como false e \x01true.

Experimente online.

Isso mantém a estrutura

a b 1 c

na fita, onde cestá o caractere atual, bé o caractere anterior e aé o caractere anterior anterior, desde que a matriz esteja alternada. Se uma incompatibilidade for encontrada, o ponteiro será movido para a esquerda, de modo que a,, be o 1sinalizador se tornem zero, e essa situação continuará até que toda a entrada seja consumida.

R, 24 23 bytes

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

Lê um vetor no STDIN, pega os dois primeiros elementos desse vetor e verifica a igualdade. Se os comprimentos de a[1:2]e a não corresponderem, R passará a[1:2]para corresponder ao comprimento de a. Dará um aviso sobre isso, mas funcionará.

Surpreendentemente, isso funciona mesmo para entradas vazias, não sei por que, mas vou rolar com ela.

Guardado 1 byte graças a @MickyT

MATL , 7 6 bytes

2YCs&=

Para matrizes alternadas, isso gera uma matriz não vazia de unidades, que é verdadeira. Para matrizes não alternadas, a matriz contém pelo menos um zero e, portanto, é falsa (veja aqui ).

Experimente online! Ou verifique todos os casos de teste .

Explicação

Vamos dar [1 2 1 2]como exemplo de 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 teste

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

Experimente online!

Em vez de combinar uma entrada com valores alternativos (o que leva a alguns efeitos irritantes de borda em uma regex), estou combinando entradas que não são válidas e depois negamos o resultado posteriormente.

O benefício de corresponder uma entrada inválida é que esta é uma propriedade que pode ser verificada localmente e não precisa tratar especialmente entradas vazias ou curtas: qualquer entrada é inválida se contiver dois valores distintos que estão separados por uma posição.

Portanto, o primeiro estágio conta o número de correspondências \b(\d+),\d+,(?!\1\b)correspondentes e captura um valor, depois corresponde ao próximo valor e, em seguida, afirma que o terceiro valor na sequência é diferente. Isso dá zero para entradas válidas e algo positivo para valores inválidos.

A segunda fase simplesmente conta o número de jogos de ^0que é 1, se a primeira etapa devolvido 0e 1de outra forma.

Mathematica, 29 bytes

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

Uma porta do algoritmo MATL de Luis Mendo. Função sem nome, levando uma lista de números (ou objetos ainda mais gerais) e retornando Trueou False. Testa se somas de elementos consecutivos são iguais. Infelizmente Moste Restengasgar com a lista vazia, de modo que tem de ser testados separadamente.

Mathematica, 33 bytes

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

Função sem nome, levando uma lista de números (ou objetos ainda mais gerais) e retornando Trueou False. A função Differences[#,1,2]pega as diferenças, não de pares consecutivos de números inteiros, mas pares de números inteiros na distância dois. Depois, apenas verificamos se a lista resultante não possui nada além de zeros.

Como bônus, para mais um byte (altere 2para #2), obtemos uma função que insere uma lista de números inteiros e outro número inteiro positivo #2e verifica se a lista de entrada é o resultado da intercalação #2periódica de seqüências constantes entre si. Por exemplo,

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

avalia como True.

Haskell, 27 26 bytes

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

Isso avalia uma função anônima que resolve o desafio. A idéia é soltar os dois primeiros números da lista, compactar com a lista original usando igualdade e verificar se o resultado contém apenas Trues. Experimente online!

Obrigado a nimi por 1 byte!

Retina ,39. 32. 28 bytes

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

Experimente online!

Economizou 7 bytes graças a Martin ! Guardado mais 3 agradecimentos a Kobi ! E a Kritixi por uma idéia para outra 1.

Opcionalmente, combinamos um número que ocupa toda a entrada, qualquer par de números ou qualquer par de números seguido pelo mesmo par várias vezes e, opcionalmente, não incluindo o segundo número no final. Pode salvar 2 bytes se a entrada estiver unária.

Pitão, 9 bytes

q<*<Q2lQl

Explicação

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

Braquilog , 15 bytes

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

Experimente online!

Explicação

:{         }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⍴⊢

Explicação:

• 2⍴⊢: remodelar a matriz de entrada por 2
• ⍴⍴: remodelar o resultado pelo tamanho original da entrada, repetindo elementos
• ⊢≡: veja se o resultado é igual à entrada original

Casos de teste:

      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 é uma expressão lambda para um Predicate< int[ ] >

Explicação: inicialize o resultado como 0. Para cada elemento, Biteise OU o resultado com a diferença entre o elemento atual e o elemento 2 indica anteriormente. retorne truese o resultado for igual a 0. Caso contrário, retornefalse

Perl 6 ,  49 43  42 bytes

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

Tente

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

Tente

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

Tente

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

Experimente online!

J, 8 bytes

-:$$2&{.

Explicação

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

Casos de teste

   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

Experimente online! ou Verifique as caixas de teste. -1 byte graças ao Zgarb.

bash, 56 54 38 bytes

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

Salve isso como um script e passe a lista de números como argumentos (para uma lista de n elementos, você passará n argumentos). A saída é o código de saída: 0 (para true) se a lista estiver alternada e 1 (para false) caso contrário.

(A saída de retorno no código de saída é permitida nos métodos de E / S padrão do PPCG.)

Isso funciona recursivamente:

• Se a lista tiver menos de 3 elementos, saia com o código de retorno 0;
• caso contrário, se o primeiro elemento! = o terceiro elemento, saia com o código de retorno 1;
• caso contrário, execute o programa recursivamente na lista com o primeiro elemento removido.

Python 2.7, 38 bytes

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

Casos de teste:

>> 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, não-competitivo

2<Ql{q

Experimente aqui!

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

Permitir remodelar o nó para obter uma lista e uma sequência

Shenzen IO (Assembler), 83 76 bytes, não-concorrente

Shenzen io é um jogo de quebra-cabeça em que você pode codificar em uma linguagem montadora-ish especial.

Infelizmente, você só pode usar números inteiros entre -999 e 999 como entradas ou saídas, e não há como saber se uma matriz terminou. Então eu assumi que o array foi escrito em uma ROM que envolve depois de ler a última célula. Isso significa que apenas matrizes podem ser usadas, razão pela qual não são concorrentes.

Código:

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

Explicação:

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

Desculpe se isso é confuso, esta é minha primeira resposta ao código-golfe.

Edição: removido 7 bytes, substituindo loops pelo código de execução única

Ruby, 23 bytes

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

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

O Lambda aespera uma matriz xe retorna true se houver 0 ou 1 valores exclusivos para os elementos indexados ímpares e 0 ou 1 valores exclusivos para os elementos indexados pares na matriz.

Notte byte-safers

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

Casos de teste

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

Dardo, 46 ​​bytes

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

Correr com:

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();

Filtre a matriz para mostrar valores que não correspondem ao primeiro valor para pares e o segundo valor para probabilidades. Se não houver nenhum resultado, retorne true.

Japonês, 7 6 bytes

eUîU¯2

Experimente ou execute todos os casos de teste

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

Função anônima que recebe uma matriz inteira e retorna 1 se a matriz estiver alternada e 0 caso contrário.

Programa completo com funções não testadas e casos de teste:

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

Oitava, 51 bytes

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

Input é uma matriz de células de números inteiros positivos.

Experimente online!

Clojure, 70 bytes

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

Verifica se a contagem distinta de cada segundo item é 1 e lida com coleções vazias como um caso especial. Também tentei muitas abordagens baseadas em reducee group-bymas não muito sorte lá.

Outra opção com R: 36 bytes.

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

E acho que encontrei uma versão muito mais curta: 15 bytes

all(!diff(x,2))