Ho un elenco di cifre decimali:

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

L'elenco delle cifre decimali è noto come elementi. Possiamo formare "pezzi" da questi elementi raggruppando insieme numeri identici e adiacenti. Voglio assegnare a ciascun blocco un numero univoco, a partire da 1 e aumentando di 1 nell'ordine in cui i blocchi vengono visualizzati nell'elenco originale. Quindi, l'output per l'esempio dato sarebbe simile al seguente:

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

Formato di input

Un elenco di cifre. (0-9) È possibile utilizzare i componenti incorporati della lingua per leggere questo elenco come desiderato. Codifica: ASCII

Formato di output

Una serie di numeri decimali, separati da un delimitatore. Il tuo programma deve sempre utilizzare lo stesso delimitatore. Il delimitatore deve essere più lungo di 0 bit. Codifica: ASCII

Si applicano scappatoie standard.

Python 3.8 (pre-release) , 41 byte

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

Provalo online!

Loda il tricheco magico :=delle espressioni di incarico.

Python 2 , 42 byte

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

Provalo online!

Python 2 , 44 byte

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

Provalo online!

APL (dzaima / APL) , 7 byte ^SBCS

Funzione prefisso tacito anonimo. Stampa separata dallo spazio.

+\1,2≠/

Provalo online!

2≠/ disuguaglianza tra le coppie

1, anteporre 1

+\ somma cumulativa

Gelatina , 6 5 byte

ŒɠµJx

Provalo online!

Salvato un byte grazie a UnrelatedString !

Ingressi e uscite come array (con parentesi aperte / chiuse)

Come funziona

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

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

Provalo online!

05AB1E , 5 byte

¥Ā.¥>

Provalo online!

Haskell , 40 byte

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

Provalo online!

Perl 6 , 21 byte

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

Provalo online!

Blocco di codice anonimo che accetta un elenco e restituisce un elenco. Questo funziona confrontando se ogni coppia di elementi adiacenti non è uguale, piuttosto che prendere la somma cumulativa dell'elenco.

05AB1E , 4 byte

γdƶ˜

Provalo online!

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

R , 33 byte

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

Provalo online!

Utilizza lo stesso metodo di somma cumulativa di Luis Mendo e altri.

MATL , 8 byte

Y'wn:wY"

Provalo online!

Spiegazione:

    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 byte

ŒgƤẈ

Provalo online!

Come?

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

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

Provalo online!

Haskell , 46 43 byte

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

Provalo online!

Funzione anonima senza punti che accetta un elenco e restituisce un elenco

J , 12 byte

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

Provalo online!

Simile alla risposta APL di Adám

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

Perl 5 , 27 byte

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

Provalo online!

L'opzione della riga di comando -pconsente a perl di leggere la riga di input da STDIN nella "variabile predefinita" $_. Quindi cerca-sostituisce tutte le cifre $_con il contatore $i. Ed $iè aumentato per ogni cifra che è diversa dalla cifra precedente, che è anche alla prima cifra, quindi inizia il contatore 1. La cifra precedente è memorizzata in $p.

Pyth , 13 11 byte

s.e*]hkhbr8

Provalo 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 byte grazie a Mr. Xcoder

Scala , 75 byte

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

Provalo online!

Se input e output devono essere separati da virgola String (e non List), quindi 102 byte.

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

Gelatina , 5 byte

nƝÄŻ‘

Provalo online!

Inizialmente miravo a un 4-byter (lo stesso programma ma senza il Ż ) ma poi capito rapidamente che un 1 doveva essere anteposto ogni volta a causa di una svista ... Anche se c'è un altro 5-byter in Jelly, io effettivamente mantenere questo perché utilizza un metodo diverso.

Per ogni coppia di elementi vicini dell'elenco di input $L$, prova se $L_i\ne L_{i+1}, \forall 1\le i<|L|$e salva questi risultati in un elenco. Quindi prendere la somma cumulativa di questo elenco e incrementarli di 1 in modo che corrispondano al sistema di indicizzazione dei blocchi. TL; DR. Ogni volta che incontriamo diversi oggetti vicini, incrementiamo l'indice del blocco di 1 .

JavaScript (ES6), 30 byte

Accetta l'input come una matrice di numeri interi.

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

Provalo online!

Commentate

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 byte

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

Provalo online!

Input da riga di comando, output a STDOUT .

Grazie a @ Night2 per il fastidioso '0' == 0bugfix di confronto!

Julia 1.0 , 56 byte

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

Provalo online!

Japt v2.0a0, 9 byte

£T±A¦(A=X

Provalo

Aggiungi ++ , 23 byte

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

Provalo online!

Come funziona

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 byte

ä¦Ug)åÄ

Provalo

Retina 0.8.2 , 34 byte

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

Provalo online! Spiegazione:

\b\d+\b

Abbina ogni numero a turno.

(?<=(...)*)

Inizia a guardare indietro per quante più partite possibili. (Le prossime voci saranno nell'ordine da destra a sinistra poiché è così che funziona lookbehind.)

\D*

Salta i separatori.

(\3|(\d+))

Prova ad abbinare lo stesso numero dell'ultima volta, ma in caso contrario, abbina qualsiasi numero, ma ricorda che abbiamo dovuto abbinare un nuovo numero.

\b

Assicurarsi che il numero intero sia abbinato.

$#3

Conta il numero di nuovi numeri.

Stax , 10 byte

▓ª2ªmD?Ä╧╖

Esegui ed esegui il debug

L'output utilizza lo spazio come delimitatore. L'input segue le specifiche precise utilizzando le virgole come separatori e ora racchiude le parentesi graffe.

C (gcc) , 62 61 byte

Questa è una delle poche voci che ho fatto in cui un programma completo è più breve di un invio di funzione!

Al primo passaggio, non mi interessa il valore precedente, quindi posso fare affidamento sul fatto che argvè un puntatore da qualche parte ed è estremamente improbabile che sia compreso tra [0..9]!

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

Provalo online!

Scala , 114 byte

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

Provalo online!

C (gcc) , 62 byte

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

Provalo online!

Una funzione che accetta l'elenco e la sua lunghezza come argomenti.

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

Provalo online!

Uscite in unario, delimitate da 0s