0-1 সর্বাধিক পর্যায়ের কাউন্টার

21

বিটের একটি অ্যারে বিবেচনা করুন, বলুন

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

মজাদার ঘটনা: এই চ্যালেঞ্জটি টেম্পোরাল ডেটা পরিবর্তন সনাক্তকরণের লক্ষ্য সহ একটি ডেটা মাইনিং সমস্যা থেকে এসেছিল।

code-golf  array-manipulation 
— Sp3000
সূত্র
এটি যখন একটি সুসংগত সাবহারে সম্পর্কে প্রশ্ন। দৈর্ঘ্য ≥ 5 একটি পর্যায় যদি বিটগুলির কমপক্ষে 85% একই হয় তবে আমাদের দৈর্ঘ্য 5 এর মতো 5 1 1 0 1 1% এর 5% হল 4.25 যা দৈর্ঘ্য 5 অসম্ভব হবে বা আমাদের কি এটি 4 এর নিচে গোল করা উচিত?
— তেউন প্রোঙ্ক
@ টিউনপ্রঙ্ক এর অর্থ হ'ল সমস্ত বিট সমান না হলে দৈর্ঘ্য 5 অসম্ভব
— Sp3000
এটিতে যুক্ত করার জন্য আমি আমার মন্তব্য সম্পাদনা করতে যাচ্ছিলাম, সুতরাং এটি কোনও বৃত্তাকার নয় :)
— টিউন প্রোঙ্ক
সুতরাং আপনি কি বোঝাচ্ছেন যতটা সম্ভব সাবহারিগুলি খুঁজে পাওয়া বা যতটা সম্ভব বড় অ্যারেগুলি সন্ধান করতে চান? কারণ আমি টেস্টকেস 5 এ 1 এরও বেশি খুঁজে পাই (কোড অনুসারে নয় বরং দেখে)
— টিউন প্রোঙ্ক
@TununPronk আপনি যথাসম্ভব খুঁজে পেতে পারেন যা পুরোপুরি বড়দের মধ্যে নেই। ৫ ম পরীক্ষার ক্ষেত্রে এরকম একটি মাত্র অ্যারে রয়েছে, প্রথম থেকে শুরু করে 0শেষটিতে শেষ হবে।
— মার্টিন এন্ডার

উত্তর:

8

পাইথন 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
— GRC
সূত্র
5

পাইথন 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)

সাবসকেন্সগুলি প্রাথমিক উপাদান বাড়িয়ে, তারপরে দৈর্ঘ্য হ্রাস করে অর্ডার দিয়ে পরীক্ষা করা হয়। এইভাবে, এটি জানা যায় যে কোনও নতুন উপসর্গ পূর্ববর্তী অনুচ্ছেদের একটি অনুচ্ছেদ নয় যদি এর শেষ উপাদানটির সূচকটি পূর্ববর্তী সিক্যুয়েন্সের শেষ উপাদানটির কোনও সূচকের চেয়ে বেশি হয়।

— feersum
সূত্র
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-ম্যাট্রিক্স হয় x

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ব্যবহার করে এমনগুলিকে গণনা করুন +/∨/¨।

* এপিএলের জন্য একটি স্ট্যান্ডার্ড 1-বাইট এনকোডিং রয়েছে।

— Zgarb
সূত্র
ঠিক আছে, আমি কী জিজ্ঞাসা করছি তা ব্যাখ্যা করা শক্ত। আপনার যদি কোডটির আরও ভাল ব্যাখ্যা থাকে তবে আমি পুনরায় লিখতে পারতাম। আমি আপাতত আমার মন্তব্য মুছে ফেলব।
— অপ্টিমাইজার 13
@ অপ্টিমাইজার আমি ব্যাখ্যাটি প্রসারিত করেছি।
— জগারব
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)))))

ভালো callable: (s [0 1 0 1 0] 10 0)। এটিতে কয়েকটি অতিরিক্ত যুক্তি প্রয়োজন, তবে আমি অতিরিক্ত ২০ টি অক্ষরযুক্ত ব্যক্তিদের থেকে মুক্তি পেতে পারি।

— resueman
সূত্র
0

জাভাস্ক্রিপ্ট (ES6) 141

@ জিআরসি-এর অ্যালগরিদম জাভাস্ক্রিপ্ট ইনপুটটিতে পোর্ট করা
স্ট্রিং বা অ্যারে হতে পারে

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
— edc65
সূত্র
0

সিজেম, 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]

আউটপুট পর্যায়ক্রমে সংখ্যা।

এটি এখানে অনলাইনে চেষ্টা করুন

— অপ্টিমাইজার
সূত্র
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
— cPu1
সূত্র
1
কিছু গল্ফ কৌশল: -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
0

ওল্ফ্রাম - 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
— ফিটফাট
সূত্র
0

জাভা: 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();}}

পদ্ধতির (ইন [ইনপুট) কল করে চালান

— PoweredByRice
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.