एक क्रम में सबसे अधिक 1 के साथ विकल्प खोजें

Question

परिचय

मैं 1's 0' और 1's ' के क्रम में सबसे अधिक के साथ सबस्ट्रिंग खोजना चाहता हूँ ।

इनपुट

आपके प्रोग्राम में दो इनपुट , अनुक्रम और सबस्ट्रिंग लंबाई है।

अनुक्रम के किसी भी संख्या है 0की और 1की:

01001010101101111011101001010100010101101010101010101101101010010110110110

सबस्ट्रिंग लंबाई किसी भी सकारात्मक गैर शून्य पूर्णांक है:

5

उत्पादन

आपके प्रोग्राम को दी गई लंबाई के पहले विकल्प के शुरुआती इंडेक्स को आउटपुट करना चाहिए जिसमें सबसे अधिक है 1। उपरोक्त इनपुट के साथ, आउटपुट है:

10

स्ट्रिंग में पहला वर्ण इंडेक्स पर शुरू होता है 0।

स्कोरिंग

सबसे छोटा कोड जीतता है!

नियम

• आपके प्रोग्राम को हमेशा किसी भी मान्य इनपुट के लिए सही इंडेक्स का उत्पादन करना चाहिए।
• आप डिफ़ॉल्ट विकल्पों पर सकारात्मक स्कोर के साथ किसी भी जवाब से अपना इनपुट / आउटपुट विधि चुन सकते हैं । कृपया उस विधि को निर्दिष्ट करें जिसे आप अपने उत्तर में उठाते हैं।

Comments

आपका शीर्षक और परिचय कहता है "सबसे अधिक 1 के साथ प्रतिस्थापन खोजें"। लेकिन आपका कार्यक्रम विवरण कहता है कि आप एक सबरिंग लेंथ दे रहे हैं और पहले सबरिंग के सूचकांक की तलाश कर रहे हैं। तो क्या हमें यह मान लेना चाहिए कि शीर्षक और परिचय गलत हैं? ज्यादातर लोग पहले भाग को हल करते दिख रहे हैं। किसी जीत?

— स्वस्तिक

@swstephe मुझे यकीन नहीं है कि मैं आपका भ्रम समझता हूँ। यदि सबसे अधिक के लिए एक से अधिक सबस्ट्रिंग बंधे हैं 1, तो आप अपने द्वारा पाया गया पहला सबस्ट्रिंग आउटपुट करते हैं। आप उस विकल्प में पहले वर्ण के सूचकांक के साथ सबस्ट्रिंग की पहचान करते हैं। क्या उससे मदद हुई?

— hmatt1

ठीक है, इसलिए आप सबस्ट्रिंग में अनुक्रम को तोड़ रहे हैं और सबसे अधिक 1 के साथ पहले प्रतिस्थापन के सूचकांक को वापस कर रहे हैं? ऐसा लग रहा था जैसे आप 1 के सबस्ट्रिंग की तलाश में थे।

— स्वस्तिक

क्या आवश्यकता है "हमेशा किसी भी दिए गए इनपुट के लिए सही इंडेक्स को आउटपुट करना चाहिए" अभी भी लागू होता है यदि हम अचूक लंबाई देते हैं, जैसे लंबाई = 99?

— 3

@smci आप मान्य इनपुट के लिए मान सकते हैं। आपको एक ऐसे मामले को संभालने की ज़रूरत नहीं है जहाँ सबस्ट्रिंग की लंबाई अनुक्रम से अधिक लंबी हो।

— hmatt1

Answer 1

दिल्लोग एपीएल, 11

(-∘1+⍳⌈/)+/

इसे यहाँ आज़माएँ। उपयोग:

   f ← (-∘1+⍳⌈/)+/
   4 f 0 1 1 0 1 1 1 0 0 0 0 1 1
1

व्याख्या

यह एक डाईएडिक (बाइनरी अर्थ) फ़ंक्शन है जो बाईं ओर से सबस्ट्रिंग लंबाई और दाईं ओर से अनुक्रम लेता है। इसकी संरचना निम्नलिखित है:

   ┌───┴────┐
 ┌─┴──┐     /
 ∘  ┌─┼─┐ ┌─┘
