Sua tarefa hoje é escrever um programa ou função que utilize uma matriz de números inteiros e conte o número de vezes, lendo da esquerda para a direita, que o valor muda. Isso é mais fácil de mostrar com um exemplo:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Caso de teste:

Input           |   Output
[]              |   0
[0]             |   0
[0 1]           |   1
[0 0]           |   0
[1 2 3 17]      |   3
[1 1 1 2 2 3]   |   2
[-3 3 3 -3 0]   |   3

Isso é código-golfe , o menor número de bytes vence!

MATL , 2 bytes

dz

Experimente online! Ou verifique todos os casos de teste .

Explicação

     % Implicit input
d    % Consecutive differences
z    % Number of nonzeros
     % Implicit display

Python 3 , 38 bytes

f=lambda x=0,*y:y>()and(x!=y[0])+f(*y)

Experimente online!

Haskell , 33 bytes

f(a:b:r)=sum[1|a/=b]+f(b:r)
f _=0

Experimente online!

Bônus: Versão aritmética um pouco curiosa e sem pontos (44 bytes)

sum.(tail>>=zipWith((((0^).(0^).abs).).(-)))

Experimente online!

Dada uma entrada [1,1,4,3,3,3], primeiro pegamos a diferença das entradas adjacentes ( [0,3,-1,0,0]), depois o absvalor olute:[0,3,1,0,0] . Levando zero à potência de cada elemento na primeira vez [1,0,0,1,1], e uma segunda vez inverte a lista: [0,1,1,0,0]( (1-)também funcionaria aqui em vez de (0^)). Finalmente, pegamos o sumda lista para obter 2.

Python 2 , 42 bytes

lambda a:sum(x!=y for x,y in zip(a,a[1:]))

Experimente online!

Flacidez cerebral , 50 bytes

([][()]){{}({}[({})]){{}<>({}())(<>)}{}([][()])}<>

Experimente online!

Não produz nada para 0, o que no cérebro é equivalente. Se isso não for aceitável, acrescente-o a+4 bytes:({})

Explicação:

#Push stack-height-1
([][()])

#While true:
{

    #Pop the stack-height-1 off
    {}

    #If 'a' is the element on top of the stack, and 'b' is the element underneath it, then
    #Pop 'a' off, and push (a - b)
    ({}[({})])

    #If (a-b) is not 0...
    {
        #Pop (a-b) off
        {}

        #Switch stacks
        <>

        #Increment the value on the other stack
        ({}())

        #Push a 0 back to the main stack
        (<>)

    #Endif
    }

    #Pop either (a-b) or the 0 we pushed
    {}

    #Push stack-height-1
    ([][()])

#Endwhile
}

#Toggle to the alternate stack and display the counter
<>

Flacidez cerebral , 50 bytes

(([][()]){[{}]<({}[({})])>{(<{}>)()}{}([][()])}<>)

Experimente online!

# Get ready to push the answer
(

# Push stack height - 1
([][()])

# Loop until 0 (until the stack has a height of 1)
{

  # Pop the old stack height and subtract it 
  #(cancels the loop counter from the final answer)
  [{}]

  # Pop the top of the stack and subtract the next element from that
  # Don't include this in the final answer
  <({}[({})])>

  # If not 0
  {

    # Pop the difference between the last two numbers
    # Don't include this in the final answer
    (<{}>)

    # Add 1 to the final answer
    ()

  # End if
  }{}

  # Push stack height - 1
  ([][()])

# End while
}

# Switch to the off stack so we don't print anything extra
<>

# Push the total sum. This is the number of times the if was true
)

Haskell , 35 bytes

-8 bytes graças a H.PWiz.

Out-golfed por uma versão recursiva . Haskell é praticamente o melhor em recursão e eu perdi. > _ <

f l=sum[1|x<-zipWith(/=)l$tail l,x]

Experimente online!

Seria incrível se alguém descobrisse como empregar essa dica .

Solução alternativa, 36 bytes

f l=sum[1|True<-zipWith(/=)l$tail l]

Experimente online!

Java (OpenJDK 8) , 65 bytes

Não é tão curto quanto eu gostaria, mas isso é apenas Java para você.

Teste passando a matriz como uma lista delimitada por vírgula.

a->{int s=0,i=1;for(;i<a.length;s+=a[i-1]!=a[i++]?1:0);return s;}

Experimente online!

Casca , 3 bytes

Ltg

Experimente online!

Explicação

Ltg    Input: [1,1,1,2,2,3]
  g    Group equal elements together: [[1,1,1],[2,2],[3]]
 t     Drop the first group (if any): [[2,2],[3]]
L      Return the length of the list: 2

