Twoim dzisiejszym zadaniem jest napisanie programu lub funkcji, która pobiera tablicę liczb całkowitych i liczy liczbę razy, odczytując od lewej do prawej, że wartość się zmienia. Łatwiej to pokazać na przykładzie:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Przypadek testowy:

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

To jest golf golfowy , wygrywa najmniej bajtów!

MATL , 2 bajty

dz

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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

Python 3 , 38 bajtów

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

Wypróbuj online!

Haskell , 33 bajty

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

Wypróbuj online!

Bonus: nieco ciekawa bezcelowa wersja arytmetyczna (44 bajty)

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

Wypróbuj online!

Biorąc pod uwagę wejście [1,1,4,3,3,3], najpierw wziąć różnicę sąsiednich wpisów ( [0,3,-1,0,0]), wówczas abswartość olute: [0,3,1,0,0]. Biorąc zero do potęgi każdego elementu za pierwszym razem [1,0,0,1,1], a drugi raz odwraca listę: [0,1,1,0,0]( (1-)działałoby tutaj również zamiast (0^)). Wreszcie bierzemy sumlistę, aby uzyskać 2.

Python 2 , 42 bajty

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

Wypróbuj online!

Brain-Flak , 50 bajtów

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

Wypróbuj online!

Nie wyprowadza nic dla 0, co w uderzeniu mózgu jest równoważne. Jeśli jest to nie do przyjęcia, dodaj to do +4bajtów:({})

Wyjaśnienie:

#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 bajtów

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

Wypróbuj 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 bajtów

-8 bajtów dzięki H.PWiz.

Wyprzedzony przez rekurencyjną wersję . Haskell jest prawie najlepszy w rekurencji i mi tego brakowało. > _ <

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

Wypróbuj online!

Byłoby wspaniale, gdyby ktoś wymyślił, jak zastosować tę wskazówkę .

Alternatywne rozwiązanie, 36 bajtów

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

Wypróbuj online!

Java (OpenJDK 8) , 65 bajtów

Nie tak krótki, jak bym chciał, ale to po prostu Java dla Ciebie.

Testuj, przekazując tablicę jako listę rozdzielaną przecinkami.

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

Wypróbuj online!

Łuska , 3 bajty

Ltg

Wypróbuj online!

Wyjaśnienie

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 bajty

ΔyΣ

Wypróbuj online!

Wyjaśnienie

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

Wolfram Language (Mathematica) , 2324 26 29 bajty

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

Wypróbuj online!

• -1 bajt dzięki Martin Ender!
• -2 bajty dzięki JungHwan Min! niezłe wykorzystanie Split[].
• -3 bajty dzięki totalnie ludzkiemu!

małe wyjaśnienie:

Splitpodzieli tablicę na listę list (tych samych elementów), czyli zamienia się {1, 2, 2, 3, 1, 1}w {{1}, {2, 2}, {3}, {1, 1}}. Tak więc Length@Split@#jest ilość kolejnych segmentów. Max[*****-1, 0]służy do radzenia sobie z {}danymi wejściowymi.

Siatkówka , 24 21 16 bajtów

Dzięki @MartinEnder za -3 bajty i zauważenie błędu
-1 bajt dzięki @tsh
-4 bajty dzięki @Leo

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

Wypróbuj online!

Symboliczny Python , 120 117 bajtów

Zmieniono w golfa 3 bajty, usuwając jawny rzut na liczbę całkowitą (przy użyciu unary +) dla zmiennej licznika - oznacza to, że jeśli nie ma żadnych zmian w tablicy, wyjście będzie Falsezamiast 0, ale jest to dozwolone przez meta .

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

Wypróbuj 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.
_=___                                       

Galaretka , 3 bajty

ITL

Wypróbuj online!

Jak to działa

ITL - Pełny program.

I - Przyrosty (delty).
 T - Uzyskaj indeksy prawdziwych wartości (pobiera indeksy elementów innych niż 0).
  L - długość.

K (oK) , 8 bajtów

Rozwiązanie:

+/1_~~':

Wypróbuj online!

Przykłady:

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

Wyjaśnienie:

Interpretowane od prawej do lewej:

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

¥ĀO

Wypróbuj online!

Łuska , 4 bajty

#IẊ≠

Wypróbuj online!

R , 24 bajty

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

Wypróbuj online!

Taki sam jak odpowiedź MATL, po prostu użyty, sum(!!diff))ponieważ nie ma nnz.

Cubix , 24 bajty

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

Wypróbuj online

Zauważ, że Cubix używa 0, aby wskazać, że nie ma już żadnych danych wejściowych, więc 0 nie może być na liście.

Wyjaśnienie

Rozłożony:

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

Zaczynamy od 0, wypychając licznik (zainicjowany za pomocą 0) i pierwsze wejście ( I) na stos.

