Description du défi

Étant donné une liste / tableau d'éléments, affichez tous les groupes d'éléments répétitifs consécutifs.

Description des entrées / sorties

Votre entrée est une liste / tableau d'éléments (vous pouvez supposer que tous sont du même type). Vous n'avez pas besoin de prendre en charge tous les types de votre langue, mais vous devez en prendre au moins un (de préférence int, mais des types comme boolean, bien que pas très intéressants, conviennent également). Exemples de sorties:

[4, 4, 2, 2, 9, 9] -> [[4, 4], [2, 2], [9, 9]]
[1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4] -> [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
[1, 1, 1, 3, 3, 1, 1, 2, 2, 2, 1, 1, 3] -> [[1, 1, 1], [3, 3], [1, 1], [2, 2, 2], [1, 1], [3]]
[9, 7, 8, 6, 5] -> [[9], [7], [8], [6], [5]]
[5, 5, 5] -> [[5, 5, 5]]
['A', 'B', 'B', 'B', 'C', 'D', 'X', 'Y', 'Y', 'Z'] -> [['A'], ['B', 'B', 'B'], ['C'], ['D'], ['X'], ['Y', 'Y'], ['Z']]
[True, True, True, False, False, True, False, False, True, True, True] -> [[True, True, True], [False, False], [True], [False, False], [True, True, True]]
[0] -> [[0]]

En ce qui concerne les listes vides, la sortie n'est pas définie - il peut s'agir de rien, d'une liste vide ou d'une exception - tout ce qui convient le mieux à vos besoins de golf. Vous n'avez pas non plus à créer une liste de listes distincte, il s'agit donc également d'une sortie parfaitement valide:

[1, 1, 1, 2, 2, 3, 3, 3, 4, 9] ->

1 1 1
2 2
3 3 3
4
9

L'important est de maintenir les groupes séparés d'une manière ou d'une autre.

Mathematica, 5 octets

Split

... il y a une fonction intégrée pour cela.

Gelée , 5 octets

I0;œṗ

Fonctionne pour tous les types numériques. Essayez-le en ligne! ou vérifiez tous les cas de test numériques .

Comment ça fonctionne

I0;œṗ  Main link. Argument: A (array)

I      Increments; compute the differences of consecutive elements.
 0;    Prepend a zero.
   œṗ  Partition; split A at truthy values in the result to the left.

Rétine , 15 8 octets

Merci à Lynn d'avoir proposé un format d'E / S plus simple.

!`(.)\1*

Traite l'entrée comme une liste de caractères (et utilise des sauts de ligne pour séparer les groupes).

Essayez-le en ligne!

Cela fonctionne simplement en faisant correspondre les groupes et en les imprimant tous (qui utilise automatiquement la séparation de saut de ligne).

JavaScript (ES6), 39 37 octets

f=
s=>s.replace(/(\w+) (?!\1\b)/g,`$1
`)
;

<input oninput=o.textContent=f(this.value);><pre id=o>

Fonctionne sur tous les jetons de type mot séparés par des espaces. Enregistré 2 octets grâce à @ MartinEnder ♦. Le mieux que je puisse faire pour l'entrée et le retour du tableau est 68:

a=>a.reduce((l,r)=>(l==r?c.push(r):b.push(c=[r]),r),b=[c=[a[0]]])&&b

MATL , 9 octets

Y'v"@Z}Y"

Y'     % Take input. Run-length encoding. Gives two row arrays: values and run lengths
v      % Concatenate vertically   
"      % For each column
  @Z}  %   Push column and split into its two elements
  Y"   %   Run-length decoding
       % End for. Implicitly display

L'entrée est un tableau de nombres , avec des espaces ou des virgules comme séparateurs.

Essayez-le en ligne! Testez avec des nombres non entiers .

MATL, 11 octets

lidgvYsG7XQ

L'entrée est un tableau de colonnes de chiffres ou de caractères , utilisé ;comme séparateur.

Essayez-le en ligne! Testez avec des nombres arbitraires . Testez avec des personnages .

l     % Push 1
i     % Take input, say [4;4;2;2;9;9]
d     % Consecutive differences of input: [0;-2;0;7;0]
g     % Convert to logical: gives 1 if consecutive entries were different: [0;1;0;1;0]
v     % Concatenate vertically with the initial 1: [1;0;1;0;1;0]
Ys    % Cumulative sum. Each value is a group label: [1;1;2;2;3;3]
G     % Push input again
7XQ   % Split into horizontal arrays as indicated by group labels: {[4 4];[2 2];[9 9]}
      % Implicitly display

gs2, 2 octets

c-

Essayez-le en ligne!

cest un regroupement intégré qui fait exactement cela, nous l'appelons donc sur STDIN (qui est une chaîne, c'est-à-dire une liste de caractères) et obtenons une liste de chaînes. Malheureusement, le résultat est indiscernable de l'entrée, nous devons donc ajouter des séparateurs! -(joindre par des espaces) fait l'affaire.

Une autre réponse est cα(2 octets de CP437), qui encapsule simplement cune fonction anonyme.

Brachylog , 13 octets

:{s.dl1}fs.c?

Attention: c'est extrêmement inefficace, et vous comprendrez pourquoi dans l'explication.

Cela attend une liste (par exemple [1:1:2:2:2]) en entrée. Les éléments de la liste peuvent être à peu près n'importe quoi.

Explication

:{     }f       Find all ordered subsets of the Input with a unique element in them
  s.                Output is a subset of the input
    dl1             Output minus all duplicates has a length of 1 (i.e. one unique value)
         s.     Output is an ordered subset of those subsets
           c?   The concatenation of those subsets is the Input

Cela ne fonctionne qu'à cause de la façon dont les s - Subsetunités s'unissent: les plus petits ensembles sont à la fin. Par conséquent, la première chose qu'il trouve qui concatène à l'entrée sont les plus longues séries, par exemple [[1:1]:[2:2:2]]et non par exemple [[1:1]:[2:2]:[2]].

J , 13 octets

<;.1~1,2~:/\]

Étant donné que J ne prend pas en charge les tableaux irréguliers, chaque série d'éléments égaux est encadrée. L'entrée est un tableau de valeurs et la sortie est un tableau de tableaux encadrés.

Usage

   f =: <;.1~1,2~:/\]
   f 4 4 2 2 9 9
┌───┬───┬───┐
│4 4│2 2│9 9│
└───┴───┴───┘
   f 1 1 1 3 3 1 1 2 2 2 1 1 3
┌─────┬───┬───┬─────┬───┬─┐
│1 1 1│3 3│1 1│2 2 2│1 1│3│
└─────┴───┴───┴─────┴───┴─┘
   f 'ABBBCDXYYZ'
┌─┬───┬─┬─┬─┬──┬─┐
│A│BBB│C│D│X│YY│Z│
└─┴───┴─┴─┴─┴──┴─┘
   f 0
┌─┐
│0│
└─┘

Explication

<;.1~1,2~:/\]  Input: s
            ]  Identify function to get s
       2       The constant 2
           \   Operate on each overlapping sublist of size 2
        ~:/      Are the two values unequal, 1 if true else 0
     1,        Prepend a 1 to it
<;.1~          Using the list just made, chop s at each index equal to 1 and box it
               Return this as the result

Dyalog APL , 9 octets

⊢⊂⍨1,2≠/⊢

⊢l'argument
⊂⍨partitionné au
1premier élément
, , puis
2≠/là où les paires suivantes diffèrent
⊢dans l'argument

Python 2, 43 octets

p=-1
for x in input():print"|"[:x^p],x,;p=x

Fonctionne sur les listes de booléens. Exemple:

>> [True,True,False,False,False,True,False,True,False]
 True  True | False  False  False | True | False | True | False

Itère dans la liste d'entrée, stockant le dernier élément vu. Une barre de séparation est imprimée avant chaque élément différent du précédent, vérifiée comme ayant un xor au niveau ^du bit de 0. L'initialisation p=-1évite un séparateur avant le premier élément.

CJam, 9 octets

Deux solutions:

{e`:a:e~}
{e`{(*}%}

Testez-le ici.

Explication

e`   e# Run-length encode (gives a list of pairs [run-length value]).
:a   e# Wrap each pair in a singleton list.
:e~  e# Run-length decode each list.

Ou

e`   e# Run-length encode.
{    e# Map this block over each pair...
  (  e#   Pull out the run length.
  *  e#   Repeat the list containing only the value that many times.
}%

Haskell, 22 octets

import Data.List
group

Il y a un intégré. Fonctionne sur tout type prenant en charge l'égalité.

MATL, 8 7 octets

Suppression de 1 octet grâce à @Suever

ly&Y'Y{

Fonctionne avec des entiers / flottants / caractères / booléens / points licorne / autres entrées imaginaires.
Pour les booléens, les entrées sont T/F, les sorties sont 1/0.

Essayez-le en ligne!

Regroupés et répétés

ly&Y'Y{
l          % push 1 onto the stack
 y         % duplicate the input
  &Y'      % run-length encoding (secondary output only)
     Y{    % break up array into cell array of subarrays

C #, 117 octets

void f(List<String>m){Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));}

non golfé (pas vraiment)

    public static void f(List<String>m)
    {
        Console.Write(m[0]+String.Join("",m.GetRange(1,m.Count()-1).Select((i,j)=>i==m[j]?i:"\n"+i)));
    }

Pyth, 9 7 octets

mr9]dr8

Crédit à @LeakyNun pour 2 octets!

Explication:

             input
     r8      run-length decode
m            for each...
   ]d        ...treat each run as standalone encoded form...
 r9          ...decode 
             print

Ancienne réponse, 12 octets

hf.Am!t{dT./

J'ai oublié la longueur de course intégrée, mais je pense que c'est une approche correcte, donc je l'ai gardée.

Explication:

                input
          ./    all possible partitions
 f       T      filter by...
  .A            ...whether all groups of integers...
    m!t{d       ...have length one after deduplication
h               get the first element (first one has no adjacent [1,1] and [1])
                print

Pyth , 36 35 octets

VQIqNk=hZ).?=+Y]*]kZ=Z1=kN;t+Y]*]kZ

Lien de test

Edit: explication:

                                      standard variables: Y=[], Z=0, k='', Q=input
VQ                                    iterate over input
  IqNk                                if the current entity is equal to k:
      =hZ)                            increase Z.
          .?                          else:
               ]*]kZ                  list of length Z filled with k
            =+Y                       add it to Y
                    =Z1               set Z to 1
                       =kN            set k to the current entity
                          ;           end loop
                              ]*]kZ   list of length Z filled with k
                            +Y        add it to Y
                           t          implicitly print the tail of Y (removing the first element)

Rétine , 24 22 octets

2 octets grâce à Martin Ender.

Une réponse de 15 octets existe déjà, il ne s'agit donc que d'une autre approche qui coûte plus d'octets.

S-`(?<=(\d+)) (?!\1\b)

Essayez-le en ligne!

Il se divise en espaces dont le nombre précédent diffère de la procédure.

Il s'agit d'une démonstration de contournements.

05AB1E, 13 octets

¬svyÊi¶}yðJ?y

