Tengo una lista de dígitos decimales:

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

La lista de dígitos decimales se conoce como elementos. Podemos formar "fragmentos" a partir de estos elementos agrupando números idénticos y adyacentes. Quiero asignar a cada fragmento un número único, comenzando desde 1, y aumentando en 1 en el orden en que aparecen los fragmentos en la lista original. Entonces, la salida para el ejemplo dado se vería así:

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

Formato de entrada

Una lista de dígitos. (0-9) Puede usar sus idiomas incorporados para leer esta lista como quiera. Codificación: ASCII

Formato de salida

Una serie de números decimales, separados por un delimitador. Su programa siempre debe usar el mismo delimitador. El delimitador debe ser más largo que 0 bits. Codificación: ASCII

Se aplican lagunas estándar.

Python 3.8 (prelanzamiento) , 41 bytes

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

Pruébalo en línea!

Alabado sea la morsa mágica :=de las expresiones de asignación.

Python 2 , 42 bytes

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

Pruébalo en línea!

Python 2 , 44 bytes

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

Pruébalo en línea!

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

Función de prefijo tácito anónimo. Imprime separados por espacios.

+\1,2≠/

Pruébalo en línea!

2≠/ desigualdad por pares

1, anteponer 1

+\ suma acumulativa

Jalea , 6 5 bytes

ŒɠµJx

Pruébalo en línea!

¡Guardado un byte gracias a UnrelatedString !

Entradas y salidas como matriz (con paréntesis de apertura / cierre)

Cómo 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@#)&

Pruébalo en línea!

05AB1E , 5 bytes

¥Ā.¥>

Pruébalo en línea!

Haskell , 40 bytes

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

Pruébalo en línea!

Perl 6 , 21 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma una lista y devuelve una lista. Esto funciona al comparar si cada par de elementos adyacentes no son iguales, que tomar la suma acumulativa de la lista.

05AB1E , 4 bytes

γdƶ˜

Pruébalo en línea!

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

Pruébalo en línea!

Utiliza el mismo método de suma acumulativa que Luis Mendo y otros.

MATL , 8 bytes

Y'wn:wY"

Pruébalo en línea!

Explicación:

    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

Jalea , 4 bytes

ŒgƤẈ

Pruébalo en línea!

¿Cómo?

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

Octava / MATLAB, 25 bytes

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

Pruébalo en línea!

Haskell , 46 43 bytes

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

Pruébalo en línea!

Función anónima sin puntos que toma una lista y devuelve una lista

J , 12 bytes

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

Pruébalo en línea!

Similar a la respuesta APL de Adám

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

Perl 5 , 27 bytes

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

Pruébalo en línea!

La opción de línea de comando -phace que Perl lea la línea de entrada de STDIN en la "variable predeterminada" $_. Luego, la búsqueda reemplaza todos los dígitos $_con el contador $i. Y $ise incrementa para cada dígito que es diferente del dígito anterior, que también está en el primer dígito, por lo que el contador comienza en 1. El dígito anterior se almacena en $p.

Pyth , 13 11 bytes

s.e*]hkhbr8

Pruébalo en línea!

         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 gracias al Sr. Xcoder

Scala , 75 bytes

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

Pruébalo en línea!

Si la entrada y la salida deben estar separadas por comas String (y no List) entonces 102 bytes.

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

Jalea , 5 bytes

nƝÄŻ‘

Pruébalo en línea!

Inicialmente apunté a un 4-byter (el mismo programa pero sin el Ż) pero luego me di cuenta rápidamente de que un 1 tenía que ser antepuesto cada vez debido a un descuido ... A pesar de que hay otro 5-byter en Jelly, voy a En realidad, guarde esto porque utiliza un método diferente.

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

JavaScript (ES6), 30 bytes

Toma datos como una matriz de enteros.

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

Pruébalo en línea!

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,' ';

Pruébalo en línea!

Entrada a través de línea de comando, salida a STDOUT.

Gracias a @ Night2 por la molesta corrección de errores de '0' == 0comparación.

Julia 1.0 , 56 bytes

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

Pruébalo en línea!

Japt v2.0a0, 9 bytes

£T±A¦(A=X

Intentalo

Agregar ++ , 23 bytes

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

Pruébalo en línea!

Cómo 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]

Japt , 8 7 bytes

ä¦Ug)åÄ

Intentalo

Retina 0.8.2 , 34 bytes

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

Pruébalo en línea! Explicación:

\b\d+\b

Empareja cada número por turno.

(?<=(...)*)

Comienza a mirar hacia atrás en busca de la mayor cantidad de partidos posible. (Las siguientes entradas estarán en orden de derecha a izquierda, ya que así es como funciona mirar atrás).

\D*

Salta los separadores.

(\3|(\d+))

Intente hacer coincidir el mismo número que la última vez, pero si no lo hace, simplemente haga coincidir cualquier número, pero recuerde que teníamos que hacer coincidir un nuevo número.

\b

Asegúrese de que el número entero coincida.

$#3

Cuenta el número de nuevos números.

Stax , 10 bytes

▓ª2ªmD?Ä╧╖

Ejecutar y depurarlo

La salida usa el espacio como delimitador. La entrada sigue las especificaciones precisas usando comas como separadores, y ahora encierra llaves.

C (gcc) , 62 61 bytes

¡Esta es una de las pocas entradas que he hecho donde un programa completo es más corto que una presentación de función!

En la primera pasada, no me importa el valor anterior, ¡así que puedo confiar en el hecho de que argves un puntero a algún lugar y es extremadamente improbable que esté entre [0..9]!

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

Pruébalo en línea!

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(", ")

Pruébalo en línea!

C (gcc) , 62 bytes

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

Pruébalo en línea!

Una función que toma la lista y su longitud como argumentos.

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

Pruébalo en línea!

Salidas en unario, delimitadas por 0s