Ihre heutige Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die ein Array von ganzen Zahlen enthält und zählt, wie oft sich der Wert von links nach rechts ändert. Dies lässt sich leichter anhand eines Beispiels zeigen:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Testfall:

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

Das ist Code-Golf , die wenigsten Bytes gewinnen!

MATL , 2 Bytes

dz

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

     % 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)

Probieren Sie es online!

Haskell , 33 Bytes

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

Probieren Sie es online!

Bonus: Etwas merkwürdige punktfreie Rechenversion (44 Bytes)

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

Probieren Sie es online!

Ein Eingang gegeben [1,1,4,3,3,3], nehmen wir zuerst die Differenz benachbarter Einträge ( [0,3,-1,0,0]), dann der absquenten Wert: [0,3,1,0,0]. Wenn Sie beim ersten Mal die Potenz jedes Elements auf Null setzen, wird die [1,0,0,1,1]Liste beim zweiten Mal umgekehrt: [0,1,1,0,0]( (1-)würde auch hier funktionieren (0^)). Zum Schluss nehmen wir die sumvon der Liste, um sie zu bekommen 2.

Python 2 , 42 Bytes

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

Probieren Sie es online!

Brain-Flak , 50 Bytes

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

Probieren Sie es online!

Gibt nichts für 0 aus, was in brain-flak äquivalent ist. Wenn dies nicht akzeptabel ist, hängen Sie dies für +4Bytes an:({})

Erläuterung:

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

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

Probieren Sie es 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 dank H.PWiz.

Ausgolfen durch eine rekursive Version . Haskell ist so ziemlich der Beste in Rekursion und ich habe es verpasst. > _ <

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

Probieren Sie es online!

Es wäre fantastisch, wenn jemand herausfinden würde, wie man diesen Tipp einsetzt .

Alternative Lösung, 36 Bytes

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

Probieren Sie es online!

Java (OpenJDK 8) , 65 Byte

Nicht so kurz wie ich möchte, aber das ist nur Java für Sie.

Testen Sie, indem Sie das Array als kommagetrennte Liste übergeben.

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

Probieren Sie es online!

Schale , 3 Bytes

Ltg

Probieren Sie es online!

Erläuterung

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Σ

Probieren Sie es online!

Erläuterung

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

Wolfram Language (Mathematica) , 2324 26 29 Bytes

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

Probieren Sie es online!

• -1 Byte Danke an Martin Ender!
• -2 Bytes dank JungHwan Min! netter Gebrauch von Split[].
• -3 Bytes dank totalhuman!

eine kleine Erklärung:

Splitteilt ein Array in eine Liste von Listen (gleicher Elemente), das heißt {1, 2, 2, 3, 1, 1}in {{1}, {2, 2}, {3}, {1, 1}}. So Length@Split@#ist die Anzahl der aufeinanderfolgenden Segmente. Max[*****-1, 0]wird verwendet, um mit {}Eingaben umzugehen .

Retina , 24 21 16 Bytes

Danke an @MartinEnder für -3 Bytes und einen Bug
-1 Bytes dank @tsh
-4 Bytes dank @Leo

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

Probieren Sie es online!

Symbolisches Python , 120 bis 117 Bytes

Golfed 3 Bytes durch Entfernen einer expliziten Umwandlung in eine Ganzzahl (unter Verwendung von unary +) für die Zählervariable. Dies bedeutet, dass die Ausgabe Falsestattdessen erfolgt , wenn keine Änderungen im Array vorgenommen wurden. 0Dies ist jedoch durch Meta zulässig .

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

Probieren Sie es 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.
_=___                                       

Gelee , 3 Bytes

ITL

Probieren Sie es online!

Wie es funktioniert

ITL - Volles Programm.

I - Inkremente (Deltas).
 T - Liefert die Indizes der Wahrheitswerte (Liefert die Indizes von Nicht-0-Elementen).
  L - Länge.

K (oK) , 8 Bytes

Lösung:

+/1_~~':

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Interpretation von rechts nach links:

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

Probieren Sie es online!

Schale , 4 Bytes

#IẊ≠

Probieren Sie es online!

R , 24 Bytes

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

Probieren Sie es online!

Entspricht der MATL-Antwort, wird nur verwendet, sum(!!diff))da es kein gibt nnz.

Cubix , 24 Bytes

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

Probieren Sie es online aus

Beachten Sie, dass Cubix mit 0 angibt, dass keine weiteren Eingaben vorhanden sind, sodass 0 nicht in der Liste enthalten sein kann.

Erläuterung

Entfaltet:

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

Wir beginnen beim 0, indem wir den Zähler (initialisiert mit 0) und die erste Eingabe ( I) auf den Stapel legen.