┌┴┐ + ⍳ / +  
- 1   ┌─┘    
      ⌈      

विस्फोट से स्पष्टीकरण:

(-∘1+⍳⌈/)+/
(       )+/  ⍝ Take sums of substrings of given length, and feed to function in parentheses
    + ⌈/     ⍝ The array of sums itself, and its maximum
     ⍳       ⍝ First index of right argument in left
 -∘1         ⍝ Subtract 1 (APL arrays are 1-indexed)

उदाहरण के लिए, के लिए ले जाने 4और 0 1 1 0 1 1 1 0इनपुट के रूप में। पहले हम +/उनके लिए फंक्शन लागू करते हैं और प्राप्त करते हैं 2 3 3 3 3। फिर, +और ⌈/इस सरणी के लिए लागू खुद को और 3, और 2 3 3 3 3 ⍳ 3मूल्यांकन करता है 2, क्योंकि 3पहले दूसरे तत्व के रूप में होता है। हम अंतिम परिणाम के रूप में घटाते हैं 1और प्राप्त 1करते हैं।

Comments

आपके उदाहरण में, लंबाई 4 है, लेकिन एक पंक्ति (01101110) में 4 समान आइटम नहीं हैं, तो यह सब कुछ क्यों आउटपुट करता है?

— थॉमस वेलर

@ThomasW। चुनौती में उदाहरण के लिए एक पंक्ति में 5 समान आइटम नहीं हैं, और फिर भी आउटपुट 10 है। जिस तरह से मैं कार्य की व्याख्या करता हूं वह यह है कि मुझे दिए गए लंबाई के विकल्प के पहले सूचकांक को खोजने की आवश्यकता है जिसमें mलोग हैं, जहां mहै अधिक से अधिक।

— ज़र्गब

Answer 2

रूबी, ४२

f=->s,n{(0..s.size).max_by{|i|s[i,n].sum}}

इसे कॉल करके इनपुट लेता है, जैसे

f['01001010101101111011101001010100010101101010101010101101101010010110110110',5]

यह उनके कुल ASCII मूल्य का उपयोग करते हुए सब्सट्रिंग की तुलना करता है और अधिकतम का सूचकांक लौटाता है। मुझे यकीन नहीं है कि अगर max_byरूबी की कल्पना स्थिर होने की आवश्यकता है, लेकिन यह सी कार्यान्वयन में प्रतीत होता है।

Answer 3

अजगर 2, 56

lambda s,l:max(range(len(s)),key=lambda i:sum(s[i:i+l]))

पूर्णांक की एक सरणी को स्वीकार करता है, फिर लंबाई।

Comments

यह इनपुट के रूप में पूर्णांक की एक सरणी की जरूरत है, इसलिए यदि आप एक स्ट्रिंग के साथ शुरू करते हैं, तो आपको यह करने की आवश्यकता है:[int(s) for s in "010010...0"]

— एसएमएस

बग: f(ss, 999)0 (बदले में कोई नहीं) वापस आ जाएगा। क्या आप इसे ठीक कर सकते हैं? यह यकीनन नियम 1 का उल्लंघन करता है

— 3

@smci मुझे पता नहीं है कि आप किस बारे में बात कर रहे हैं। मुझे यह कैसे पता होना चाहिए कि चर में क्या है ss? Noneकिसी भी मामले में एक वांछित आउटपुट नहीं है क्योंकि उत्तर पूर्णांक है।

— फ़ेरसम

Answer 4

बैच - 222

बैच स्पष्ट रूप से इस तरह के ऑपरेशन के लिए एकदम सही भाषा है।

@echo off&setLocal enableDelayedExpansion&set s=%1&set l=-%2
:c
if defined s set/Al+=1&set "s=%s:~1%"&goto c
set s=%1&set x=0&for /l %%a in (0,1,%l%)do set c=!s:~%%a,%2!&set c=!c:0=!&if !c! GTR !x! set x=!c!&set y=%%a
echo !y!

गैर-गोल्फ / विच्छेदित:

