Eu tenho uma lista de dígitos decimais:

4, 4, 4, 7, 7, 9, 9, 9, 9, 2, 2, 2, 4, 4

A lista de dígitos decimais é conhecida como itens. Podemos formar "pedaços" desses itens agrupando números idênticos e adjacentes. Desejo atribuir a cada bloco um número único, iniciando em 1 e aumentando em 1 na ordem em que os blocos aparecem na lista original. Portanto, a saída para o exemplo fornecido ficaria assim:

1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5

Formato de entrada

Uma lista de dígitos. (0-9) Você pode usar os idiomas internos para ler esta lista da maneira que desejar. Codificação: ASCII

Formato de saída

Uma série de números decimais, separados por um delimitador. Seu programa sempre deve usar o mesmo delimitador. O delimitador deve ter mais de 0 bits. Codificação: ASCII

Aplicam-se brechas padrão.

Python 3.8 (pré-lançamento) , 41 bytes

lambda l,n=0:[n:=n+(l!=(l:=x))for x in l]

Experimente online!

Elogie a morsa mágica :=das expressões de atribuição.

Python 2 , 42 bytes

n=0
for x in input():n+=x!=id;id=x;print n

Experimente online!

Python 2 , 44 bytes

l=input()
n=0
for i in l:n+=i!=l;l=i;print n

Experimente online!

APL (dzaima / APL) , ^{SBCS de} 7 bytes

Função de prefixo tácito anônimo. Imprime com espaço separado.

+\1,2≠/

Experimente online!

2≠/ desigualdade em pares

1, anexar 1

+\ soma acumulada

Geléia , 6 5 bytes

ŒɠµJx

Experimente online!

Salvo um byte graças a UnrelatedString !

Entradas e saídas como array (com colchetes de abertura / fechamento)

Como funciona

ŒɠµJx - Main link, takes one argument:                       [7, 7, 5, 5, 5, 1]
Œɠ    - Get the lengths of consecutive elements:             [2, 3, 1]
  µ   - Call these lengths A
   J  - range(length(A))                                     [1, 2, 3]
    x - Repeat each element by the corresponding value in A: [1, 1, 2, 2, 2, 3]

Wolfram Language (Mathematica) , 29 bytes

Join@@(i=1;0#+i++&/@Split@#)&

Experimente online!

05AB1E , 5 bytes

¥Ā.¥>

Experimente online!

Haskell , 40 bytes

f(a:t)=1:map(+sum[1|a/=t!!0])(f t)
f e=e

Experimente online!

Perl 6 , 21 bytes

{+<<[\+] $,|$_ Zne$_}

Experimente online!

Bloco de código anônimo que pega uma lista e retorna uma lista. Isso funciona comparando se cada par de elementos adjacentes não é igual, do que obtendo a soma acumulada da lista.

05AB1E , 4 bytes

γdƶ˜

Experimente online!

γ       # group adjacent equal digits together
 d      # replace all digits with 1
  ƶ     # multiply each group by its 1-based index
   ˜    # flatten

R , 33 bytes

function(x)cumsum(c(1,!!diff(x)))

Experimente online!

Usa o mesmo método de soma acumulada que Luis Mendo e outros.

MATL , 8 bytes

Y'wn:wY"

Experimente online!

Explicação:

    Y'      % run-length encoding
    w       % swap elements in stack
    n       % number of elements in array / size along each dimension
    :       % range; vector of equally spaced values
    w       % swap elements in stack
    Y"      % replicate elements of array
            % (implicit) convert to string and display

Gelatina , 4 bytes

ŒgƤẈ

Experimente online!

Quão?

ŒgƤẈ - Link: list of integers  e.g. [7,7,2,7,7]
  Ƥ  - for prefixes:     [7]   [7,7]   [7,7,2]      [7,7,2,7]        [7,7,2,7,7]
Œg   -   group runs      [[7]] [[7,7]] [[7,7],[2]]  [[7,7],[2],[7]]  [[7,7],[2],[7,7]]
   Ẉ - length of each    [1,   1,      2,           3,               3]

Oitava / MATLAB, 25 bytes

@(x)cumsum([1 ~~diff(x)])

Experimente online!

Haskell , 46 43 bytes

scanl(+)1.map fromEnum.(zipWith(/=)=<<tail)

Experimente online!

Função pointfree anônima que pega uma lista e retorna uma lista

J , 12 bytes

1+/\@,2~:/\]

Experimente online!

Semelhante à resposta do Adám no APL

      2~:/\]  - pair-wise inequality
1    ,        - prepend 1
    @         - and   
+/\           - find the cumulative sum

Perl 5 , 27 bytes

s/\d/$i+=$&!=$p;$p=$&;$i/ge

Experimente online!

A opção de linha de comando -pfaz com que o perl leia a linha de entrada de STDIN na "variável padrão" $_. Em seguida, a pesquisa substitui todos os dígitos $_pelo contador $i. E $ié aumentado para cada dígito diferente do dígito anterior, que também está no primeiro dígito, portanto o contador inicia em 1. O dígito anterior é armazenado em $p.

Pitão , 13 11 bytes

s.e*]hkhbr8