Expliqué

¬s             # push first element of list to stack and swap with input
  v            # for each X in input
   yÊi¶}       # if X is different from last iteration, push a newline
        yðJ?   # push X followed by a space to stack and join stack to string
            y  # push X to stack for next iterations comparison

Devrait fonctionner pour n'importe quelle liste.
Testé sur int et char.

Essayez-le en ligne

Swift, 43 octets

var p=0;i.map{print($0==p ?"":",",$0);p=$0}

Suppose que i est un tableau d'objets équables; fonctionne pour tout, des entiers aux chaînes en passant par les objets personnalisés. Un peu effronté en ce que la sortie contient beaucoup de nouvelles lignes, mais rendre cette plus jolie coûterait des octets.

Version plus jolie et non golfée:

var prev = Int.max // unlikely to be the first element, but not the end of the world if it happens to be.
i.map { n in
    print(n == prev ? " " : "\n•", n, terminator: "")
    prev = n
}

Cette version imprime chaque groupe sur une nouvelle ligne au détriment de plus de code.

Idées d'amélioration

i.reduce(0){print($0==$1 ?"":"•",$1);return $1}

Cette version a 47 octets, mais c'est une approche différente, alors peut-être qu'il y a quelque chose à optimiser là-bas? Le plus gros problème est la déclaration de retour.

