Il tuo compito oggi è quello di scrivere un programma o una funzione che accetta un array di numeri interi e conta il numero di volte, leggendolo da sinistra a destra, che il valore cambia. Questo è più facile da mostrare con un esempio:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Caso di prova:

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

Questo è code-golf , vince meno byte!

MATL , 2 byte

dz

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Python 3 , 38 byte

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

Provalo online!

Haskell , 33 byte

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

Provalo online!

Bonus: versione aritmetica un po 'curiosa senza punti (44 byte)

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

Provalo online!

Dato un input [1,1,4,3,3,3], abbiamo prima dare la differenza di voci adiacenti ( [0,3,-1,0,0]), allora il absvalore olute: [0,3,1,0,0]. Portando zero alla potenza di ogni elemento la prima volta produce [1,0,0,1,1], e una seconda volta inverte la lista: [0,1,1,0,0]( (1-)funzionerebbe anche qui invece di (0^)). Infine prendiamo sumla lista per ottenere 2.

Python 2 , 42 byte

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

Provalo online!

Brain-Flak , 50 byte

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

Provalo online!

Non restituisce nulla per 0, che in scaglie di cervello è equivalente. Se ciò non è accettabile, aggiungere questo per+4 byte:({})

Spiegazione:

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

Brain-Flak , 50 byte

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

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

-8 byte grazie a H.PWiz.

Fuori campo da una versione ricorsiva . Haskell è praticamente il migliore alla ricorsione e l'ho perso. > _ <

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

Provalo online!

Sarebbe fantastico se qualcuno capisse come utilizzare questo suggerimento .

Soluzione alternativa, 36 byte

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

Provalo online!

Java (OpenJDK 8) , 65 byte

Non corto come vorrei, ma è solo Java per te.

Test passando la matrice come elenco delimitato da virgole.

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

Provalo online!

Buccia , 3 byte

Ltg

Provalo online!

Spiegazione

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 byte

ΔyΣ

Provalo online!

Spiegazione

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

Wolfram Language (Mathematica) , 2324 26 29 byte

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

Provalo online!

• -1 byte grazie a Martin Ender!
• -2 byte grazie a JungHwan Min! buon uso di Split[].
• -3 byte grazie a totalmente umano!

una piccola spiegazione:

Splitdividerà un array in un elenco di liste (degli stessi elementi), ovvero trasformandole {1, 2, 2, 3, 1, 1}in {{1}, {2, 2}, {3}, {1, 1}}. Quindi, Length@Split@#è la quantità di segmenti consecutivi. Max[*****-1, 0]è usato per gestire l' {}input.

Retina , 24 21 16 byte

Grazie a @MartinEnder per -3 byte e notando un bug
-1 byte grazie a @tsh
-4 byte grazie a @Leo

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

Provalo online!

Python simbolico , 120 117 byte

Golfato 3 byte rimuovendo un cast esplicito su intero (usando unario +) per la variabile contatore - questo significa che se non ci sono cambiamenti nell'array, l'output sarà Falseinvece di 0, ma questo è consentito da meta .

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

Provalo 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.
_=___                                       

Jelly, 3 bytes

ITL

Try it online!

How it works

ITL  - Full program.

I    - Increments (deltas).
 T   - Get the indices of truthy values (gets the indexes of non-0 elements).
  L  - Length.

K (oK), 8 bytes

Solution:

+/1_~~':

Try it online!

Examples:

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

Explanation:

Interpreted right-to-left:

+/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

Try it online!

Husk, 4 bytes

#IẊ≠

Try it online!

R, 24 bytes

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

Try it online!

Same as the MATL answer, just used sum(!!diff)) since there's no nnz.

Cubix, 24 bytes

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

Try it online

Note that Cubix uses 0 to indicate that there are no more inputs, so 0 cannot be in the list.

Explanation

Unfolded:

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

We start at the 0, pushing the counter (initialized with 0) and the first input (I) onto the stack.

We then enter the loop. At each iteration of the loop, we get the next input with I. If it's 0, we've run out of inputs, so we rotate the counter to the top (p), Output, and exit (@).

Otherwise, we take the difference of the top two elements. If it's nonzero, we rotate the counter to the top, increment it, and rotate it back to the bottom with p)q. We then pop the difference with ; before moving to the next iteration.

All the characters not mentioned here are just control flow. There tend to be a lot of those in Cubix programs.

Brain-Flak, 50 bytes

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

Try it online!

Since everyone is posting their 50 byte solutions here is mine (I have a 48 byte one but it was a simple modification of DjMcMayhem's so I did feel it worth posting)

Explanation

This answer extensively uses value canceling.

Un-golfed it looks like

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

Here we compute the delta's until the stack has one item left, each time we accumulate one value from the inner loop if the delta is non zero.

This is a pretty straight forward way of doing it.

To make this golfy we begin value canceling. The first one and the one that should be obvious to any hardened brain-flak golfer is the stack heights. It is a well known fact that

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

is the same as

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

When the values are modified by one, the same holds. This gives us

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

You may notice this didn't even save us bytes, but don't fret it will become more useful as we go on.

We can perform another reduction, if you see a statement

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

you can actually reduce it to

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

This works because if we enter the loop [(...)] and {} will cancel, and if we don't the value of [(...)] already was zero in the first place and doesn't need to be canceled. Since we have an occurrence of this pattern in our code we can reduce it.

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

That saved us 2 bytes but it also put two negs next to each other. These can be combined to save us another 2.

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

And that's our code.

Perl 6, 18 bytes

{sum $_ Z!= .skip}

Test it

Expanded:

{ # 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

Try it online!

This abuses a bug (or feature?) of Gaia, that run-length-encoding doesn't take the last run of elements into account. Note that I have double checked, it works for all test cases.

• ė - Run length encoding (with the flaw described above).
• l - Length.

JavaScript (ES6), 35 bytes

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

Pyth, 5 bytes

l #.+

Test suite.

Explanation:

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

APL (Dyalog), 8 bytes

+/2≠/⊃,⊢

Try it online!

How?

⊃,⊢ - the list, with the first value repeated for the case of single element

2≠/ - changes list, not equal for every 2 elements

+/ - sum

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

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

Try it online!

J, 10 bytes

[:+/2~:/\]

Infixes of length 2... are they unequal? 2 ~:/\ ]

Sum the resulting list of 0s and 1s: +/

Try it online!

Ruby, 31 bytes

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

Try it 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;}

Try it Online!

f is a function taking the length of the array and a pointer to the first element of the array, and returning the number of changes in the array;

This submission utilizes undefined behavior (*p++!=*p, p is used twice in an expression in which it is changed), which works on my machine (gcc 5.4.0) and on TIO, but may not work on other implementations or versions.

Explanation:

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

Try it online!

An alternative to Erik's answer.

γ¦g  ~ Full program.

γ    ~ Group into runs of equal adjacent elements.
 ¦   ~ Remove the first group (if there are any).
  g  ~ Length.