Experimente online!

         r8  # Run-length encode (implicit argument is the input) (-> [[frequency, char], ...]
 .e          # Enumerated map (current element is b, index is k) over rQ8
   *]hk      # [ k+1 ] *
       hb    #           b[0]
s            # Reduce list on + ([a]+[b] = [a,b])

-2 bytes graças ao Sr. Xcoder

Scala , 75 bytes

s=>s.scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2)

Experimente online!

Se a entrada e a saída tiverem de ser separadas por vírgula, a sequência (e não a lista) será 102 bytes.

s=>s.split(", ").scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2).mkString(", ")

Gelatina , 5 bytes

nƝÄŻ‘

Experimente online!

Inicialmente, eu tinha como objetivo um 4-byter (o mesmo programa, mas sem o Ż), mas logo percebi que um 1 tinha que ser anexado todas as vezes devido a uma supervisão ... Mesmo que haja outro 5-byter em Jelly, eu vou Na verdade, mantenha isso porque ele usa um método diferente.

$L$$L_i\ne L_{i+1}, \forall 1\le i<|L|$

JavaScript (ES6), 30 bytes

Recebe a entrada como uma matriz de números inteiros.

a=>a.map(p=n=>i+=p!=(p=n),i=0)

Experimente online!

Comentado

a =>                // a[] = input array
  a.map(p =         // initialize p to a non-numeric value
  n =>              // for each value n in a[]:
    i +=            //   increment i if:
      p != (p = n), //     p is not equal to n; and update p to n
    i = 0           //   start with i = 0 (chunk counter)
  )                 // end of map()

PHP , 52 bytes

while(''<$d=$argv[++$x])echo$i+=$argv[$x-1]!=$d,' ';

Experimente online!

Entrada via linha de comando, saída para STDOUT.

Thx para @ Night2 para o traquina '0' == 0 correção de comparação !

Julia 1.0 , 56 bytes

l->foldl(l,init=(0,0))do(p,i),c
println(i+=p!=c)
c,i
end

Experimente online!

Japt v2.0a0, 9 bytes

£T±A¦(A=X

Tente

Adicionar ++ , 23 bytes

D,f,@*,BGd€bL$bLRz€¦XBF

Experimente online!

Como funciona

D,f,@*,     - Define a function, f, that takes one argument:  [7 7 5 5 5 1]
       BG   - Group neighbouring elements together:           [[[7 7] [5 5 5] [1]]]          
       d    - Duplicate:                                      [[[7 7] [5 5 5] [1]] [[7 7] [5 5 5] [1]]]
       €bL  - Get the length of each:                         [[[7 7] [5 5 5] [1]] [2 3 1]]
       $bLR - Length, then range of length:                   [[2 3 1] [1 2 3]]
       z    - Zip together:                                   [[2 1] [3 2] [1 3]]
       €¦X  - Reduce each by repetition:                      [[1 1] [2 2 2] [3]]
       BF   - Flatten:                                        [1 1 2 2 2 3]
            - Due to the * in the function definition,
                 return the whole stack:                      [1 1 2 2 2 3]

Japonês , 8 7 bytes

ä¦Ug)åÄ

Tente

Retina 0.8.2 , 34 bytes

\b\d+\b(?<=(\b(\3|(\d+))\D*)*)
$#3

Experimente online! Explicação:

\b\d+\b

Combine cada número por vez.

(?<=(...)*)

Comece olhando para trás o maior número possível de correspondências. (As próximas entradas serão na ordem da direita para a esquerda, pois é assim que o lookbehind funciona.)

\D*

Pule os separadores.

(\3|(\d+))

Tente corresponder ao mesmo número da última vez, mas, na sua falta, basta corresponder a qualquer número, mas lembre-se de que tivemos que corresponder a um novo número.

\b

Verifique se o número inteiro é correspondido.

$#3

Conte o número de novos números.

Stax , 10 bytes

▓ª2ªmD?Ä╧╖

Execute e depure

A saída usa o espaço como um delimitador. A entrada segue as especificações precisas usando vírgulas como separadores e agora incluindo chaves.

C (gcc) , 62 61 bytes

Esta é uma das poucas entradas que fiz quando um programa completo é mais curto que um envio de função!

Na primeira passagem, não me importo com o valor anterior, por isso confio no fato de que argvé um ponteiro para algum lugar e é extremamente improvável que esteja entre [0..9]!

s;main(i,j){for(;~scanf("%d,",&i);j=i)printf("%d ",s+=j!=i);}

Experimente online!

Scala , 114 bytes

s.split(", ").zipWithIndex.scan(s.head,0){(a,b)=>if(a._1==b._1)a else b._1->(a._2+1)}.tail.unzip._2.mkString(", ")

Experimente online!

C (gcc) , 62 bytes

f(_,l)int*_;{printf("%d ",l=--l?f(_,l)+(_[l]!=_[l-1]):1);_=l;}

Experimente online!

Uma função que leva a lista e seu comprimento como argumentos.

f(_,l)int*_;{_=printf("%*d",--l?f(_,l)+(_[l]!=_[l-1]):2,0);}

Experimente online!

Saídas em unário, delimitado por 0s