Wir betreten dann die Schleife. Bei jeder Iteration der Schleife erhalten wir die nächste Eingabe mit I. Wenn es 0 ist, haben wir keine Eingaben mehr, also drehen wir den Zähler nach oben ( p), Output und exit ( @).

Ansonsten nehmen wir die Differenz der beiden obersten Elemente. Wenn es nicht Null ist, drehen wir den Zähler nach oben, inkrementieren ihn und drehen ihn mit nach unten zurück p)q. Wir machen dann den Unterschied mit, ;bevor wir zur nächsten Iteration übergehen.

Alle hier nicht erwähnten Zeichen sind nur Kontrollflüsse. In Cubix-Programmen gibt es in der Regel viele davon.

Brain-Flak , 50 Bytes

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

Probieren Sie es online!

Da jeder seine 50-Byte-Lösungen hier veröffentlicht, ist es meine (ich habe eine 48- Byte-Lösung, aber es war eine einfache Modifikation von DjMcMayhem, so dass ich es für sinnvoll hielt, sie zu veröffentlichen)

Erläuterung

In dieser Antwort wird häufig die Wertekompensation verwendet.

Ohne Golf sieht es aus

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

Hier berechnen wir die Deltas, bis der Stapel ein Element übrig hat, jedes Mal, wenn wir einen Wert aus der inneren Schleife akkumulieren, wenn das Delta nicht Null ist.

Dies ist ein ziemlich direkter Weg, dies zu tun.

Um diesen Golf zu spielen, beginnen wir mit der Wertaufhebung. Der erste und derjenige, der für gehärtete Brain-Flak-Golfer offensichtlich sein sollte, sind die Stapelhöhen. Es ist eine bekannte Tatsache, dass

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

ist das gleiche wie

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

Wenn die Werte um eins geändert werden, gilt dasselbe. Das gibt uns

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

Sie werden vielleicht bemerken, dass uns dies nicht einmal Bytes erspart hat, aber ärgern Sie sich nicht, dass es im weiteren Verlauf nützlicher wird.

Wir können eine weitere Reduktion durchführen, wenn Sie eine Aussage sehen

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

Sie können es tatsächlich reduzieren

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

Dies funktioniert, weil, wenn wir in die Schleife eintreten [(...)]und {}abbrechen, und wenn wir dies nicht tun, der Wert von [(...)]bereits an erster Stelle Null war und nicht abgebrochen werden muss. Da dieses Muster in unserem Code vorkommt, können wir es reduzieren.

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

Das hat uns 2 Bytes gespart, aber auch zwei Negative nebeneinander gelegt. Diese können kombiniert werden, um uns weitere 2 zu ersparen.

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

Und das ist unser Code.

Perl 6 , 18 Bytes

{sum $_ Z!= .skip}

Probier es aus

Erweitert:

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

Probieren Sie es online!

Dies missbraucht einen Fehler (oder eine Funktion?) Von Gaia, bei dem die Lauflängencodierung den letzten Lauf von Elementen nicht berücksichtigt. Beachten Sie, dass ich doppelt geprüft habe, es funktioniert für alle Testfälle.

• ė - Lauflängencodierung (mit dem oben beschriebenen Fehler).
• l - Länge.

JavaScript (ES6), 35 Byte

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

Pyth, 5 Bytes

l #.+

Testsuite.

Erläuterung:

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

APL (Dyalog) , 8 Bytes

+/2≠/⊃,⊢

Probieren Sie es online!

Wie?

⊃,⊢ - die Liste, wobei der erste Wert für den Fall eines einzelnen Elements wiederholt wird

2≠/ - Änderungsliste, nicht für alle 2 Elemente gleich

+/ - Summe

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

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

Probieren Sie es online!

J 10 Bytes

[:+/2~:/\]

Infixe der Länge 2 ... sind sie ungleich? 2 ~:/\ ]

Summiere die resultierende Liste von 0s und 1s:+/

Probieren Sie es online!

Ruby , 31 Bytes

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

Probieren Sie es 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;}

Probieren Sie es online!

f ist eine Funktion, die die Länge des Arrays und einen Zeiger auf das erste Element des Arrays nimmt und die Anzahl der Änderungen im Array zurückgibt;

Diese Übermittlung verwendet undefiniertes Verhalten ( *p++!=*p, p wird zweimal in einem Ausdruck verwendet, in dem es geändert wird), das auf meinem Computer (gcc 5.4.0) und in TIO funktioniert, jedoch möglicherweise nicht auf anderen Implementierungen oder Versionen funktioniert.

Erläuterung:

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

Probieren Sie es online!

Eine Alternative zu Eriks Antwort.

γ¦g ~ Volles Programm.

γ ~ Gruppiere in Reihen gleicher benachbarter Elemente.
 ¦ ~ Entfernen Sie die erste Gruppe (falls vorhanden).
  g ~ Länge.