Ваше завдання сьогодні - написати програму або функцію, яка займає масив цілих чисел, і підраховує кількість разів, читаючи її зліва направо, щоб значення змінювалося. Це простіше показати на прикладі:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Тестовий випадок:

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

Це кодовий гольф , найменше виграш байтів!

MATL , 2 байти

dz

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

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

Python 3 , 38 байт

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

Спробуйте в Інтернеті!

Haskell , 33 байти

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

Спробуйте в Інтернеті!

Бонус: Дещо цікаво безриментована арифметична версія (44 байти)

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

Спробуйте в Інтернеті!

З огляду на вхід [1,1,4,3,3,3], ми спочатку беремо різницю суміжних записів ( [0,3,-1,0,0]), то absolute значення: [0,3,1,0,0]. Приймаючи нуль до потужності кожного елемента, перший раз поступається [1,0,0,1,1], а другий раз перевертає список: [0,1,1,0,0]( (1-)також буде працювати тут замість (0^)). Нарешті ми беремо sumсписок зі списку 2.

Python 2 , 42 байти

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

Спробуйте в Інтернеті!

Мозок-Флак , 50 байт

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

Спробуйте в Інтернеті!

Виводить нічого за 0, що в мозковому спаді є рівнозначним. Якщо це не прийнятно, додайте це до +4байтів:({})

Пояснення:

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

Мозок-Флак , 50 байт

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

Спробуйте в Інтернеті!

# 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 байт

-8 байт завдяки H.PWiz.

Поле для гольфу за рекурсивною версією . Haskell є майже найкращим у рекурсії, і я пропустив це. > _ <

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

Спробуйте в Інтернеті!

Було б дивовижно, якби хтось придумав, як використовувати цю пораду .

Черговий розчин, 36 байт

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

Спробуйте в Інтернеті!

Java (OpenJDK 8) , 65 байт

Не такий короткий, як хотілося б, але це лише Java для вас.

Тестуйте, передаючи масив як список, розділений комами.

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

Спробуйте в Інтернеті!

Лушпиння , 3 байти

Ltg

Спробуйте в Інтернеті!

Пояснення

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

Ом v2 , 3 байти

ΔyΣ

Спробуйте в Інтернеті!

Пояснення

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

Мова Вольфрама (Mathematica) , 2324 26 29 байти

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

Спробуйте в Інтернеті!

• -1 байт завдяки Мартіну Ендеру!
• -2 байти завдяки JungHwan Min! приємне використання Split[].
• -3 байти завдяки абсолютнолюдському!

невелике пояснення:

Splitподілить масив на список списків (з тих самих елементів), тобто перетвориться {1, 2, 2, 3, 1, 1}на {{1}, {2, 2}, {3}, {1, 1}}. Отже, Length@Split@#це кількість послідовних сегментів. Max[*****-1, 0]використовується для роботи з {}введенням даних.

Сітківка , 24 21 16 байт

Завдяки @MartinEnder за -3 байти та помітив помилку
-1 байт завдяки @tsh
-4 байти завдяки @Leo

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

Спробуйте в Інтернеті!

Символічний Python , 120 117 байт

Поле 3 байтів, видаливши явний перелік цілому числу (використовуючи унар +) для змінної лічильника - це означає, що якщо в масиві не буде змін, вихід буде Falseзамість 0, але це дозволено мета .

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

Спробуйте в Інтернеті!

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

Желе , 3 байти

ITL

Спробуйте в Інтернеті!

Як це працює

ITL - Повна програма.

I - збільшення (дельти).
 T - Отримайте індекси правдоподібних значень (отримує індекси не-0 елементів).
  L - довжина.

K (oK) , 8 байт

Рішення:

+/1_~~':

Спробуйте в Інтернеті!

Приклади:

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

Пояснення:

Інтерпретується справа наліво:

+/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 байти

¥ĀO

Спробуйте в Інтернеті!

Лушпиння , 4 байти

#IẊ≠

Спробуйте в Інтернеті!

R , 24 байти

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

Спробуйте в Інтернеті!

Те саме, що відповідь MATL, щойно використовується, sum(!!diff))оскільки немає nnz.

Кубікс , 24 байти

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

Спробуйте в Інтернеті

Зауважте, що Cubix використовує 0, щоб вказати, що більше немає входів, тому 0 не може бути у списку.

Пояснення

Розгорнуто:

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