C, 88 77 octets

Déplacé le strmcmp intérieur des printf 11 octets d'économie

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}

Usage:

f(char**a){*a++;char*x;for(;*a;x=*a++)printf(strcmp(*a,x)?"\n%s ":"%s ",*a);}
main(c,v)char**v;{f(v);}

Exemple d'entrée:

(Paramètres de ligne de commande)

1 1 1 1 2 2 2 2 3 3 3 3 4 5 6 7777

Exemple de sortie:

1 1 1 1
2 2 2 2
3 3 3 3
4
5
6
7777

Testé sur:

gcc 4.4.7 (Red Hat 4.4.7-16)  - OK
gcc 5.3.0 (Cygwin)            - Segmetation Fault
gcc 4.8.1 (Windows)           - OK

J'essaie de corriger le défaut de Segmetation 5.3.0.

Version 88

f(char**a){*a++;char*x;for(;*a;x=*a++)strcmp(*a,x)?printf("\n%s ",*a):printf("%s ",*a);}

Java 134 octets

void a(String[]a){int i=0,l=a.length;for(;i<l-1;i++)System.out.print(a[i]+((a[i].equals(a[i+1]))?" ":"\n"));System.out.print(a[l-1]);}

itère à travers et décide de séparer avec une nouvelle ligne ou un espace.