प्रारंभिक व्यवस्था। चर sइनपुट स्ट्रिंग है, और इनपुट स्ट्रिंग lकी लंबाई होगी, उप-स्ट्रिंग की लंबाई शून्य (ऋणात्मक पर प्रारंभ %2जहां %2दी गई उप-स्ट्रिंग लंबाई है)।

@echo off
setLocal enableDelayedExpansion
set s=%1
set l=-%2

lशुद्ध बैच स्ट्रिंग लंबाई समाधान का उपयोग करते हुए इनपुट की लंबाई प्राप्त करें - यह sइनपुट स्ट्रिंग वाले चर का प्रबंधन करता है, इसलिए हम फिर से सेट करते हैं।

:c
if defined s (
    set /A l += 1
    set "s=%s:~1%"
    goto c
)
set s=%1

का मूल्य x उपयोग यह जांचने के लिए किया जाता है कि किस उप-स्ट्रिंग में सबसे बड़ी संख्या 1 थी। स्ट्रिंग की लंबाई से 0 से एक लूप शुरू करें, सब-स्ट्रिंग लंबाई (चर l) को घटाएं । लूप ( %%a) में वर्तमान बिंदु से शुरू होने वाला उप-स्ट्रिंग प्राप्त करें , cइनपुट स्ट्रिंग के रूप में शुरू हो रहा है %%a, और %2(दिए गए उप-स्ट्रिंग लंबाई) वर्ण ले रहा है। किसी भी 0s को हटा दिया जाता है c, उसके बाद के मूल्य की cतुलना की जाती है x- यानी 111इससे बड़ी संख्या है 11ताकि हम तुलना करने के लिए 'स्ट्रिंग' का उपयोग अधिक से अधिक कर सकें। yतब स्ट्रिंग में वर्तमान स्थान पर सेट किया जाता है - जो अंततः आउटपुट होता है।

set x=0
for /l %%a in (0, 1, %l%) do (
    set c=!s:~%%a,%2!
    set c=!c:0=!
    if !c! GTR !x! (
        set x=!c!
        set y=%%a
    )
)
echo !y!

ओपी उदाहरण का उपयोग करना -

h:\>sub1.bat 01001010101101111011101001010100010101101010101010101101101010010110110110 5
10

Answer 5

सी # (रेगेक्स), 196

class Test{static void Main(string[]a){System.Console.Write(System.Text.RegularExpressions.Regex.Match(a[1],"(?=((?<o>1)|0){"+a[0]+"})(?!.+(?=[10]{"+a[0]+"})(?!((?<-o>1)|0){"+a[0]+"}))").Index);}}

वास्तविक रेगेक्स लंबा नहीं है, लेकिन कोड के आकार को दोगुना करने के लिए एक सी # कार्यक्रम के लिए आवश्यक सभी फ़ुलज़ हैं।

वास्तविक रेगेक्स, जिसकी लंबाई 5 है:

(?=((?<o>1)|0){5})(?!.+(?=[10]{5})(?!((?<-o>1)|0){5}))

• (?=((?<o>1)|0){5}): बिना उपभोग के 5 अक्षर पढ़ने के लिए तत्पर रहें, और सभी 1को "स्टैक" में धकेलें o।
• (?=[10]{5})(?!((?<-o>1)|0){5}): ऐसी स्थिति में जिसके 5 वर्ण आगे हैं, "स्टैक" में पर्याप्त आइटम नहीं है o बाहर निकले, यानी 1वर्तमान स्थिति में जो हमारे पास है उससे अधिक सख्ती से प्रतिस्थापन है ।
• (?!.+(?=[10]{5})(?!((?<-o>1)|0){5})): ऊपर वर्णित स्थिति को स्ट्रिंग के बाकी हिस्सों के लिए नहीं पाया जा सकता है, अर्थात सभी स्थिति की संख्या कम या बराबर है 1 ।

पहला परिणाम लेना जवाब देता है, क्योंकि इसके सामने सभी सब्सट्रिंग्स में कुछ विकल्प हैं जो आगे के साथ अधिक हैं 1 और विकल्प हैं, और हमने जांच की है कि वर्तमान सूचकांक से बड़ा कोई भी सूचकांक संख्या के बराबर या उससे कम है 1।

