Un tableau de défis n ° 1: les tableaux en alternance

41

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 , 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
FlipTack
la source
Quelles sont les valeurs possibles des éléments du tableau?
Robert Hickman
@RobertHickman une liste d'entiers positifs, dans la taille standard int de votre langue
FlipTack
oh je le vois dans la question maintenant. Oups et merci.
Robert Hickman

Réponses:

27

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.
Dennis
la source
7
Zut. Et changer le 2à d'autres numéros généralise immédiatement le défi!
Greg Martin
3 octets , mais Ɲn'existait pas lorsque le défi a été posté.
Caird coinheringaahing
14

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.

Mitch Schwartz
la source
13

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

JAD
la source
vous pouvez économiser un octet avecall((a=scan())==a[1:2])
MickyT
Comment saisissez-vous les données, sous forme de vecteur, de liste ou de nombres simples? J'ai essayé de saisir des nombres simples sur la console, mais l'avertissement suivant s'affiche: "Message d'avertissement: Dans scan () == a [1: 2]: la longueur d'un objet n'est pas un multiple d'une longueur d'objet plus courte". Bien que cela fonctionne.
Skan
En tapant des nombres simples en effet. Il émettra un avertissement si la longueur d’entrée est impair, mais donnera toujours le bon résultat.
JAD
10

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]
Luis Mendo
la source
2
Bel algorithme! Cela ferait une réponse Jelly moyenne.
Dennis
@ Dennis Merci! Il a été en partie inspiré par votre approche de la gelée
Luis Mendo
9

JavaScript (ES6), 27 octets

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

Cas de test

Arnauld
la source
8

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.

Martin Ender
la source
7

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.

Greg Martin
la source
7

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!

Zgarb
la source
1
Agréable. and.(zipWith(==)=<<drop 2)enregistre un octet.
Nimi
7

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.

FryAmTheEggman
la source
1
Une autre ^(\d+)?(.\d+)?(.\1\2)*(.\1)?$alternative de 29 octets. Cela ne correspond pas,1,,1 .
Kritixi Lithos
1
@ Kobi Excellente idée, merci! J'ai utilisé une partie de la réponse de Kritixi (l'ajout de la virgule au deuxième groupe de capture) pour enregistrer un autre 1!
FryAmTheEggman
6

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
Mnémonique
la source
vous voudrez peut-être mettre à jour le code dans l'explication (c'est différent atm)
FlipTack
@ Flp.Tkc Pyth ajoute implicitement Qs au code. Je les ai ajoutés dans l'explication pour clarifier ce qui se passait, mais ils ne sont pas vraiment dans le code.
Mnémonique
5

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
Fataliser
la source
5

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
marinus
la source
5

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

Jack Ammo
la source
5

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.
  }
}
Brad Gilbert b2gills
la source
$_[1]peut être un octet plus court que .[1]. Le corps du lambda interne peut être un octet plus court que {.[0]!=a||.[1]!=b}.
smls
1
@smls je ne sais pas pourquoi je n'ai pas vu le .[1]. Aussi !=ne semble pas fonctionner si ce n'est pas suivi d'un espace. Je pense que quelque chose comme $_!=3est en cours d'analyse comme si elle était écrite comme!( $_ = 3 )
Brad Gilbert b2gills
Ah On dirait que c'est un bug de Rakudo .
smls
3

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|
+-+-+-+-+-+
Conor O'Brien
la source
Vous devriez pouvoir remplacer {.Take with $Shape.
Adám
3

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.

Laikoni
la source
@Dennis La fonction fonctionne pour [], mais pour une raison quelconque, ghc ne peut pas en déduire le type correct []. Cela fonctionne s'il est testé avec l'autre cas de test, voir Vérifier les cas de test.
Laikoni
D'accord, je ne connais pas très bien Haskell.
Dennis
Enregistrer un octet avecf(a:x@(_:b:_))=a==b&&f x
Zgarb
3

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

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
Faucon
la source
2
J'appellerais cela une copie de cette réponse .
mbomb007
1

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

Bleu
la source
1

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

Anamne
la source
Bienvenue chez PPCG!
FlipTack
1

Ruby, 23 octets

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

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
manonthemat
la source
1

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

Grax32
la source
1

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
Hirsute
la source
0

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
    }
}
adrianmp
la source
0

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!

rahnema1
la source
0

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.

NikoNyrh
la source
0

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))
skan
la source