Array alternati

Un array alternato è un elenco di qualsiasi lunghezza in cui si alternano due valori (non necessariamente diversi). Vale a dire, tutti gli elementi con indicizzazione pari sono uguali e tutti gli elementi con indicizzazione dispari sono uguali.

Il tuo compito è quello di scrivere un programma o una funzione che, quando viene fornito un elenco di numeri interi positivi, restituisce / restituisce truthyse si alterna e falsyaltrimenti.

Questo è code-golf , quindi vince il codice più breve (in byte)!

Custodie per bordi:

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

Altri casi di 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

Esempio

Ecco un esempio per cui puoi testare la tua soluzione, scritto in Python 3 (non giocato a golf):

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

Gelatina , 4 byte

ḣ2ṁ⁼

Provalo online!

Come funziona

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

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

Prende l'array come valori di byte in una stringa e genera output \x00per false e \x01per true.

Provalo online.

Questo mantiene la struttura

a b 1 c

sul nastro, dove si ctrova il carattere corrente, bè il carattere precedente ed aè il carattere precedente precedente, a condizione che l'array si alterni. Se viene rilevata una mancata corrispondenza, il puntatore viene spostato a sinistra in modo tale che a, be il 1flag diventa tutto zero, e questa situazione continuerà fino a quando tutto l'input viene consumato.

R, 24 23 byte

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

Legge un vettore in STDIN, prende i primi due elementi di quel vettore e verifica l'uguaglianza. Se le lunghezze di a[1:2]e a non corrispondono, R scorrerà in sequenza a[1:2]per corrispondere alla lunghezza di a. Darà un avvertimento in merito, ma funzionerà.

Sorprendentemente, questo funziona anche con input vuoti, non so perché, ma ci proverò.

Salvato 1 byte grazie a @MickyT

MATL , 7 6 byte

2YCs&=

Per le matrici alternate questo produce una matrice non vuota di quelli, il che è vero. Per le matrici non alternate la matrice contiene almeno uno zero ed è quindi falsa (vedi qui ).

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Prendiamo [1 2 1 2]come esempio di input.

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 byte

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

Casi 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

Retina , 25 byte

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

Provalo online!

Invece di abbinare un input con valori alternati (che porta ad alcuni fastidiosi effetti collaterali in una regex), sto abbinando input che non sono validi e quindi annullo il risultato in seguito.

Il vantaggio di abbinare un input non valido è che questa è una proprietà che può essere verificata localmente e non ha bisogno di trattare in particolare input vuoti o brevi: qualsiasi input non è valido se contiene due valori distinti che sono una posizione a parte.

Quindi il primo stadio conta il numero di corrispondenze di \b(\d+),\d+,(?!\1\b)cui corrisponde e acquisisce un valore, quindi corrisponde al valore successivo e quindi afferma che il terzo valore in sequenza è diverso. Questo dà zero per input validi e qualcosa di positivo per valori non validi.

Il secondo stadio conta semplicemente il numero di partite di ^0cui è 1se il primo stadio è tornato 0e in caso 1contrario.

Mathematica, 29 byte

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

Una porta dell'algoritmo MATL di Luis Mendo. Funzione senza nome che prende un elenco di numeri (o anche oggetti più generali) e che restituisce Trueo False. Verifica se le somme di elementi consecutivi sono tutte uguali. Sfortunatamente Moste Restsoffocare nell'elenco vuoto, quindi deve essere testato separatamente.

Mathematica, 33 byte

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