(और मैं कुछ अच्छा सीखता हूं: "स्टैक" बैकट्रैकिंग पर बहाल है)।

Comments

बहुत अच्छा, मुझे अनुमान नहीं था कि आप इसे रेगेक्स के साथ कर सकते हैं।

— हिस्टोक्रेट

Answer 6

अजगर , १२

Mho/<>GNHZUG

यह एक फ़ंक्शन को परिभाषित करता है g, जिसे इनपुट के रूप में संख्याओं की संख्या और संख्या की आवश्यकता होती है। उदाहरण के लिए

Mho/<>GNHZUGg[0 1 0 0 1 0 1 0 1 0 1 1 0 1 1 1 1 0 1 1 1 0 1 0 0 1 0 1 0 1 0 0 0 1 0 1 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0 1 1 0 1 0 1 0 0 1 0 1 1 0 1 1 0 1 1 0)5

आप इसका परीक्षण यहां कर सकते हैं: पाइथ कंपाइलर / एक्ज़ीक्यूटर

स्पष्टीकरण:

Mho/<>GNHZUG
M             defines a function g(G,H), G is the sequence, H the sequence length
  o       UG  orders the numbers between 0 and len(G)-1 according to the following key
    <>GNH     take the subsequence G[N:N+5]
   /     Z    count the zeros in this subsequence (this is the key)
 h            return the first value of the sorted list (minimum)

वैकल्पिक:

Mho_s<>GNHUG

Comments