Ми починаємо з 0, натискаючи лічильник (ініціалізований з 0) і перший вхід ( I) на стек.

Потім вводимо цикл. При кожній ітерації циклу ми отримуємо наступний вхід з I. Якщо це 0, у нас не вистачає входів, тому ми повертаємо лічильник до вершини ( p), Output та exit ( @).

В іншому випадку ми беремо різницю двох перших елементів. Якщо це ненульове значення, ми обертаємо лічильник до верху, збільшуємо його і повертаємо назад до низу p)q. Потім ми з'являємо різницю; перш ніж переходити до наступної ітерації.

Усі символи, які тут не згадуються, - це лише керування потоком. Їх, як правило, багато в програмах Cubix.

Мозок-Флак , 50 байт

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

Спробуйте в Інтернеті!

Оскільки всі публікують свої 50-байтні рішення, це моє (у мене є 48-байтне) байтне, але це була проста модифікація DjMcMayhem, тому я вважав, що варто опублікувати)

Пояснення

У цій відповіді широко використовується скасування значення.

Без гольфу це схоже

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

Тут ми обчислюємо дельти до тих пір, поки у стеку не залишиться один елемент, кожного разу ми накопичуємо одне значення з внутрішньої петлі, якщо дельта не дорівнює нулю.

Це досить прямий спосіб зробити це.

Щоб зробити цей гольф, ми починаємо скасовувати цінність. Перший і той, який повинен бути очевидним для будь-якого загартованого гольфіста, що займається мозку, - це висота стека. Загальновідомий факт, що

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

те саме, що

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

Коли значення модифікуються одним, те ж саме є. Це нам дає

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

Ви можете помітити, що це навіть не врятувало нас байтами, але не бідайте, воно стане кориснішим у міру продовження.

Ми можемо виконати ще одне зменшення, якщо ви побачите заяву

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

ви можете насправді зменшити його

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

Це працює, тому що якщо ми введемо цикл [(...)]і {}скасуємо, а якщо ми не зробимо значення, [(...)]було в першу чергу нульовим, і його не потрібно скасовувати. Оскільки у нас в коді є така модель, ми можемо її зменшити.

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

Це врятувало нас 2 байти, але також поставило два гнізда поруч. Їх можна комбінувати, щоб врятувати нас ще 2.

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

І це наш код.

Perl 6 , 18 байт

{sum $_ Z!= .skip}

Перевірте це

Розширено:

{ # 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 ｢$_｣
}

Гая , 2 байти

ėl

Спробуйте в Інтернеті!

Це зловживає помилкою (або особливістю?) Gaia, що кодування довжини виконання не враховує останній запуск елементів. Зауважте, що я перевірив двічі, він працює для всіх тестових випадків.

• ė - Запустити кодування довжини (із недоліком, описаним вище).
• l - Довжина.

JavaScript (ES6), 35 байт

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

Pyth, 5 байт

l #.+

Тестовий набір.

Пояснення:

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

APL (Dyalog) , 8 байт

+/2≠/⊃,⊢

Спробуйте в Інтернеті!

Як?

⊃,⊢ - список, з першим значенням, повтореним для випадку одного елемента

2≠/ - список змін, не рівний для кожні 2 елементи

+/ - сума

Perl 5 , 37 + 2 ( -ap) = 39 байт

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

Спробуйте в Інтернеті!

J, 10 байт

[:+/2~:/\]

Вставки довжиною 2 ... вони неоднакові? 2 ~:/\ ]

Підсумовуйте отриманий список 0s і 1s:+/

Спробуйте в Інтернеті!

Рубін , 31 байт

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

Спробуйте в Інтернеті!

C (gcc 5.4.0), 61 байт

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

Спробуйте в Інтернеті!

f - це функція, що приймає довжину масиву та вказівник на перший елемент масиву і повертає кількість змін у масиві;

У цьому поданні використовується невизначена поведінка ( *p++!=*p, p використовується двічі в виразі, в якому вона змінюється), яка працює на моїй машині (gcc 5.4.0) та TIO, але може не працювати в інших реалізаціях або версіях.

Пояснення:

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 байти

γ¦g

Спробуйте в Інтернеті!

Альтернатива відповіді Еріка.

γ¦g ~ Повна програма.

γ ~ Згрупуйте в прогони рівних сусідніх елементів.
 ¦ ~ Видаліть першу групу (якщо є).
  г ~ Довжина.