Następnie wchodzimy w pętlę. Przy każdej iteracji pętli otrzymujemy kolejne dane wejściowe za pomocą I. Jeśli wynosi 0, zabrakło nam danych wejściowych, więc obracamy licznik do góry ( p), Output i exit ( @).

W przeciwnym razie bierzemy różnicę z dwóch górnych elementów. Jeśli jest niezerowy, obracamy licznik do góry, zwiększamy go i obracamy z powrotem do dołu za pomocą p)q. Następnie zaznaczamy różnicę ;przed przejściem do następnej iteracji.

Wszystkie postacie niewymienione tutaj są tylko kontrolą. W programach Cubix jest ich wiele.

Brain-Flak , 50 bajtów

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

Wypróbuj online!

Ponieważ wszyscy publikują swoje 50-bajtowe rozwiązania tutaj są moje (mam 48-bajtowe, ale była to prosta modyfikacja DjMcMayhem, więc czułem, że warto opublikować)

Wyjaśnienie

Ta odpowiedź w szerokim zakresie wykorzystuje anulowanie wartości.

Wygląda na to, że nie grał w golfa

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

Tutaj obliczamy deltę, aż na stosie pozostanie jeden element, za każdym razem, gdy gromadzimy jedną wartość z wewnętrznej pętli, jeśli delta nie jest równa zero.

Jest to dość prosty sposób na zrobienie tego.

Aby uczynić tego golfa, zaczynamy anulować wartość. Pierwszym i tym, który powinien być oczywisty dla każdego zahartowanego golfisty, jest wysokość stosu. Jest to dobrze znany fakt

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

jest taki sam jak

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

Gdy wartości są modyfikowane o jeden, to samo obowiązuje. To nam daje

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

Możesz zauważyć, że to nawet nie uratowało nam bajtów, ale nie przejmuj się, że stanie się to bardziej przydatne w miarę upływu czasu.

Możemy wykonać kolejną redukcję, jeśli zobaczysz oświadczenie

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

możesz to zredukować do

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

Działa to, ponieważ jeśli wejdziemy w pętlę [(...)]i {}anulujemy, a jeśli nie, wartość [(...)]już była zero na pierwszym miejscu i nie trzeba jej anulować. Ponieważ w kodzie mamy ten wzorzec, możemy go zmniejszyć.

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

To zaoszczędziło nam 2 bajty, ale także umieściło obok siebie dwa neg. Można je połączyć, aby uratować nam kolejne 2.

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

I to jest nasz kod.

Perl 6 , 18 bajtów

{sum $_ Z!= .skip}

Sprawdź to

Rozszerzony:

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

ėl

Wypróbuj online!

To nadużywa błędu (lub funkcji?) Gai, że kodowanie długości przebiegu nie bierze pod uwagę ostatniego ciągu elementów. Pamiętaj, że dwukrotnie sprawdziłem, działa dla wszystkich przypadków testowych.

• ė - Kodowanie długości przebiegu (z wadą opisaną powyżej).
• l - długość

JavaScript (ES6), 35 bajtów

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

Pyth, 5 bajtów

l #.+

Zestaw testowy.

Wyjaśnienie:

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

APL (Dyalog) , 8 bajtów

+/2≠/⊃,⊢

Wypróbuj online!

W jaki sposób?

⊃,⊢ - lista, z pierwszą wartością powtarzaną dla przypadku pojedynczego elementu

2≠/ - lista zmian, nie równa dla każdych 2 elementów

+/ - suma

Perl 5 , 37 + 2 ( -ap) = 39 bajtów

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

Wypróbuj online!

J, 10 bajtów

[:+/2~:/\]

Infiksy o długości 2 ... czy są nierówne? 2 ~:/\ ]

Zsumuj wynikową listę 0s i1 s:+/

Wypróbuj online!

Ruby , 31 bajtów

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

Wypróbuj online!

C (gcc 5.4.0), 61 bajtów

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

Wypróbuj online!

f jest funkcją przenoszącą długość tablicy i wskaźnik do pierwszego elementu tablicy i zwracającą liczbę zmian w tablicy;

To przesłanie wykorzystuje nieokreślone zachowanie (*p++!=*p , p jest używane dwukrotnie w wyrażeniu, w którym zostało zmienione), które działa na moim komputerze (gcc 5.4.0) i na TIO, ale może nie działać na innych implementacjach lub wersjach.

Wyjaśnienie:

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 bajty

γ¦g

Wypróbuj online!

Alternatywa dla odpowiedzi Erika.

γ¦g ~ Pełny program.

γ ~ Grupuj w serie równych sąsiadujących elementów.
 Remove ~ Usuń pierwszą grupę (jeśli istnieje).
  g ~ Długość.