0-1 मैक्सिमल फेज काउंटर

Question

बिट्स की एक सरणी पर विचार करें, कहते हैं

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

अगर हम कम से कम 85% बिट्स समान हैं और पहले / अंतिम बिट्स दोनों बहुमत बिट के बराबर हैं, तो हम एक सन्निहित उप-सीमा को uous 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, कमांड लाइन या फ़ंक्शन तर्क के माध्यम से bits 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
---------------------------
      -------------------------
                            -----------------
                                -----------------
                                              -------------

^{मजेदार तथ्य: यह चुनौती अस्थायी डेटा में परिवर्तन का पता लगाने के लक्ष्य के साथ डेटा माइनिंग समस्या से आई थी।}

Comments

सवाल जब इसके बारे में एक सन्निहित उपरि। लंबाई the 5 एक चरण यदि कम से कम 85% बिट्स समान हैं तो हम कहते हैं कि हमारी लंबाई 5 है जैसे 1 1 0 1 185% 5 4.25 है जो इतनी लंबाई 5 असंभव होगा या क्या हमें नीचे 4 को गोल करना चाहिए?

— त्यूण प्रैंक

@TeunPronk इसका मतलब है कि लंबाई 5 असंभव है जब तक कि सभी बिट एक समान न हों

— Sp3000

मैं इसे जोड़ने के लिए अपनी टिप्पणी को संपादित करने वाला था, इसलिए इसे नीचे राउंडिंग नहीं किया गया :)

— Teun Pronk

तो क्या आप संभव के रूप में के रूप में कई subarrays खोजने के लिए या संभव के रूप में arrays खोजने के लिए हैं? क्योंकि मुझे टेस्टकेस 5 में 1 से अधिक लगता है (कोड से नहीं बल्कि देखने से)

— तेउन प्रोन

@TeunPronk आपको अधिक से अधिक खोजने की आवश्यकता है जो पूरी तरह से बड़े लोगों में निहित नहीं हैं। 5 वें टेस्ट केस के लिए केवल एक ही एरे है, पहले पर शुरू 0होता है और आखिरी में खत्म होता है।

— मार्टिन एंडर

Answer 1

डायलाग एपीएल, 62 अक्षर

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

ज़र्गब के समाधान के समान लेकिन थोड़ा और आगे बढ़ा।

Answer 2

पायथन 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

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

प्रारंभिक तत्व को बढ़ाकर आदेश के साथ जांच की जाती है, फिर लंबाई कम हो जाती है। इस तरह, यह ज्ञात है कि एक नया परिणाम एक पूर्ववर्ती परिणाम के बाद का नहीं है यदि इसके अंतिम तत्व का सूचकांक पहले पाए गए अनुक्रम के अंतिम तत्व के किसी भी सूचकांक से अधिक है।

Answer 4

डायलॉग एपीएल, 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-बाइट एन्कोडिंग मौजूद है।}

Comments

खैर, इसकी कठिन व्याख्या करना कि मैं क्या पूछ रहा हूं। यदि आपके पास कोड की बेहतर व्याख्या होती, तो मैं फिर से पा सकता था। मैं अभी के लिए अपनी टिप्पणी हटा दूंगा।

— ऑप्टिमाइज़र

@ ओप्टिमाइज़र I ने स्पष्टीकरण का विस्तार किया।

— Zgarb

Answer 5

क्लोजर, 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 वर्ण वाले लोगों से छुटकारा पा सकता था।

Answer 6

जावास्क्रिप्ट (ईएस 6) 141

@ 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

फायरफॉक्स / फायरबग कंसोल में टेस्ट

;['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

Answer 7

CJam, 110 103 बाइट्स

प्रीटेटेट्टी लंबा। बहुत गोल्फ हो सकता है।

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]

आउटपुट चरणों की संख्या है।

इसे यहाँ ऑनलाइन आज़माएँ

Answer 8

जावास्क्रिप्ट (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

Comments

कुछ गोल्फ ट्रिक्स: -11 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}

— edc65

Answer 9

वोल्फ्राम - 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

Answer 10

जावा: 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();}}

कॉलिंग विधि (इंट [] इनपुट) द्वारा चलाएं