Hãy xem xét một mảng các bit, nói

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

Chúng ta gọi một phân đoạn liền kề có độ dài ≥ 5 một pha nếu ít nhất 85% các bit giống nhau và các bit đầu tiên / cuối cùng đều bằng bit đa số. Hơn nữa, chúng tôi gọi là cực đại pha nếu nó không phải là phân đoạn nghiêm ngặt của một số pha khác.

Dưới đây là các giai đoạn tối đa của ví dụ trên:

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

Như bạn có thể thấy, có những 3pha tối đa. Mặt khác, điều này

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

không phải là một pha tối đa vì nó là một phân đoạn nghiêm ngặt của ít nhất một pha khác.

Các thách thức

Đầu vào là một chuỗi gồm 5 bit thông qua STDIN, dòng lệnh hoặc đối số hàm. Các bit có thể đi vào dưới dạng một chuỗi hoặc một mảng.

Bạn phải xuất một số nguyên duy nhất, số lượng pha tối đa cho mảng, được in qua STDOUT hoặc được trả về từ một hàm.

Chấm điểm

Đây là môn đánh gôn, vì vậy chương trình trong ít byte nhất sẽ thắng.

Các trường hợp thử nghiệm

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

Đây là lời giải thích cho trường hợp cuối cùng:

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

^{Sự thật thú vị: Thách thức này xuất phát từ một vấn đề khai thác dữ liệu với mục tiêu phát hiện sự thay đổi trong dữ liệu tạm thời.}

APL Dyalog, 62 ký tự

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

Tương tự như giải pháp của Zgarb nhưng chơi gôn xa hơn một chút.

Python 2, 149 byte

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

Vòng lặp đầu tiên quét qua mảng từ trái sang phải. Mỗi bit, được lập chỉ mục bởi i, được kiểm tra để xem liệu nó có thể là bit đầu tiên trong pha tối đa hay không.

Điều này được thực hiện bởi vòng lặp bên trong, quét từ phải sang trái. Nếu subarray giữa ivà jlà một pha, chúng ta tăng bộ đếm và di chuyển trên. Mặt khác, chúng ta tiếp tục cho đến khi phân đoạn trở nên quá nhỏ hoặc j đến cuối giai đoạn tối đa trước đó.

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

Thí dụ:

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

Trăn 2, 144

Nhập đầu vào trong mẫu [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)

Các kết quả được kiểm tra với thứ tự bằng cách tăng phần tử ban đầu, sau đó giảm độ dài. Theo cách này, người ta biết rằng một phần tiếp theo mới không phải là phần tiếp theo của phần trước đó nếu chỉ số của phần tử cuối cùng của nó lớn hơn bất kỳ chỉ mục nào của phần tử cuối cùng được tìm thấy trước đó.

APL Dyalog, 86 byte *

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

Hãy thử nó ở đây. Sử dụng:

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

Điều này có thể có thể được chơi golf khá nhiều, đặc biệt là phần giữa, nơi kiểm tra điều kiện pha.

Giải trình

Trước tiên tôi thu thập các chuỗi con của vectơ đầu vào thành một ma trận, trong đó góc trên bên trái chứa toàn bộ đầu vào, sử dụng ⌽∘.{(⍺-1)↓⍵↑t}⍨⍳⍴t←⍵. Đối với đầu vào 0 0 0 0 0 1 0, ma trận này là

┌───────────────┬─────────────┬───────────┬─────────┬───────┬─────┬───┬─┐
│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              │             │           │         │       │     │   │ │
└───────────────┴─────────────┴───────────┴─────────┴───────┴─────┴───┴─┘

Sau đó, tôi ánh xạ điều kiện là một pha trên nó, dẫn đến ma trận 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

Để có được số lượng pha tối đa, tôi tràn 1vào bên phải và xuống bằng cách sử dụng ∨⍀∨\,

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

thu thập các hàng độc đáo với ∪↓,

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

và đếm những cái có chứa ít nhất một cái 1sử dụng +/∨/¨.

^{* Tồn tại mã hóa 1 byte tiêu chuẩn cho APL.}

Clojure, 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)))))

và phiên bản hơi vô dụng

(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)))))

có thể gọi như thế này : (s [0 1 0 1 0] 10 0). Nó đòi hỏi một vài đối số bổ sung, nhưng tôi có thể loại bỏ những đối số có thêm 20 ký tự.

JavaScript (ES6) 141

Thuật toán của @ grc được chuyển sang JavaScript
Input có thể là một chuỗi hoặc một mảng

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

Kiểm tra trong bảng điều khiển FireFox / FireBug

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

Đầu ra

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

CJam, 110 103 byte

Pretttttty dài. Có thể chơi golf rất nhiều.

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

Đầu vào giống như

[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]

Đầu ra là số lượng pha.

Dùng thử trực tuyến tại đây

JavaScript (ECMAScript 6), 148 139 byte

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}

Đệ quy qua mảng và bắt đầu lặp ở chỉ số đệ quy cuối cùng. Đối số có thể là một mảng hoặc chuỗi.

f('011000000000001011111110100000'); //5

Sói - 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

Thí dụ

{}⊕{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

Java: 771 byte

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();}}

chạy bằng cách gọi phương thức s (int [] input)