비트 배열을 고려하십시오.

1 1 1 0 0 0 0 1 0 0 1 0 1 1 1 1 1 0 1 0

비트의 85 % 이상이 동일하고 첫 번째 / 마지막 비트가 모두 다수 비트와 동일한 경우 길이가 5 이상인 연속 서브 어레이를 위상 이라고합니다. 또한 다른 위상의 엄격한 하위 배열이 아닌 경우 위상을 최대 값 이라고합니다.

위 예제의 최대 단계는 다음과 같습니다.

1 1 1 0 0 0 0 1 0 0 1 0 1 1 1 1 1 0 1 0
      -------------
                    -------------
                        -------------

보시다시피, 3최대 단계가 있습니다. 한편, 이것

1 1 1 0 0 0 0 1 0 0 1 0 1 1 1 1 1 0 1 0
                        ---------

그것은 적어도 하나의 다른 위상의 엄격한 서브 어레이이기 때문에 최대 위상이 아니다.

도전

입력은 STDIN, 명령 행 또는 함수 인수를 통한 5 비트 이상의 시퀀스입니다. 비트는 문자열 또는 배열로 제공 될 수 있습니다.

STDOUT을 통해 인쇄되거나 함수에서 반환 된 배열의 최대 위상 수인 단일 정수를 출력해야합니다.

채점

이것은 코드 골프이므로 가장 적은 바이트의 프로그램이 승리합니다.

테스트 사례

0 1 0 1 0 -> 0
0 0 0 0 0 -> 1
0 0 0 0 1 0 1 1 1 1 -> 0
0 0 0 0 0 1 0 1 1 1 1 1 -> 2
1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 -> 1
0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 -> 2
0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 -> 1
0 1 0 1 0 0 1 0 1 0 1 0 0 0 1 1 1 1 0 1 0 0 1 1 0 0 0 1 1 0 -> 0
1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 -> 4
0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 0 0 0 0 -> 5

마지막 경우에 대한 설명은 다음과 같습니다.

0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 0 0 0 0
---------------------------
      -------------------------
                            -----------------
                                -----------------
                                              -------------

^{재미있는 사실 :이 과제는 시간적 데이터의 변화를 감지한다는 목표를 가진 데이터 마이닝 문제에서 비롯되었습니다.}

Dyalog APL, 62 자

{≢∪0~⍨+/∨⍀∨\⌽∘.{((⊃=⊃∘⌽)∧(.85≤(+/⊢=⊃)÷≢)∧5≤≢)(⍺-1)↓⍵↑a}⍨⍳⍴a←⍵}

Zgarb의 솔루션과 유사하지만 조금 더 골프를 쳤다.

파이썬 2, 149 바이트

a=input()
l=len(a)
n=p=0
for i in range(l):
 for j in range(l-1,i+3,-1):
  if(j>p)>(.15<sum(a[i:j+1])/(j+1.-i)+a[i]+a[j]<2.85):n+=1;p=j;break
print n

첫 번째 루프는 어레이에서 왼쪽에서 오른쪽으로 스캔합니다. 로 색인 된 각 비트 i는 최대 단계에서 첫 번째 비트가 될 수 있는지 확인합니다.

이것은 내부 루프에 의해 수행되며, 오른쪽에서 왼쪽으로 스캔합니다. i와 사이에 하위 배열이 있으면 j카운터를 늘리고 계속 진행합니다. 그렇지 않으면 하위 배열이 너무 작아 지거나 j 이전 최대 단계의 끝에 도달 할 때까지 계속 진행합니다 .

1 1 1 0 0 0 0 1 0 0 1 0 1 1 1 1 1 0 1 0
i ->                               <- j

예:

$ python phase.py
[1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0]
3

파이썬 2, 144

형식으로 입력을 입력하십시오 [0,1,0,1,0].

a=input()
o=[2];i=-1
while a[i:]:
 j=len(a);i+=1
 while j>i+4:o+=sum(j>max(o)>x==a[i]==a[j-1]for x in a[i:j])*20/(j-i)/17*[j];j-=1
print~-len(o)

하위 시퀀스는 초기 요소를 증가시킨 다음 길이를 줄임으로써 순서대로 점검됩니다. 이러한 방식으로, 새로운 서브 시퀀스는 마지막 요소의 인덱스가 이전에 발견 된 시퀀스의 마지막 요소의 인덱스보다 큰 경우 이전 서브 시퀀스의 서브 시퀀스가 ​​아닌 것으로 알려져있다.