Ohm v2 , 3 bytes

ΔyΣ

Experimente online!

Explicação

Δ     absolute differences between consecutive elements
 y    sign: 1 if positive, -1 if negative, 0 if zero
  Σ   sum

Língua Wolfram (Mathematica) , 2324 26 29 bytes

Length@Split@#~Max~1-1&

Experimente online!

• -1 byte graças a Martin Ender!
• -2 bytes graças a JungHwan Min! bom uso de Split[].
• -3 bytes graças a totallyhuman!

uma pequena explicação:

Splitdividirá uma matriz em uma lista de listas (dos mesmos elementos), ou seja, se transformará {1, 2, 2, 3, 1, 1}em {{1}, {2, 2}, {3}, {1, 1}}. Então, Length@Split@#é a quantidade de segmentos consecutivos. Max[*****-1, 0]é usado para lidar com {}entrada.

Retina , 24 21 16 bytes

Graças a @MartinEnder por -3 bytes e percebendo um erro
-1 byte graças a @tsh
-4 bytes graças a @Leo

m`^(\S+)¶(?!\1$)

Experimente online!

Python simbólico , 120 117 bytes

Golpeou 3 bytes removendo uma conversão explícita para inteiro (usando unário +) para a variável do contador - isso significa que, se não houver alterações na matriz, a saída será em Falsevez de 0, mas isso é permitido por meta .

___=-~(_==_)
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___)
_=___

Experimente online!

# LINE 1: Generate value '2' for utility
___=-~(_==_)

# LINE 2: Get len(input) - 1
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
   '___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)'     # Generate string '___=~-len(_)'
            `_>_`[___::___]                       #    'le' spliced from 'False'
                           +`__`[-~___]           #    'n' indexed from '<function ...>'
   '___=~-'+                           +'(_)'     #    Remaining characters in plaintext
__(                                          )    # Execute this to get len(input) - 1

# LINE 3: Main calculation loop
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___) 
__(                                               ) # Execute:
   '__=___=_>_'                                     #   Set var1, var2 to 0
               +';                           '*___  #   len(input) - 1 times do:
                       _[__]!=_[-~__]               #   Compare input[var1, var1 + 1]
                  ___+=              ;              #   Add this to var2
                                      __=-~__       #   Increment var1

# LINE 4: Set output variable ('_') to the result calculated.
_=___                                       

Gelatina , 3 bytes

ITL

Experimente online!

Como funciona

ITL - Programa completo.

I - incrementos (deltas).
 T - Obtenha os índices de valores reais (obtém os índices de elementos diferentes de 0).
  L - comprimento.

K (oK) , 8 bytes

Solução:

+/1_~~':

Experimente online!

Exemplos:

+/1_~~':1 1 1 2 2 5 5 5 5 17 3
4
+/1_~~':()
0
+/1_~~':-3 3 3 -3 0
3

Explicação:

Interpretado da direita para a esquerda:

+/1_~~': / the solution
     ~': / equal each-previous
    ~    / not (ie differ)
  1_     / 1 drop, remove first as this is different to null
+/       / sum up trues

05AB1E , 3 bytes

¥ĀO

Experimente online!

Casca , 4 bytes

#IẊ≠

Experimente online!

R , 24 bytes

cat(sum(!!diff(scan())))

Experimente online!

O mesmo que a resposta MATL, usada apenas sum(!!diff))porque não há nnz.

Cubix , 24 bytes

UpO@0I>I!^-u>q.uvv$!^;)p

Experimente online

Observe que o Cubix usa 0 para indicar que não há mais entradas, portanto, 0 não pode estar na lista.

Explicação

Desdobrado:

    U p
    O @
0 I > I ! ^ - u
> q . u v v $ !
    ^ ;
    ) p

Começamos no 0, pressionando o contador (inicializado com 0) e a primeira entrada (I ) para a pilha.

Em seguida, entramos no loop. A cada iteração do loop, obtemos a próxima entrada com I. Se for 0, ficamos sem entradas, então giramos o contador para top ( p), Output e exit (@ ).

Caso contrário, consideramos a diferença dos dois principais elementos. Se for diferente de zero, giramos o contador para cima, incrementamos e giramos de volta para baixo com p)q. Em seguida, mostramos a diferença ;antes de passar para a próxima iteração.

Todos os caracteres não mencionados aqui são apenas controle de fluxo. Existem muitos programas nos programas Cubix.

Flacidez cerebral , 50 bytes

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

Experimente online!

Como todo mundo está postando suas soluções de 50 bytes aqui é minha (eu tenho uma de 48 bytes, mas foi uma modificação simples do DjMcMayhem, então achei que valha a pena postar)

Explicação

Esta resposta usa extensivamente o cancelamento de valor.

Sem golfe parece

([][()])({<{}({}[({})])>{<{}>()(<()>)}{}<([][()])>}<>)

Aqui, calculamos os delta's até que a pilha tenha um item restante, cada vez que acumulamos um valor do loop interno se o delta for diferente de zero.

Esta é uma maneira bastante direta de fazê-lo.

Para fazer este golfe, começamos o cancelamento de valor. O primeiro e o que deve ser óbvio para qualquer jogador endurecido de ataques cerebrais são as alturas das pilhas. É um fato bem conhecido que

([])({<{}>...<([])>}{})

é o mesmo que

(([]){[{}]...([])}{})

Quando os valores são modificados por um, o mesmo vale. Isso nos dá

(([][()]){[{}]<({}[({})])>{<{}>()(<()>)}{}([][()])}<>)

Você pode notar que isso nem nos salvou bytes, mas não se preocupe, isso se tornará mais útil à medida que prosseguimos.

Podemos realizar outra redução, se você vir uma declaração

<(...)>{<{}> ...

você pode reduzi-lo a

[(...)]{{} ...

Isso funciona porque se inserirmos o loop [(...)]e {}cancelar, e se não o fizermos, o valor de [(...)]já era zero em primeiro lugar e não precisará ser cancelado. Como temos uma ocorrência desse padrão em nosso código, podemos reduzi-lo.

(([][()]){[{}][({}[({})])]{{}()(<()>)}{}([][()])}<>)

Isso nos salvou 2 bytes, mas também colocou dois pontos negativos um ao lado do outro. Estes podem ser combinados para salvar outros 2.

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

E esse é o nosso código.

Perl 6 , 18 bytes

{sum $_ Z!= .skip}

Teste-o

Expandido:

{ # bare block lambda with implicit parameter ｢$_｣

  sum         # count the number of True values

      $_      # the input
    Z!=       # zip using &infix:«!=»
      .skip   # the input, but starting from the second value
              # (implicit method call on ｢$_｣
}

Gaia , 2 bytes

ėl

Experimente online!

Isso abusa de um bug (ou recurso?) Do Gaia, que a codificação do comprimento da execução não leva em consideração a última execução dos elementos. Observe que eu verifiquei duas vezes, ele funciona para todos os casos de teste.

• ė - Execute a codificação de comprimento (com a falha descrita acima).
• l - Comprimento.

JavaScript (ES6), 35 bytes

a=>a.filter((e,i)=>e-a[i+1]).length

Pitão, 5 bytes

l #.+

Suíte de teste.

Explicação:

   .+  Deltas
  #    Filter on identity (space)
l      Get length 

APL (Dyalog) , 8 bytes

+/2≠/⊃,⊢

Experimente online!

Quão?

⊃,⊢ - a lista, com o primeiro valor repetido para o caso de elemento único

2≠/ - lista de alterações, não é igual para cada 2 elementos

+/ - soma

Perl 5 , 37 + 2 ( -ap) = 39 bytes

$\+=$F[$_]!=$F[$_-1]for 1..$#F}{$\|=0

Experimente online!

J, 10 bytes

[:+/2~:/\]

Infixes de comprimento 2 ... são desiguais? 2 ~:/\ ]

Soma a lista resultante de 0s e 1s:+/

Experimente online!

Ruby , 31 bytes

->a{a.chunk{|x|x}.drop(1).size}

Experimente online!

C (gcc 5.4.0), 61 bytes

f(c,v)int*v;{int*p=v,s=0;for(;p<v+c-1;s+=*p++!=*p);return s;}

Experimente Online!

f é uma função que leva o comprimento da matriz e um ponteiro para o primeiro elemento da matriz e retorna o número de alterações na matriz;

Este envio utiliza um comportamento indefinido (*p++!=*p , p é usado duas vezes em uma expressão na qual é alterado), que funciona na minha máquina (gcc 5.4.0) e no TIO, mas pode não funcionar em outras implementações ou versões.

Explicação:

f(c,v)int*v;{ // old-style declaration for v, and implicit-int for c and return value
    int*p=v,s=0; // p is a pointer to the current item, s is the number of changes
    for(;p<v+c-1;s+=*p++!=*p); // for each consecutive pair of integers, if they are different, add one to the number of changes
    return s; // return the number of changes
}

05AB1E , 3 bytes

γ¦g

Experimente online!

Uma alternativa à resposta de Erik.

γ¦g ~ Programa completo.

γ ~ Agrupe em execuções de elementos adjacentes iguais.
 ¦ ~ Remova o primeiro grupo (se houver).
  g ~ comprimento.