Descrição do Desafio

Dada uma lista / matriz de itens, exiba todos os grupos de itens repetidos consecutivos.

Descrição de entrada / saída

Sua entrada é uma lista / matriz de itens (você pode assumir que todos são do mesmo tipo). Você não precisa dar suporte a todos os tipos que seu idioma possui, mas deve suportar pelo menos um (de preferência int, mas tipos como boolean, embora não sejam muito interessantes, também são bons). Saídas de amostra:

[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]]

Quanto às listas vazias, a saída é indefinida - não pode ser nada, uma lista vazia ou uma exceção - o que melhor se adapte aos seus objetivos de golfe. Você também não precisa criar uma lista separada de listas, portanto, essa é uma saída perfeitamente válida:

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

1 1 1
2 2
3 3 3
4
9

O importante é manter os grupos separados de alguma forma.

Mathematica, 5 bytes

Split

... há um built-in para isso.

Gelatina , 5 bytes

I0;œṗ

Funciona para todos os tipos numéricos. Experimente online! ou verifique todos os casos de teste numéricos .

Como funciona

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.

Retina , 15 8 bytes

Agradecemos a Lynn por sugerir um formato de E / S mais simples.

!`(.)\1*

Trata a entrada como uma lista de caracteres (e usa alimentações de linha para separar grupos).

Experimente online!

Isso simplesmente funciona combinando grupos e imprimindo todos (que usa a separação de alimentação de linha automaticamente).

JavaScript (ES6), 39 37 bytes

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

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

Funciona em quaisquer tokens semelhantes a palavras, separados por espaço. Economizou 2 bytes graças a @ MartinEnder ♦. O melhor que eu poderia fazer para a entrada e o retorno da matriz é 68:

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

MATL , 9 bytes

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

A entrada é uma matriz de números de linhas , com espaços ou vírgulas como separadores.

Experimente online! Teste com números não inteiros .

MATL, 11 bytes

lidgvYsG7XQ

A entrada é uma matriz de colunas de números ou caracteres , usando ;como separador.

Experimente online! Teste com números arbitrários . Teste com caracteres .

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 bytes

c-

Experimente online!

cé um agrupamento interno que faz exatamente isso, por isso chamamos STDIN (que é uma string, ou seja, uma lista de caracteres) e obtemos uma lista de strings. Infelizmente, o resultado é indistinguível da entrada, por isso precisamos adicionar separadores! -(junção por espaços) faz o truque.

Uma resposta alternativa é cα(2 bytes do CP437), que simplesmente envolve cuma função anônima.

Braquilog , 13 bytes

:{s.dl1}fs.c?

Aviso: isso é extremamente ineficiente e você entenderá o porquê da explicação.

Isso espera uma lista (por exemplo [1:1:2:2:2]) como entrada. Os elementos dentro da lista podem ser praticamente qualquer coisa.

Explicação

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

Isso funciona apenas por causa da maneira como os s - Subsetunifica: os menores conjuntos estão no final. Portanto, a primeira coisa que acha que concatena com a entrada é a execução mais longa, por exemplo, [[1:1]:[2:2:2]]e não por exemplo [[1:1]:[2:2]:[2]].

J , 13 bytes

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

Como J não suporta matrizes irregulares, cada execução de elementos iguais é encaixotada. A entrada é uma matriz de valores e a saída é uma matriz de matrizes in a box.

Uso

   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│
└─┘

Explicação

<;.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 bytes

⊢⊂⍨1,2≠/⊢

⊢o argumento
⊂⍨particionado no
1primeiro elemento
,e,
2≠/em seguida, onde os pares subsequentes diferem
⊢no argumento

Python 2, 43 bytes

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

Trabalha em listas de booleanos. Exemplo:

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

Repete a lista de entrada, armazenando o último elemento visto. Uma barra separadora é impressa antes de cada elemento que é diferente do anterior, marcada como tendo xor ^de bit a 0. 0. A inicialização p=-1evita um separador antes do primeiro elemento.

CJam, 9 bytes

Duas soluções:

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

Teste aqui.

Explicação

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 bytes

import Data.List
group

Há um embutido. Funciona em qualquer tipo que ofereça suporte à igualdade.

MATL, 8 7 bytes

Removido 1 byte graças a @Suever

ly&Y'Y{

Trabalha com números inteiros / flutuantes / caracteres / booleanos / pontos unicórnio / outras entradas imaginárias.
Para booleanos, entradas são T/F, saídas são 1/0.

Experimente online!

Agrupados e repetidos

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 bytes

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

ungolfed (não realmente)

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

Pitão, 9 7 bytes

mr9]dr8

Crédito para @LeakyNun por 2 bytes!

Explicação:

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

Resposta antiga, 12 bytes

hf.Am!t{dT./

Esqueci o comprimento da execução interno, mas acho que essa é uma abordagem correta, então a mantive.

Explicação:

                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

Pitão , 36 35 bytes

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

Link de teste

Editar: explicação:

                                      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)

Retina , 24 22 bytes

2 bytes graças a Martin Ender.

A resposta de 15 bytes já existe, por isso esta é apenas uma outra abordagem que custa mais bytes.

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

Experimente online!

Divide-se em espaços cujo número anterior difere do processo.

Esta é uma demonstração de lookarounds.

05AB1E, 13 bytes

¬svyÊi¶}yðJ?y

Explicado

¬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

Deve funcionar para qualquer lista.
Testado em int e char.

Experimente online

Rápido, 43 bytes

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

Assume i como uma matriz de objetos equáveis; funciona para qualquer coisa, de ints a strings e objetos personalizados. Tipo de atrevido em que a saída contém muitas novas linhas, mas tornar esse mais bonito custaria bytes.

Versão mais bonita e não destruída:

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
}

Esta versão imprime todos os grupos em uma nova linha à custa de mais código.

Idéias para melhoria

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

Esta versão tem 47 bytes, mas é uma abordagem diferente, então talvez haja algo para otimizar por aí? O maior problema é a declaração de retorno.

C, 88 bytes

Movido o strmcmp interior para printf salvar 11 bytes

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

Uso:

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

Entrada de amostra:

(parâmetros da linha de comando)

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

Saída de amostra:

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

Testado em:

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

Estou tentando corrigir a falha de segmentação 5.3.0.

88 Versão

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

Java 134 bytes

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]);}

itera e decide se deve separar com uma nova linha ou um espaço.

ListSharp , 134 bytes

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

O ListSharp não suporta funções, para que a matriz seja salva em um arquivo local chamado l.txt

Ruby , 24 bytes

Em Arrayinstâncias de ruby, o método internogroup_by

Então a solução será:

a.group_by{|x| x}.values

TSQL, 132 bytes

Isso é um pouco diferente das outras respostas - o sql não possui matrizes, a entrada óbvia para o sql é uma tabela.

Golfe:

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)

Ungolfed:

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)

Violino

Perl 5 - 39 bytes

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

Pyke, 2 bytes (não competitivo)

Suporta apenas números inteiros

$f

Experimente aqui!

split_at(input, delta(input))

Nó split_at adicionado, divide a entrada quando o segundo argumento é verdadeiro

sed, 33 23 + 1 = 24 bytes

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

Precisa da -ropção.

Exemplo de uso:

$ 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

Entrada: matriz de números ou seqüências de caracteres

Saída: matriz de matrizes

Primeira vez usando comparações exatas no código de golfe

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

Clojure, 19 bytes

#(partition-by + %)

É um built-in, mas é preciso uma função de mapeamento. Nesse caso, +serve como uma função de identidade.

Javascript (usando biblioteca externa) (178 bytes)

(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:[]})

Isenção de responsabilidade: estou usando uma biblioteca que escrevi para implementar o LINQ de c # em JS. Não me ajudou exatamente a vencer, mas tudo bem