งานของคุณในวันนี้คือการเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้อาร์เรย์จำนวนเต็มและนับจำนวนครั้งโดยอ่านจากซ้ายไปขวาว่าค่าเปลี่ยนไป นี่เป็นตัวอย่างที่แสดงได้ง่ายกว่า:[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

นี่คือcode-golfไบต์ที่น้อยที่สุดชนะ!

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]) แล้วabsค่า [0,3,1,0,0]olute: การนำศูนย์ไปสู่พลังของแต่ละองค์ประกอบในครั้งแรกที่ได้รับผลตอบแทน[1,0,0,1,1]และครั้งที่สองกลับรายการ: [0,1,1,0,0]( (1-)จะทำงานที่นี่แทน(0^)) ในที่สุดเราใช้เวลาของรายการที่จะได้รับsum2

Python 2 , 42 ไบต์

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

ลองออนไลน์!

Brain-Flakขนาด 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
<>

Brain-Flakขนาด 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

ออกแข็งแรงเล่นกอล์ฟโดยรุ่น recursive 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;}

ลองออนไลน์!

Huskขนาด 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

ภาษา Wolfram (Mathematica) , 2324 26 29 ไบต์

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

ลองออนไลน์!

• -1 ไบต์ขอบคุณ Martin Ender!
• -2 ไบต์ขอบคุณ JungHwan Min! Split[]การใช้งานที่ดีของ
• -3 ไบต์ขอบคุณโดยสิ้นเชิงมนุษย์!

คำอธิบายเล็กน้อย:

Splitจะแบ่งอาร์เรย์ลงในรายการของรายการ A (ขององค์ประกอบเดียวกัน), ที่อยู่, เปลี่ยนเข้าไป{1, 2, 2, 3, 1, 1} {{1}, {2, 2}, {3}, {1, 1}}ดังนั้นLength@Split@#ปริมาณ segements ต่อเนื่องคือ Max[*****-1, 0]ใช้เพื่อจัดการกับ{}อินพุต

Retina , 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

ลองออนไลน์!

Husk , 4 ไบต์

#IẊ≠

ลองออนไลน์!

R , 24 ไบต์

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

ลองออนไลน์!

เช่นเดียวกับคำตอบ MATL ที่ใช้เพียงเนื่องจากไม่มีsum(!!diff))nnz

Cubix , 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

Brain-Flakขนาด 50 ไบต์

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

ลองออนไลน์!

เนื่องจากทุกคนกำลังโพสต์โซลูชั่น 50 ไบต์ที่นี่เป็นของฉัน (ฉันมี48 ไบต์แต่เป็นการดัดแปลง DjMcMayhem ง่าย ๆ ดังนั้นฉันรู้สึกว่ามันคุ้มค่าที่จะโพสต์)

คำอธิบาย

คำตอบนี้ใช้การยกเลิกค่าอย่างกว้างขวาง

Un-golfed ดูเหมือนว่า

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

ที่นี่เราคำนวณเดลต้าจนกว่าสแต็กจะมีหนึ่งรายการที่เหลือแต่ละครั้งที่เราสะสมหนึ่งค่าจากลูปด้านในหากเดลต้าไม่ใช่ศูนย์

นี่เป็นวิธีการทำตรงไปตรงมา

เพื่อให้กอล์ฟนี้เราเริ่มต้นการยกเลิกค่า อันแรกและอันที่ควรจะเห็นได้จากนักกอล์ฟที่มีสมองที่แข็งกระด้างคือความสูงของกอง มันเป็นความจริงที่รู้จักกันดีว่า

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

เป็นเช่นเดียวกับ

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

เมื่อค่าถูกแก้ไขโดยหนึ่งค่าเดียวกันจะถูกเก็บไว้ สิ่งนี้ทำให้เรา

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

คุณอาจสังเกตเห็นว่าสิ่งนี้ไม่ได้ช่วยให้เราประหยัดไบต์ แต่ไม่ต้องกังวลว่ามันจะมีประโยชน์มากขึ้นเมื่อเราดำเนินการต่อไป

เราสามารถดำเนินการลดลงอีกหากคุณเห็นคำสั่ง

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

คุณสามารถลดได้จริง

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

สิ่งนี้ทำงานได้เพราะถ้าเราเข้าสู่ลูป[(...)]และ{}จะยกเลิกและหากเราไม่ได้ค่า[(...)]เป็นศูนย์ในตอนแรกและไม่จำเป็นต้องถูกยกเลิก เนื่องจากเรามีรูปแบบนี้เกิดขึ้นในรหัสของเราเราจึงสามารถลดได้

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

นั่นช่วยเราได้ 2 ไบต์ แต่มันยังใส่ negs สองตัวที่อยู่ติดกัน สิ่งเหล่านี้สามารถนำมารวมกันเพื่อช่วยเราอีก 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 ｢$_｣
}

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

ลองออนไลน์!

Ruby , 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

ลองออนไลน์!

อีกทางเลือกหนึ่งสำหรับคำตอบของ Erik

Fullg ~ โปรแกรมเต็มรูปแบบ

γ ~ จัดกลุ่มเป็นองค์ประกอบที่อยู่ติดกัน
 ¦ ~ ลบกลุ่มแรก (ถ้ามี)
  g ~ ความยาว