오늘 과제는 정수 배열을 사용하고 값을 왼쪽에서 오른쪽으로 읽고 횟수가 변경되는 횟수를 계산하는 프로그램이나 함수를 작성하는 것입니다. 이것은 예제와 함께 표시하기가 더 쉽습니다.[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

파이썬 3 , 38 바이트

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

온라인으로 사용해보십시오!

하스켈 , 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취한 다음 olute 값 을 가져 옵니다 [0,3,1,0,0]. 각 요소 처음 수율의 전력을 제로 촬영 [1,0,0,1,1]하고, 두 번째 목록을 반전 : [0,1,1,0,0]( (1-)도 대신 여기서 일 것이다 (0^)). 마지막으로 sum목록 중 하나를 가져옵니다 2.

파이썬 2 , 42 바이트

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

온라인으로 사용해보십시오!

Brain-Flak , 50 바이트

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

온라인으로 사용해보십시오!

brain-flak에서 동등한 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
)

하스켈 , 35 바이트

H.PWiz 덕분에 -8 바이트

재귀 버전으로 아웃 골프 됨 . Haskell은 재귀에서 거의 최고이며 나는 그것을 놓쳤다. > _ <

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

온라인으로 사용해보십시오!

이 팁 을 사용하는 방법을 아는 사람이 있다면 좋을 것 입니다.

대체 솔루션, 36 바이트

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

온라인으로 사용해보십시오!

자바 (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

볼프람 언어 (수학) , 2324 26 29 바이트

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

온라인으로 사용해보십시오!

• Martin Ender 덕분에 -1 바이트!
• JungHwan Min 덕분에 -2 바이트! 좋은 사용 Split[].
• 완전히 인간적인 덕분에 -3 바이트!

약간의 설명 :

Split배열을 (동일한 요소로 된) 목록의 목록으로 {1, 2, 2, 3, 1, 1}나눕니다 {{1}, {2, 2}, {3}, {1, 1}}. 따라서 Length@Split@#연속적인 침강의 양입니다. 입력 Max[*****-1, 0]을 처리하는 데 사용됩니다 {}.

레티 나 , 24 21 16 바이트

-3 바이트에 대한 @MartinEnder
덕분에 @Leo 덕분에 @tsh -4 바이트 덕분에 버그 -1 바이트
에 주목

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

온라인으로 사용해보십시오!

기호 파이썬 , (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())))

온라인으로 사용해보십시오!

sum(!!diff))이 없으므로 MATL 답변과 동일합니다 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) O, 출력 및 종료 ( @)로 회전시킵니다 .

그렇지 않으면, 우리는 상위 두 요소의 차이를 취합니다. 0이 아닌 경우 카운터를 위쪽으로 회전시키고 증가시킨 다음을 사용하여 아래쪽으로 다시 회전시킵니다 p)q. 그런 다음 ;다음 반복으로 넘어 가기 전에 차이점을 찾아 냅니다.

여기에 언급되지 않은 모든 문자는 제어 흐름입니다. Cubix 프로그램에는 많은 것들이 있습니다.

Brain-Flak , 50 바이트

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

온라인으로 사용해보십시오!

모두가 여기에 50 바이트 솔루션을 게시하고 있기 때문에 ( 48 바이트를 가지고 있지만 DjMcMayhem의 간단한 수정이므로 게시 가치가 있다고 생각했습니다)

설명

이 답변은 값 취소를 광범위하게 사용합니다.

언 골프처럼 보입니다

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

델타가 0이 아닌 경우 내부 루프에서 하나의 값을 누적 할 때마다 스택에 하나의 항목이 남을 때까지 델타를 계산합니다.

이것은 매우 직접적인 방법입니다.

이 골프를 만들기 위해 우리는 가치 취소를 시작합니다. 첫 번째 및 강화 된 뇌-골프 골퍼에게 분명해야 할 것은 스택 높이입니다. 잘 알려진 사실은

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

와 같다

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

값이 하나씩 수정되면 동일하게 유지됩니다. 이것은 우리에게

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

이것이 우리에게 바이트를 저장하지 않았다는 것을 알 수 있지만 걱정하지 마십시오.

성명서를 보면 또 다른 감축을 할 수 있습니다

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

당신은 실제로 그것을 줄일 수 있습니다

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

이 작품은 우리가 루프를 입력하기 때문에 경우 [(...)]및 {}취소되며, 우리가 아닌 값을 할 경우 [(...)]이미 처음에 영 (0) 및 취소 할 필요가 없습니다. 코드에서이 패턴이 발생하면이를 줄일 수 있습니다.

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

그것은 우리에게 2 바이트를 절약했지만 두 개의 부정을 서로 옆에 두었습니다. 이것들을 결합하여 또 다른 2를 구할 수 있습니다.

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

그리고 그것은 우리의 코드입니다.

펄 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 - 길이.

자바 스크립트 (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≠/ -두 요소마다 동일하지 않은 변경 목록

+/ -합계

Perl 5 , 37 + 2 ( -ap) = 39 바이트

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

온라인으로 사용해보십시오!

J, 10 바이트

[:+/2~:/\]

길이 2의 접두사 ... 그들은 같지 않습니까? 2 ~:/\ ]

의 결과 목록 합계 0들과 1들 :+/

온라인으로 사용해보십시오!

루비 , 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의 답변에 대한 대안.

γ¦g ~ 전체 프로그램.

γ ~ 동일한 인접 요소의 런으로 그룹화합니다.
 ¦ ~ 첫 번째 그룹을 제거하십시오 (있는 경우).
  g ~ 길이.