Funzione senza nome che prende un elenco di numeri (o anche oggetti più generali) e che restituisce Trueo False. La funzione Differences[#,1,2]prende le differenze, non di coppie consecutive di numeri interi, ma di coppie di numeri di distanza distanti due. Quindi controlliamo solo se l'elenco risultante non contiene altro che zero.

Come bonus, per un altro byte (cambia 2in #2), otteniamo una funzione che inserisce un elenco di numeri interi e un altro numero intero positivo #2e controlla se l'elenco di input è il risultato di interlacciare #2sequenze costanti periodicamente tra loro. Per esempio,

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

valuta True.

Haskell, 27 26 byte

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

Questo valuta una funzione anonima che risolve la sfida. L'idea è di eliminare i primi due numeri dall'elenco, comprimere l'elenco originale usando l'uguaglianza e verificare che il risultato contenga solo Trues. Provalo online!

Grazie a nimi per 1 byte!

Retina ,39 32 28 byte

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

Provalo online!

Risparmiato 7 byte grazie a Martin ! Ne ho salvati altri 3 grazie a Kobi ! E a Kritixi per un'idea per un altro 1.

Opzionalmente abbiniamo un numero che occupa l'intero input, qualsiasi coppia di numeri o qualsiasi coppia di numeri seguita dalla stessa coppia un numero qualsiasi di volte e facoltativamente non includendo il secondo numero alla fine. Potrebbe salvare 2 byte se l'input fosse in unario.

Pyth, 9 byte

q<*<Q2lQl

Spiegazione

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 byte

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

Provalo online!

Spiegazione

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

⊢≡⍴⍴2⍴⊢

Spiegazione:

• 2⍴⊢: rimodella l'array di input di 2
• ⍴⍴: rimodella il risultato in base alla dimensione originale dell'input, ripetendo gli elementi
• ⊢≡: vedere se il risultato è uguale all'input originale

Casi 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 byte

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

Questa è un'espressione lambda per a Predicate< int[ ] >

Spiegazione: inizializzare il risultato su 0. Per ogni elemento, Biteise O il risultato con la differenza tra l'elemento corrente e l'elemento 2 indica in precedenza. ritorna truese il risultato è uguale a 0. Altrimenti ritornafalse

Perl 6 ,  49 43  42 byte

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

Provalo

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

Provalo

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

Provalo

Allargato:

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

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

Provalo online!

J, 8 byte

-:$$2&{.

Spiegazione

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

Casi 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 byte

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

Provalo online! oppure Verifica i casi di prova. -1 byte grazie a Zgarb.

bash, 56 54 38 byte

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

Salvalo come script e passa l'elenco di numeri come argomenti (per un elenco di n elementi, passerai n argomenti). L'output è il codice di uscita: 0 (per true) se l'elenco si alterna e 1 (per false) in caso contrario.

(La restituzione dell'output nel codice di uscita è consentita nei metodi I / O standard PPCG.)

Funziona in modo ricorsivo:

• Se l'elenco contiene meno di 3 elementi, quindi uscire con il codice di ritorno 0;
• altrimenti se il 1o elemento! = il 3o elemento, quindi esci con il codice di ritorno 1;
• altrimenti esegue il programma in modo ricorsivo nell'elenco con il primo elemento rimosso.

Python 2.7, 38 byte

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

Casi 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 byte, non competitivo

2<Ql{q

Provalo qui!

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

Consenti al nodo rimodella di prendere un elenco e una stringa

Shenzen IO (Assembler), 83 76 byte, non competitivo

Shenzen io è un puzzle game in cui puoi programmare il tuo codice in un linguaggio speciale assemblatore.

Sfortunatamente, puoi usare solo numeri interi compresi tra -999 e 999 come input o output e non c'è modo di sapere se un array è terminato. Quindi ho pensato che l'array fosse scritto su una ROM che si avvolge dopo aver letto l'ultima cella. Ciò significa che è possibile utilizzare solo matrici, motivo per cui non è competitivo.

Codice:

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

Spiegazione:

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

Scusate se qualcuno di questi è confuso, questa è la mia prima risposta da golf di codice.

EDIT: rimosso 7 byte sostituendo i loop con il codice run-once

Rubino, 23 byte

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

Rubino, 131 119 byte

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 si aaspetta un array xe restituisce true se ci sono 0 o 1 valori univoci per gli elementi dispari indicizzati e 0 o 1 valori univoci per gli elementi pari indicizzati nella matrice.

Notevoli casseforti di byte

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

Casi 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

Dardo, 46 ​​byte

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

Corri 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 byte

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

Filtra l'array per mostrare i valori che non corrispondono al primo valore per i pari e al 2o valore per le probabilità. Se non ci sono risultati, restituisci true.

Japt, 7 6 byte

eUîU¯2

Provalo o esegui tutti i casi di 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 byte

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

Funzione anonima che riceve un array intero e restituisce 1 se l'array si alterna e 0 altrimenti.

Programma completo con funzione non golfata e casi di 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
    }
}

Ottava, 51 byte

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

L'input è un array di celle di numeri interi positivi.

Provalo online!

Clojure, 70 byte

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

Verifica che il conteggio distinto di ogni secondo elemento sia 1 e gestisce le raccolte vuote come un caso speciale. Ho anche provato molti approcci basati su reducee group-byma non molta fortuna lì.

Un'altra opzione con R: 36 byte.

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

E penso di aver trovato una versione molto più breve: 15 byte

all(!diff(x,2))