आप मानों की एक स्ट्रिंग (01001 ...) प्रोग्राम का उपयोग करके एक ही लंबाई का उत्तर प्राप्त कर सकते हैं ... फिर संख्या: ho/<>zNQ\0Uzअफसोस की बात है, एक स्ट्रिंग पर भरोसा ऑटो-कन्वर्ट नहीं करता है जो आप एक स्ट्रिंग के लिए देख रहे हैं :(

— FryAmTheEggman

Answer 7

जे, 15 14 वर्ण

   ([:(i.>./)+/\)

   5 ([:(i.>./)+/\) 0 1 0 0 1 0 1 0 1 0 1 1 0 1 1 1 1 0 1 1 1 0 1 0 0 1 0 1 0 1 0 0 0 1 0 1 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 1 0 1 1 0 1 0 1 0 0 1 0 1 1 0 1 1 0 1 1 0
10

Comments

मुझे यह दिलचस्प लगता है जब वास्तविक भाषाएं विशेष रूप से कोड गोल्फ के लिए बनाई गई भाषाओं को हरा देती हैं। मेरी K प्रविष्टि को खाया गया था या मैंने इसे पोस्ट किया होगा, लेकिन यह 20 वर्णों के लिए आया था।

— जेसन

Answer 8

मतलाब (42)

आज्ञा देना sस्ट्रिंग और निरूपित n-स्ट्रिंग लंबाई। परिणाम हैr ।

लोगों के sएक अनुक्रम के साथ दृढ़ संकल्प की गणना करें n, फिर अधिकतम खोजें। वार्तालाप आसानी से किया जाता है conv, और maxफ़ंक्शन पहले अधिकतम की स्थिति देता है । 1परिणामी इंडेक्स को घटाना आवश्यक है , क्योंकि मैटलैब इंडेक्सिंग शुरू होता है 1, नहीं 0।

[~, r] = max(conv(s, ones(1,n), 'valid'));
r = r-1;

golfed:

[~,r]=max(conv(s,ones(1,n),'valid'));r=r-1

Answer 9

हास्केल, 64 62 बाइट्स

n#l=0-(snd$maximum[(sum$take n$drop x l,-x)|x<-[0..length l]])

उपयोग:

5#[0,1,0,0,1,0,1,0,1,0,1,1,0,1,1,1,1,0,1,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,0,1,1,0,1,0,1,0,0,1,0,1,1,0,1,1,0,1,1,0]

Comments

आप एक n#l=...

— इन्फिक्स

आप के लिए एक infix फ़ंक्शन का उपयोग कर सकते हैं p। यह भी, मुझे लगता है कि 0यह बेमानी है (हालाँकि कोष्ठक नहीं हैं, और आपको इसके बजाय एक स्थान की आवश्यकता हो सकती है 0)।

— गर्वित हैकेलर

Answer 10

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

एक फ़ंक्शन अनुरोधित मान लौटाता है। लूप के लिए अधिकतम मूल्य की स्थिति को बचाते हुए, एक चल कुल रखते हुए इनपुट स्ट्रिंग को स्कैन करता है।

F=(a,n)=>(x=>{for(r=t=i=x;a[i];t>x&&(x=t,r=i-n))t+=a[i]-~~a[i++-n]})(0)|r

Ungolfed

F=(a, n) => {
   for(x = r = t = i = 0; a[i]; i++)
     t += a[i] - ~~a[i-n], // ~~ convert undefined values (at negative index) to 0
     t > x && (x=t, r=i-n+1);
   return r;
}

FireFox / FireBug कंसोल में टेस्ट करें

F("01001010101101111011101001010100010101101010101010101101101010010110110110",5)

उत्पादन 10

Comments

अपने कोड को कम करने के लिए, आप चर निर्धारित करने की जरूरत नहीं है xऔर r। यह 69 बाइट्स की अंतिम लंबाई होने के साथ 4 बाइट्स को कम करना चाहिए। इसके अलावा, आप शायद के &&साथ बदलने में सक्षम हो सकता है &। लेकिन ~~चाल के साथ अच्छा है !

— इस्माइल मिगुएल

@IsmaelMiguel आपको पहले init x, और त्रुटि की आवश्यकता है t > x। आपको init r: try करने की आवश्यकता है F("00000")। और && का अनुकरण करने की आवश्यकता है औरif

— edc65

आप पूरी तरह से सही हैं। मैंने ध्यान नहीं दिया कि आप इसकी अपेक्षा कर रहे थे कि (x=t, r=i-n+1)अगर tयह कम या बराबर है तो इसे अनदेखा कर दें x। यह आलसी मूल्यांकन का एक अच्छा उपयोग है! काश यह कहीं से कटा हुआ हो, लेकिन मुझे लगता है कि आपने सभी काम किए हैं।

— इस्माईल मिगुएल

Answer 11

PHP (96)

for($a=$b=$c=0;(($d=@substr_count($s,1,$a,$n))>$c&&($b=$a)&&($c=$d))||$a++<strlen($s););echo $b;

http://3v4l.org/J4vqa

चर $sऔर $nकमांड लाइन पर क्रमशः खोज स्ट्रिंग और सबरिंग लंबाई को परिभाषित किया जाना चाहिए।

यह किसी भी सी-लाइक लैंग्वेज के लिए substr_count()और उपयुक्त कार्यों के साथ भी काम करेगा strlen()।

Answer 12

गणितज्ञ, ३। ३६

f=#-1&@@Ordering[-MovingAverage@##]&

उदाहरण:

f[{0,1,0,0,1,0,1,0,1,0,1,1,0,1,1,1,1,0,1,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,0,1,1,0,1,0,1,0,0,1,0,1,1,0,1,1,0,1,1,0},5]

आउटपुट:

10

Answer 13

सी # (Linq), 148 बाइट्स

using System.Linq;class C{int F(string s,int l){return s.IndexOf(s.Skip(l-1).Select((c,i)=>s.Substring(i,l)).OrderBy(p=>-p.Sum(c=>c)).First());}}

प्रारूपित:

using System.Linq;

class C
{
    int F(string s, int l)
    {
        return s.IndexOf(
            s
                .Skip(l - 1)
                .Select((c, i) => s.Substring(i, l))
                .OrderBy(p => -p.Sum(c => c))
                .First()
        );
    }
}

इनपुट को मेथड परमेस के रूप में लेता है।

यह क्या करता है:

string result = s // string is also char collection
    .Skip(l - 1) // make it collection shorter by l-1
    .Select((c, i) => s.Substring(i, l)) // so we can iterate, and select all substrings
    .OrderBy(p => -p.Sum(c => c)) // order substrings descending by sum of characters
    .First() // take first (most ones)

return s.IndexOf(result); // find index of result string

Answer 14

स्केल - 70 बाइट्स

readLine.sliding(readInt).zipWithIndex.maxBy(x=>x._1.count(_=='1'))._2

लेकिन जब तक zipWithIndex के रूप में फ़ंक्शन नाम के साथ मुझे लगता है कि Scala कोड गोल्फ के लिए सबसे अच्छा विकल्प नहीं है।

Answer 15

सी, 245 185

#include <stdio.h>
main(int argc,char **argv){char *p,*q;int i,s,m=0;for(p=argv[1];*p;p++){for(s=0,q=p;q-p<atoi(argv[2])&&*q;q++)s+=*q-'0';if(s>m){m=s;i=p-argv[1];}}printf("%d\n", i);}

प्रारूपित:

#include <stdio.h>
main(int argc, char **argv) {
        char *p, *q;
        int i, s, m = 0;
        for (p = argv[1]; *p; p++) {
                for (s = 0, q = p; q - p < atoi(argv[2]) && *q; q++)
                        s += *q - '0';
                if (s > m) {
                        m = s;
                        i = p - argv[1];
                }
        }
        printf("%d\n", i);
}

उपयोग:

$ ./m1s 01001010101101111011101001010100010101101010101010101101101010010110110110 5
10

Answer 16

सीजेएम, 25 21 बाइट्स

q~_,,{1$>2$<:+~}$(]W=

इसका परीक्षण यहां करें।

अनुक्रमित लंबाई के लिए पूर्णांक के रूप में इनपुट लेता है, और अनुक्रम के रूप में शून्य और लोगों की एक सरणी:

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

व्याख्या

q~_,,{1$>2$<:+~}$(p];
q~                    "Read and evaluate the input.";
  _,                  "Duplicate the sequence and get its length N.";
    ,                 "Get an array [0 1 ... N-1].";
     {         }$     "Sort this array stably by the result of the given block.";
      1$              "Copy the sequence.";
        >             "Slice off the first i bits.";
         2$           "Copy the substring length.";
           <          "Truncate the sequence.";
            :+        "Get the sum to find the number of 1s.":
              ~       "Bitwise complement in order to sort from highest to lowest.";
                 (    "Shift off the first index from the sorted list.";
                  ]   "Wrap the entire stack in an array.";
                   W= "Extract the last element (the result), discarding the rest.";

परिणाम कार्यक्रम के अंत में स्वचालित रूप से मुद्रित होता है।

ध्यान दें कि मैं उन स्लाइसों पर भी विचार कर रहा हूं जो वांछित प्रतिस्थापन लंबाई की तुलना में अंत के करीब शुरू होते हैं, लेकिन यह ठीक है, क्योंकि वे अंतिम वैध विकल्प के सबस्ट्रिंग हैं और इसलिए 1उस अंतिम वैध विकल्प से अधिक एस कभी नहीं होगा ।

Answer 17

जावा 329 बाइट्स

एक .matches (regex) का पता लगाने जा रहा था, लेकिन यह ऊपर दिए गए पायथन समाधान के समान होगा, इसलिए मैंने इसके बजाय एक स्लाइडिंग विंडो की कोशिश की। यहां नया है, इसलिए यदि किसी के पास कोई संकेत है तो उन्हें सुनकर खुशी होगी।

public class ssMostOnes{
public static void main(String[] a){
    int b=0,w=0;
    for(int i=0;i<a[0].length()-Integer.valueOf(a[1]);i++){
        int c=a[0].substring(i,i+Integer.valueOf(a[1])).length() - a[0].substring(i,i+Integer.valueOf(a[1])).replace("1","").length();
        if(c>w){w=c;b=i;}
    }
    System.out.println(b);
}

}

Comments

कुछ सुझाव: आप इनिशियलाइज़ कर सकते हैं i तीसरी पंक्ति में । ज्यादातर व्हाट्सएप को हटाया जा सकता है। उपयोग System.out.print((कोई नई पंक्ति की आवश्यकता नहीं)। इसके बजाय Integer.valueOf(, आप उपयोग कर सकते हैं new Integer(।

— यपनीपैन