J'ai une liste de chiffres décimaux:

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

La liste des chiffres décimaux est connue sous le nom d'éléments. Nous pouvons former des "morceaux" à partir de ces éléments en regroupant des nombres identiques et adjacents. Je veux attribuer à chaque bloc un numéro unique, en commençant par 1 et en augmentant de 1 dans l'ordre dans lequel les blocs apparaissent dans la liste d'origine. Ainsi, la sortie de l'exemple donné ressemblerait à ceci:

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

Format d'entrée

Une liste de chiffres. (0-9) Vous pouvez utiliser votre langage intégré pour lire cette liste comme vous le souhaitez. Encodage: ASCII

Format de sortie

Une série de nombres décimaux, séparés par un délimiteur. Votre programme doit toujours utiliser le même délimiteur. Le délimiteur doit être supérieur à 0 bits. Encodage: ASCII

Des échappatoires standard s'appliquent.

Python 3.8 (pré-version) , 41 octets

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

Essayez-le en ligne!

Louez le morse magique :=des expressions d'affectation.

Python 2 , 42 octets

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

Essayez-le en ligne!

Python 2 , 44 octets

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

Essayez-le en ligne!

APL (dzaima / APL) , 7 octets ^SBCS

Fonction de préfixe tacite anonyme. Imprime en séparant l'espace.

+\1,2≠/

Essayez-le en ligne!

2≠/ inégalité par paire

1, ajouter 1

+\ somme cumulée

Gelée , 6 5 octets

ŒɠµJx

Essayez-le en ligne!

Un octet enregistré grâce à UnrelatedString !

Entrées et sorties sous forme de tableau (avec crochets d'ouverture / fermeture)

Comment ça fonctionne

Œɠµ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 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

¥Ā.¥>

Essayez-le en ligne!

Haskell , 40 octets

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

Essayez-le en ligne!

Perl 6 , 21 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend une liste et renvoie une liste. Cela fonctionne en comparant si chaque paire d'éléments adjacents n'est pas égale, en prenant la somme cumulée de la liste.

05AB1E , 4 octets

γdƶ˜

Essayez-le en ligne!

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

R , 33 octets

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

Essayez-le en ligne!

Utilise la même méthode de somme cumulée que Luis Mendo et autres.

MATL , 8 octets

Y'wn:wY"

Essayez-le en ligne!

Explication:

    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

Gelée , 4 octets

ŒgƤẈ

Essayez-le en ligne!

Comment?

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

Octave / MATLAB, 25 octets

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

Essayez-le en ligne!

Haskell , 46 43 octets

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

Essayez-le en ligne!

Fonction anonyme sans point qui prend une liste et retourne une liste

J , 12 octets

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

Essayez-le en ligne!

Similaire à la réponse APL d' Adám

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

Perl 5 , 27 octets

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

Essayez-le en ligne!

L'option de ligne de commande -pfait perl lire la ligne d'entrée de STDIN dans la "variable par défaut" $_. Il remplace ensuite tous les chiffres $_par le compteur $i. Et $iest augmenté pour chaque chiffre qui est différent du chiffre précédent, qui se trouve également au premier chiffre, de sorte que le compteur démarre à 1. Le chiffre précédent est enregistré dans $p.

Pyth , 13 11 octets

s.e*]hkhbr8

Essayez-le en ligne!

         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 octets grâce à M. Xcoder

Scala , 75 octets

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

Essayez-le en ligne!

Si l'entrée et la sortie doivent être des chaînes séparées par des virgules (et non des listes), alors 102 octets.

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

Gelée , 5 octets

nƝÄŻ‘

Essayez-le en ligne!

Au départ, je visais un 4 octets (le même programme mais sans le Ż) mais j'ai rapidement réalisé qu'un 1 devait être ajouté à chaque fois en raison d'un oubli ... Même s'il y a un autre 5 octets dans Jelly, je vais en fait garder cela car il utilise une méthode différente.

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

JavaScript (ES6), 30 octets

Prend l'entrée comme un tableau d'entiers.

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

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Entrée via ligne de commande, sortie vers STDOUT.

Thx à @ Night2 pour le '0' == 0bugfix de comparaison embêtant !

Julia 1.0 , 56 octets

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

Essayez-le en ligne!

Japt v2.0a0, 9 octets

£T±A¦(A=X

Essayez-le

Ajouter ++ , 23 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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 octets

ä¦Ug)åÄ

Essayez-le

Retina 0.8.2 , 34 octets

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

Essayez-le en ligne! Explication:

\b\d+\b

Faites correspondre chaque numéro tour à tour.

(?<=(...)*)

Commencez à regarder en arrière pour autant de matchs que possible. (Les prochaines entrées seront dans l'ordre de droite à gauche car c'est ainsi que fonctionne lookbehind.)

\D*

Sautez les séparateurs.

(\3|(\d+))

Essayez de faire correspondre le même numéro que la dernière fois, mais à défaut, faites simplement correspondre n'importe quel numéro, mais rappelez-vous que nous devions faire correspondre un nouveau numéro.

\b

Assurez-vous que le nombre entier correspond.

$#3

Comptez le nombre de nouveaux numéros.

Stax , 10 octets

▓ª2ªmD?Ä╧╖

Exécuter et déboguer

La sortie utilise l'espace comme délimiteur. L'entrée suit les spécifications précises en utilisant des virgules comme séparateurs, et maintenant des accolades.

C (gcc) , 62 61 octets

C'est l'une des rares entrées que j'ai faites où un programme complet est plus court qu'une soumission de fonction!

Lors de la première passe, je ne me soucie pas de la valeur précédente, donc je peux compter sur le fait qu'il argvs'agit d'un pointeur vers quelque part et qu'il est extrêmement peu probable qu'il se situe entre [0..9]!

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

Essayez-le en ligne!

Scala , 114 octets

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

Essayez-le en ligne!

C (gcc) , 62 octets

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

Essayez-le en ligne!

Une fonction qui prend la liste et sa longueur comme arguments.

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

Essayez-le en ligne!

Sorties en unaire, délimitées par 0s