लालची कटर

Question

iBug को हाल ही में कंपोजिट से बनी एक लंबी पट्टी मिली, फिर भी मूल्यवान सामग्री। बार इतना लंबा है कि iBug इसे आसानी से क्रेडिट के लिए नहीं बेच सकता है, इसलिए वह इसे काटना चाहता है। बार एक ऐसी नाजुक और जादूई सामग्री से बना होता है, जिसे अगर एक हिस्सा तोड़ा जाता है, तो एक ही सामग्री से बने बार के सभी हिस्से टूट जाएंगे, जिससे मनमाने तरीके से कटौती करना मुश्किल हो जाएगा।

iBug बार को अधिक से अधिक टुकड़ों में काटना चाहता है। वह बहुत छोटे कार्यक्रमों और कोड-गोल्फिंग से भी प्यार करता है, इसलिए उसने अपनी समस्या का एक सार विश्लेषण किया।

iBug की मैजिक बार को एक स्ट्रिंग (या एक सरणी या यदि आप चाहें तो वर्णों के अनुक्रम) के रूप में दर्शाया जाता है:

aaabbccccccbbbaaacccccaabbbaaaaa

स्ट्रिंग में प्रत्येक अक्षर एक जादू सामग्री का प्रतिनिधित्व करता है। बार हमेशा RegEx से मेल खाता है ^\w*$, इसलिए बार में 63 सामग्री हो सकती है। एक "भाग" किसी भी वर्ण का एक क्रम है जो रिक्त स्थान से अलग नहीं होता है।

iBug चाहता है कि आप एक ऐसा प्रोग्राम लिखें, जो अधिकतम भागों की गणना करता है जो उसे मिल सकता है, यदि शून्य या अधिक वर्ण सेट पूरी तरह से हटा दिए गए हैं (रिक्त स्थान द्वारा प्रतिस्थापित), और iBug को उस संख्या को बताएं।

---

उदाहरण 1:

In:  aaabbccccccbbbaaacccccaabbbaaaaa
Out: 4

विवरण: यदि bबार से पूरी तरह से हटा दिया जाता है, तो iBug को 4 भाग मिल सकते हैं। उन्होंने यह भी हटाने के द्वारा 4 भागों प्राप्त कर सकते हैं bऔर c, के रूप में नीचे दिखाया गया है

aaabbccccccbbbaaacccccaabbbaaaaa  # Original string
aaa  cccccc   aaacccccaa   aaaaa  # Remove 'b'
aaa           aaa     aa   aaaaa  # Remove 'b' and 'c'

और यह कि इस बार से iBug के अधिकतम हिस्से मिल सकते हैं

उदाहरण 2:

In:     111aa___9999____aaa99111__11_a_aa999
Result: 111aa   9999    aaa99111  11 a aa999
Out:    6

विवरण: केवल अंडरस्कोर को हटाकर, iBug बार से 6 भाग प्राप्त कर सकता है और यह अधिकतम है।

उदाहरण 3:

In:  __________
Out: 1

विवरण: क्या? आप यह कटौती करना चाहते हैं? यदि आप इसे बिल्कुल नहीं काटते हैं तो केवल 1 भाग प्राप्त करना संभव है।

उदाहरण 4:

In:  
Out: 0

विवरण: कटौती करने के लिए कुछ भी नहीं है, इसलिए शून्य है।

---

वहाँ भी कुछ नियम है कि iBug कार्यक्रमों का पालन करना चाहते हैं:

1. iBug मानक खामियों को नापसंद करता है और उन्हें मना किया जाता है।

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

3. लचीले इनपुट और आउटपुट की अनुमति है। आपका प्रोग्राम या फ़ंक्शन एक स्ट्रिंग, या वर्णों की एक सरणी ले सकता है, या जो भी आपको सबसे आसान लगता है। आप संख्या को प्रिंट करके या उसे वापस करके आउटपुट दे सकते हैं।

---

नमूना परीक्षण के मामले (लेकिन इन तक सीमित नहीं)

aaabbbaaa           = 2
123456789           = 5
AaAaAaAa            = 4
aaabcccdedaaabefda  = 6
________            = 1
(empty)             = 0

चूंकि यह एक कोड-गोल्फ है , प्रत्येक भाषा में सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है!

---

अतिरिक्त

iBug अत्यधिक सराहना करता है यदि आप अपने कार्यक्रम के लिए स्पष्टीकरण प्रदान कर सकते हैं, भले ही यह आपके स्कोरिंग को प्रभावित न करे (यह बाइट्स में अभी भी लंबाई है)।

Comments

123456789उपज 5 कैसे होती है? और aaabcccdedaaabefda6 कैसे उपजता है? मुझे इन दो परीक्षण मामलों के लिए क्रमशः 2 और 4 मिलते हैं।

