พิจารณาอาร์เรย์ของบิตพูด

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

เราเรียก subarray ที่ต่อเนื่องกันที่มีความยาว≥ 5 a phaseถ้าอย่างน้อย 85% ของบิตเหมือนกันและบิตแรก / ครั้งสุดท้ายมีค่าเท่ากับบิตส่วนใหญ่ นอกจากนี้เราเรียกเฟสสูงสุดถ้ามันไม่ใช่ subarray ที่เข้มงวดของเฟสอื่น ๆ

นี่คือขั้นสูงสุดของตัวอย่างข้างต้น:

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

ไม่ใช่ระยะสูงสุดเนื่องจากเป็น subarray ที่เข้มงวดของเฟสอื่นอย่างน้อยหนึ่งตัว

ความท้าทาย

อินพุตเป็นลำดับ≥ 5 บิตผ่าน STDIN บรรทัดคำสั่งหรืออาร์กิวเมนต์ของฟังก์ชัน บิตอาจมาเป็นสตริงหรืออาร์เรย์

คุณจะส่งออกจำนวนเต็มเดียวจำนวนขั้นตอนสูงสุดสำหรับอาร์เรย์ทั้งพิมพ์ผ่าน 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 แต่เพิ่มขึ้นอีกเล็กน้อย

Python 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เป็นเฟสเราจะเพิ่มตัวนับและย้ายไป มิเช่นนั้นเราจะดำเนินต่อไปจนกว่า subarray จะเล็กเกินไปหรือ 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

Python 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's ไปทางขวาและลงโดยใช้∨⍀∨\,

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+/∨/¨

^{* มีการเข้ารหัสมาตรฐานขนาด 1 ไบต์สำหรับ 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)))))

และรุ่นที่ไม่ได้รับเกียรติเล็กน้อย

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

callable (s [0 1 0 1 0] 10 0)เช่นนี้ มันต้องมีข้อโต้แย้งเพิ่มเติมเล็กน้อย แต่ฉันสามารถกำจัดมันได้ด้วยอักขระพิเศษ 20 ตัว

JavaScript (ES6) 141

อัลกอริทึมของ @ grc ถูกย้ายไปยัง
อินพุตJavaScript สามารถเป็นสตริงหรืออาร์เรย์

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 ไบต์

Pretttttty ยาว สามารถเล่นกอล์ฟได้มาก

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]

เอาต์พุตคือจำนวนเฟส

ลองออนไลน์ได้ที่นี่

JavaScript (ECMAScript 6), 148 139 Bytes

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

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

Java: 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 [])