ListSharp , 134 octets

STRG l = READ[<here>+"\\l.txt"]
[FOREACH NUMB IN 1 TO l LENGTH-1 AS i]
{
[IF l[i] ISNOT l[i-1]]
STRG o=o+"\n"
STRG o=o+l[i]
}
SHOW = o

ListSharp ne prend pas en charge les fonctions, le tableau est donc enregistré dans un fichier local appelé l.txt

Rubis , 24 octets

En rubis Array instances ont une méthode intégréegroup_by

La solution sera donc:

a.group_by{|x| x}.values

TSQL, 132 octets

C'est un peu différent des autres réponses - sql n'a pas de tableaux, l'entrée évidente pour sql est un tableau.

Golfé:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT REPLICATE(v+' ',COUNT(*))FROM(SELECT i,i-row_number()over(partition
by v order by i)x,v FROM @)z GROUP BY x,v ORDER BY max(i)

Non golfé:

DECLARE @ table(i int identity, v varchar(20))
INSERT @ values(1),(1),(1),(3),(3),(1),(1),(2),(2),(2),(1),(1),(3)

SELECT
  REPLICATE(v+' ',COUNT(*))
FROM 
  (
     SELECT
       i,
       i-row_number()over(partition by v order by i)x,
       v
     FROM @
  )z
GROUP BY
  x,v
ORDER BY
  max(i)

Violon

Perl 5 - 39 octets

print$_.($/)[$_ eq@a[++$-]]for@a=sort@a

Pyke, 2 octets (non compétitif)

Ne prend en charge que les entiers

$f

Essayez-le ici!

split_at(input, delta(input))

Ajout du nœud split_at, divise l'entrée lorsque le deuxième argument est vrai

sed, 33 23 + 1 = 24 octets

s/([^ ]+)( \1)* */&\n/g

Il a besoin de l' -roption.

Exemple d'utilisation:

$ echo '1 1 1 2 2 3 3 3 4 9 9' | sed -r 's/([^ ]+)( \1)* */&\n/g'
1 1 1 
2 2 
3 3 3 
4 
9 9

JavaScript (ES6), 56

Entrée: tableau de nombres ou de chaînes

Sortie: tableau de tableaux

Première utilisation de la comparaison exacte dans le code de golf

a=>a.map(x=>x!==p?o.push(g=[p=x]):g.push(x),p=o=g=[])&&o

Clojure, 19 octets

#(partition-by + %)

C'est intégré, mais cela prend une fonction de cartographie. Dans ce cas, +sert de fonction d'identité.

Javascript (en utilisant une bibliothèque externe) (178 octets)

(s)=>_.From(s).Aggregate((t,e)=>{if(0===t.Items.length)return t.Items.push([e]),t;var s=t.Items[t.Items.length-1];return s[0]===e?(s.push(e),t):(t.Items.push([e]),t)},{Items:[]})

Avertissement: j'utilise une bibliothèque que j'ai écrite pour implémenter LINQ de C # dans JS. Ça ne m'a pas vraiment aidé à gagner mais bon