Dyalog APL, 86 바이트 *

{+/∨/¨∪↓∨⍀∨\{⊃({(.5>|k-⍵)∧.35≤|.5-⍵}(+/÷⍴)⍵)∧(5≤⍴⍵)∧(⊃⌽⍵)=k←⊃⍵}¨⌽∘.{(⍺-1)↓⍵↑t}⍨⍳⍴t←⍵}

여기에서 시도하십시오. 용법:

   f ← {+/∨/¨∪↓∨⍀∨\{⊃({(.5>|k-⍵)∧.35≤|.5-⍵}(+/÷⍴)⍵)∧(5≤⍴⍵)∧(⊃⌽⍵)=k←⊃⍵}¨⌽∘.{(⍺-1)↓⍵↑t}⍨⍳⍴t←⍵}
   f 0 0 0 0 0 1 0 1 1 1 1 1
2

이것은 아마도 위상 조건이 확인되는 중간 부분, 특히 중간 부분에서 골프를 칠 수 있습니다.

설명

먼저 입력 벡터의 하위 문자열을 행렬로 수집합니다. 여기서 왼쪽 위 모서리에는를 사용하여 전체 입력이 포함됩니다 ⌽∘.{(⍺-1)↓⍵↑t}⍨⍳⍴t←⍵. 입력 0 0 0 0 0 1 0의 경우이 행렬은

┌───────────────┬─────────────┬───────────┬─────────┬───────┬─────┬───┬─┐
│1 0 0 0 0 0 1 0│1 0 0 0 0 0 1│1 0 0 0 0 0│1 0 0 0 0│1 0 0 0│1 0 0│1 0│1│
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0 0 0 0 0 1 0  │0 0 0 0 0 1  │0 0 0 0 0  │0 0 0 0  │0 0 0  │0 0  │0  │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0 0 0 0 1 0    │0 0 0 0 1    │0 0 0 0    │0 0 0    │0 0    │0    │   │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0 0 0 1 0      │0 0 0 1      │0 0 0      │0 0      │0      │     │   │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0 0 1 0        │0 0 1        │0 0        │0        │       │     │   │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0 1 0          │0 1          │0          │         │       │     │   │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│1 0            │1            │           │         │       │     │   │ │
├───────────────┼─────────────┼───────────┼─────────┼───────┼─────┼───┼─┤
│0              │             │           │         │       │     │   │ │
└───────────────┴─────────────┴───────────┴─────────┴───────┴─────┴───┴─┘

그런 다음 위상의 조건을 매핑하여 0-1 행렬을 만듭니다.

0 0 0 0 0 0 0 0
1 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

최대 단계 수를 얻으려면을 1사용하여를 오른쪽 아래로 플러딩합니다 ∨⍀∨\.

0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1

와 고유 행을 수집 ∪↓,

┌───────────────┬───────────────┐
│0 0 0 0 0 0 0 0│1 1 1 1 1 1 1 1│
└───────────────┴───────────────┘

를 1사용하여 하나 이상을 포함하는 항목을 계산합니다 +/∨/¨.

^{* APL에는 표준 1 바이트 인코딩이 있습니다.}

클로저, 302

(defn p[v l](if(or(<(count v)5)(= 0 l))nil(if((fn[v](let[f(first v)c(apply + v)o(count v)r(/ c o)t(+ f f r)](and(= f(last v))(or(> t 2.85)(< t 0.15)))))v)0(let[r(p(vec(drop-last v))(dec l))](if r(+ r 1)r)))))(defn s[v l c](if(empty? v)c(let[n(p v l)](if n(s(vec(rest v))n(inc c))(s(vec(rest v))l c)))))

그리고 약간 ungolfed 버전

(defn is-phase [vector]
  (let [f (first vector)
        c (apply + vector)
        o (count vector)
        r (/ c o)
        t (+ f f r)]
    (and (= f (last vector))
         (or (> t 2.85) (< t 0.15)))))
(defn phase-index [vector last]
  (if (or (<(count vector)5)(= 0 last)) nil
    (if (is-phase vector) 0
      (let [r (phase-index (vec(drop-last vector)) (dec last))]
        (if r (+ r 1) r)))))