— श्री एक्सकोडर

@ पहले के लिए Mr.Xcoder 2468, दूसरे के लिए निकालें, निकालें bd।

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

@MartinEnder ओह तो किसी भी बाद में हटाया जा सकता है? यदि कोई भी पात्र पूरी तरह से हटाए जाने का सुझाव देता है तो अन्यथा।

— श्री एक्सकोडर

@ Mr.Xcoder, अगर मैंने चुनौती को सही ढंग से समझा है, तो आप 2,4,6,8पहले और b,d,fदूसरे से हटा दें ।

— शैगी

@ Mr.Xcoder का अर्थ है किसी भी वर्ण के सभी प्रतियों को हटाना। मुझे लगता है कि काम किया उदाहरण इसे काफी अच्छी तरह से दिखाता है।

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

Answer 1

हास्केल , 73 71 70 बाइट्स

x#z|z==x=' '|1<2=z
f x=maximum$length(words x):[f$(c#)<$>x|c<-x,c>' ']

^{1 बाइट बचाने के लिए लकोनी का धन्यवाद !}

इसे ऑनलाइन आज़माएं!

Comments

maximum$(length$words x):को छोटा किया जा सकता है maximum$length(words x):।

— लैकोनी

Answer 2

जावास्क्रिप्ट (ईएस 6), 109 90 बाइट्स

f=s=>Math.max((s.match(/\s+/g)||[]).length,...[...s].map(c=>c>` `&&f(s.split(c).join` `)))

<input oninput=o.textContent=/\s/.test(this.value)?``:f(this.value)><pre id=o>0

123456789परीक्षण के मामले पर थोड़ा धीमा । पिछला 109-बाइट उत्तर केवल इस तक सीमित नहीं था !/\s/:

f=
s=>(g=a=>Math.max(a.filter(s=>s).length,...[...a.join``].map(c=>g([].concat(...a.map(s=>s.split(c)))))))([s])

<input oninput=o.textContent=f(this.value)><pre id=o>0

Comments

कम (103 बाइट्स) और तेजी से (के बंदरगाह मेरे गहरे लाल रंग का जवाब: )

— Asone Tuhid

@AsoneTuhid ओह, मैंने वर्ण सेट पर प्रतिबंध नहीं देखा; मेरा कोड किसी भी स्ट्रिंग के लिए काम करता है।

— नील

एकमात्र चरित्र जिसके लिए काम नहीं करना है वह है अंतरिक्ष?

— असोह तुहिद

@AsoneTuhid आपका पोर्ट केवल उन पात्रों के लिए काम करता है जिन्हें इसके लिए काम करने की आवश्यकता है; आपका मूल स्थान छोड़कर कुछ भी काम करने लगता है।

— नील

आपके अक्षर आपके मूल उत्तर के लिए क्या काम करते हैं?

— असोन तुहिद

Answer 3

पायथन 2 , 111 93 72 बाइट्स

-21 बाइट्स धन्यवाद किरिल एल।

f=lambda s:max([len(s.split())]+[f(s.replace(c,' '))for c in s if'/'<c])

इसे ऑनलाइन आज़माएं!

Comments

ऐसा लगता है कि वर्तमान में जेएस और रूबी द्वारा उपयोग किया जाने वाला दृष्टिकोण पायथन के लिए भी बहुत अच्छा काम करता है: 73 बाइट्स

— किरिल एल।

@KirillL। सिफारिश के लिए धन्यवाद

— अंडा

Answer 4

जेली ,  13  11 बाइट्स

^{बहुत से 2-बाइट निर्देश}
-2 ज़गारब के लिए धन्यवाद (बाहरी उत्पाद त्वरितþ> काउपयोग करें। <)

eþŒPŒr¬S€ṀḢ

पात्रों की एक सूची को स्वीकार करने और एक गैर-नकारात्मक पूर्णांक वापस करने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं!

कैसे?

इनपुट के प्रत्येक बाद के लिए (जो सेट हम निकाल सकते हैं, प्लस निरर्थक समकक्ष) को पहचानने के लिए एक अस्तित्व सूची मिलती है जिसे हटा दिया जाता है फिर प्रभावी ढंग से पता चलता है कि शून्य के कितने रन रहते हैं और अधिकतम उपज देता है। अंतिम भाग थोड़े अजीब तरीके से काम करता है क्योंकि मैंने इसे अधिक भोले विकल्पों की तुलना में गोल्फर पाया - यह [element, count]जोड़े के रूप में रन पाता है , शून्य को पहचानने की उपेक्षा करता है, रकम अधिकतम पाता है फिर सिर लेता है (गणना के बजाय तत्वों का योग) )।

eþŒPŒr¬S€ṀḢ - Link: list of characters        e.g. "aabcde"
  ŒP        - power-set - gets all subsequences    ["","a","a","b",...,"bd",...,"aabcde"]
 þ          - outer-product with:
e           -   exists in?                         [[0,0,0,0,0,0],[1,1,0,0,0,0],[1,1,0,0,0,0],[0,0,1,0,0,0],..,[0,0,1,0,1,0]...,[1,1,1,1,1,1]]
    Œr      - run-length encode                    [[[0,6]],[[1,2],[0,4]],[[1,2],[0,4]],[[0,2],[1,1],[0,3]],...,[[0,2],[1,1],[0,1],[1,1],[0,1]],...,[[1,6]]]
      ¬     - NOT                                  [[[1,0]],[[0,0],[1,0]],[[0,0],[1,0]],[[1,0],[0,0],[1,0]],...,[[1,0],[0,0],[1,0],[0,0],[1,0]],...,[[0,0]]]
        €   - for €ach:
       S    -   sum                                [[1,0],[1,0],[1,0],[2,0],...,[3,0],...,[0,0]]
         Ṁ  - maximum                              [3,0]
          Ḣ - head                                 3

Comments

मुझे लगता है कि €Đ€हो सकता है þ।

— जरगब

Answer 5

रूबी , 98 89 75 64 61 बाइट्स

f=->s{[s.split.size,*s.scan(/\w/).map{|c|f[s.tr c,' ']}].max}

इसे ऑनलाइन आज़माएं!

_{^{पहले की तुलना में छोटा और धीमा!}}

मूल रूप से @ नील के जावास्क्रिप्ट उत्तर का एक बंदरगाह

अधूरा और एनोटेट

def f(input_string)
    # splits by / +/ by default
    size0 = input_string.split.size
    # an array of all non-space characters in input_string
    characters = input_string.scan(/\w/)
    size1 = characters.map {|i|
        # all letters and digits and _ are "bigger" than /, space isn't
        if i > '/'
            # tr replaces every occurrence of i in input_string with space
            next_string = input_string.tr(i, ' ')
            f(next_string) # recursive call
        else
            0
        end
    }
    # max value between size0 and any element in size1
    return [size0, *size1].max
end

इसे ऑनलाइन आज़माएं!

Answer 6

भूसी , 12 11 बाइट्स

▲mȯ#€0gM€¹Ṗ

इसे ऑनलाइन आज़माएं! यह क्रूर बल द्वारा काम करता है और काफी धीमा है। uशब्दार्थ को बदले बिना इसे तेज चलाने के लिए दाईं ओर जोड़ें ।

व्याख्या

▲mȯ#€0gM€¹Ṗ  Implicit input, say S = "abddccbdcaab"
          Ṗ  Powerset of S: P = ["","a","b","ab","d","ad"...,"abddccbdcaab"]
 m           Map this function over P:
              Argument is a subsequence, say R = "acc"
       M ¹    Map over S
        €     index of first occurrence in R: [1,0,0,0,2,2,0,0,2,1,1,0]
      g       Group equal elements: [[1],[0,0,0],[2,2],[0,0],[2],[1,1],[0]]
  ȯ#          Count the number of groups
    €0        that contain 0: 3
▲            Take maximum of the results: 4

Answer 7

पर्ल 5 , (पुराने संस्करण) -p -I., 52 49 43 बाइट्स

पुरानी शैली की गिनती: के +3लिए -p: 46बाइट्स (क्योंकि यह एक प्रोग्राम में होना चाहिए, इसका उपयोग करके नहीं चलाया जा सकता -e)

barsplit.pl:

#!/usr/bin/perl -pI.
$G[split]+=s%\S%do$0for s/$&/ /rg%eg;$_=$#G

STDIN पर स्ट्रिंग के साथ चलाएँ:

echo aaabcccdedaaabefda | ./barsplit.pl; echo

इसे ऑनलाइन आज़माएं!

-I.विकल्प हाल पर्ल्स पर यह भी काम जहां डिफ़ॉल्ट रूप से वहाँ बनाने के लिए है .में अधिक नहीं है @INC। पर्ल के पुराने संस्करणों में उस विकल्प की आवश्यकता नहीं है। मैंने परीक्षण किया कि एक पुरानी मशीन पर जो अभी भी था perl 5.20, इसलिए स्कोर उसी पर आधारित है (अन्यथा मुझे .तर्क को भी गिनना चाहिए -I)

तेजी से संस्करण ( 49बाइट्स):

#!/usr/bin/perl -pI.
$G[split]+=s%.%$$_++||do$0for s/$&/ /rg%eg;$_=$#G

Answer 8

वोल्फ्राम भाषा (गणितज्ञ) , 77 बाइट्स

Max@Table[Tr[1^StringSplit[#,(##|##)..&@@s]],{s,Subsets@Union@Characters@#}]&

इसे ऑनलाइन आज़माएं!