(defn phase-count [vector last count]
  (if (empty? vector) count
    (let [n (phase-index vector last)]
         (if n (phase-count (vec(rest vector)) n (inc count))
             (phase-count (vec(rest vector)) last count)))))

다음과 같이 호출 가능 : (s [0 1 0 1 0] 10 0). 몇 가지 추가 인수가 필요하지만 추가로 20자를 가진 문자를 제거 할 수 있습니다.

자바 스크립트 (ES6) 141

JavaScript
입력으로 포팅 된 @grc의 알고리즘 은 문자열 또는 배열 일 수 있습니다

F=b=>
  (l=>{
    for(c=e=i=0;i<l;++i)
      for(j=l;j>i+4&j>e;--j)
        (k=0,[for(d of b.slice(i,j))k+=d==b[i]],k<(j-i)*.85)|b[i]-b[j-1]||(++c,e=j)
  })(b.length)|c

FireFox / FireBug 콘솔에서 테스트

;['01010', '00000', '0000101111',
'000001011111', '100000000000010',
'0000010000010000010', '00000100000100000100',
'010100101010001111010011000110',
'111110000011111001000000001101',
'011000000000001011111110100000'].forEach(t => console.log(t,F(t)))

산출

01010 0
00000 1
0000101111 0
000001011111 2
100000000000010 1
0000010000010000010 2
00000100000100000100 1
010100101010001111010011000110 0
111110000011111001000000001101 4
011000000000001011111110100000 5

CJam, (110) 103 바이트

오래 Pre 다. 골프를 많이 할 수 있습니다.

q~_,,\f>{_,),5>\f<{:X)\0==X1b_X,.85*<!\.15X,*>!X0=!*\X0=*+&},:,W>U):U+}%{,(},_{{_W=IW=>\1bI1b>!&!},}fI,

입력은 같다

[0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 0 0 0 0]

출력은 위상 수입니다.

여기에서 온라인으로 사용해보십시오

자바 스크립트 (ECMAScript를 6), 148 (139) 바이트

f=(s,l=0,e=0,p=0)=>{for(n=s.length,o=[j=0,y=0],i=l;i<n;++j>4&x==s[l]&i>e&c>=.85‌​*j&&(e=i,y=1))c=++o[x=s[i++]];return l-n?f(s,l+1,e,p+y):p}

배열을 반복하고 마지막 재귀 색인에서 반복을 시작합니다. 인수는 배열 또는 문자열 일 수 있습니다.

f('011000000000001011111110100000'); //5

볼프람-131

{x_, X___}⊕{Y__, x_, y___}/;MemberQ[t={x, X, Y, x}, 1-x] && t~Count~x > .85 Length@t := 
  1 + {X, Y, x}⊕{y} 
{_, X___}⊕y_ := {X}⊕y
{}⊕{y_, Y__} := {y}⊕{Y}
_⊕_ := 0

예

{}⊕{1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0}
> 3
{}⊕{0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,1,1,0,1,0,0,0,0,0}
> 5

자바 : 771 바이트

import java.util.*;public class A{static int[]a;static class b{int c,d,e,f,g,h;b(int i,int j){this.c=i;this.d=j;this.h=j-i+1;this.e=k();this.f=this.h-this.e;this.g=e>f?1:0;}
boolean l(b n){return this.c>=n.c&&this.d<=n.d;}
int k(){int o=0;for(int i=c;i<=d;i++){if(a[i]==1){o++;}}
return o;}
public boolean equals(Object o){b x=(b)o;return x.c==this.c&&x.d==this.d;}
float p(){if(g==0){return(float)f/h;}else{return(float)e/h;}}
boolean q(){float r=p();return a[c]==a[d]&&a[d]==g&&r>=0.85F;}}
static int s(int[]t){a=t;List<b>u=new ArrayList<>();for(int v=0;v<t.length-4;v++){int x=v+4;while(x<t.length){b y=new b(v,x);if(y.q()){u.add(y);}
x++;}}
List<b>a=new ArrayList<>();for(b c:u){for(b d:u){if(!c.equals(d)&&c.l(d)){a.add(c);break;}}}
u.removeAll(a);return u.size();}}

메소드 s (int [] 입력)를 호출하여 실행