एक स्ट्रिंग एस दिया गया है, जो केवल 'ए' और 'बी' से बना है। निम्नलिखित नियमों के लिए स्ट्रिंग की जाँच करें। रिकर्सन का उपयोग कर पायथन में कार्यक्रम।

  1. स्ट्रिंग 'ए' से शुरू होती है
  2. प्रत्येक 'ए' के ​​बाद कुछ भी नहीं या 'ए' या "बीबी" है
  3. प्रत्येक "बीबी" के बाद कुछ भी नहीं या 'ए' होता है

मैंने निम्नलिखित कोड की कोशिश की है।

def checkAB(s):
    if len(s) == 0:
        return 1
    if s[0] == 'a':
        if s[1] == 'a' or s[1] == 'b':
            return checkAB(s[2:])
        if s[1] == None:
            return 1
        else:
            return 0
    elif s[0] == 'b':
        if s[1] == 'b' and s[2] == None:
            return checkAB(s[2:])
        elif s[1] == 'b' and s[2] == 'a':
            return 1
        else:
            return 0

s = input()
if s[0] == 'a':
    if checkAB(s[1:]):
        print('true')
    else:
        print('false')
else:
    print('false')

लेकिन यह string index out of range त्रुटि दिखाता है।

अग्रिम में धन्यवाद!

3
Shubhang Gupta 7 जिंदा 2021, 16:50

5 जवाब

सबसे बढ़िया उत्तर
def checkAB(s):
    if len(s) == 0:
        return 1
    if s[0] == 'a':
        if len(s[1:]) > 1 and s[1:3] == 'bb':
            return checkAB(s[3:])
        else:
            return checkAB(s[1:])
    else:
        return 0

s = input()
if checkAB(s):
    print('true')
else:
    print('false')

यह वह समाधान है जो मैंने पाया है जो दिए गए परिदृश्य के लिए सबसे उपयुक्त है।

0
Shubhang Gupta 17 जिंदा 2021, 23:13

कोड के बारे में एक नोट:

s[2] का उपयोग करना यह मानता है कि तीसरे स्थान पर कुछ है, लेकिन केवल s[0] और s[1] चेक किए गए जब s[2] पर कुछ भी न हो, तो IndexError: string index out of range उत्पन्न करने वाला कोड

एक विकल्प लंबाई की जांच करना और सभी नियमों और निकास खंडों को बताना है।

कुछ इनलाइन टिप्पणियों के साथ एक उदाहरण के रूप में (शायद इसे छोटा किया जा सकता है लेकिन सिर्फ एक विचार के रूप में)

def checkAB(s):

    # Check for the validity of the input
    if len(s) == 0 or s[0] != 'a':
        return False

    def loop(val):
        # Done processing, all is well
        if len(val) == 0:  
            return True

        # If the first char is a, recurse using the rest of the string
        if val[0] == 'a':
            return loop(val[1:])

        # If there are 3 chars, it can not be bbb
        if len(val) > 2 and val[0] == 'b' and val[1] == 'b' and val[2] == 'b':
            return False

        # If there is a single value left, and that is b it is not ok
        if len(val) == 1 and val[0] == 'b':
            return False

        # If we have bb, recurse using the rest of the string
        if val[0] == 'b' and val[1] == 'b':
            return loop(val[2:])

        # In any other case
        else:
            return False
    return loop(s)

एक पायथन डेमो देखें


यह रिकर्सन का उपयोग करके कोई समाधान नहीं है, लेकिन यदि आप किसी अन्य रेगेक्स समाधान में रूचि रखते हैं, तो आप मिलान के साथ या अधिक बार मिलान कर सकते हैं।

फिर वैकल्पिक रूप से bb और उसके बाद 1 या अधिक a का मिलान करें और वैकल्पिक bb . के साथ मैच समाप्त करें

\Aa+(?:bba+)*(?:bb)?\Z
  • \A स्ट्रिंग की शुरुआत
  • a+ मैच 1 या अधिक बार a
  • (?:bba+)* वैकल्पिक रूप से bb को दोहराएं और उसके बाद 1 या अधिक बार a
  • (?:bb)? वैकल्पिक रूप से bb . से मेल खाते हैं
  • \Z स्ट्रिंग का अंत

रेगेक्स डेमो

1
The fourth bird 8 जिंदा 2021, 00:11

मुझे लगता है कि यह ठीक काम करेगा।

def state2(lst):
    if lst==[]:
        return True
    poped = lst.pop(0)
    if poped == "a":
        return state2(lst)
    else:
        if lst == [] or lst[0] == 'a':
            return False
        if lst[0]=="b":
            lst.pop(0) # removed "BB"
            return state1(lst)

def state1(lst):
    if lst==[]:
        return True
    if lst[0]=="a":
        lst.pop(0)
        return state2(lst)
    return False

संपादित करें: - आसान इनपुट

def checkString(inp):
    # print(list(inp))
    return state1(list(inp))

testcases = ["abb","a","ab","abba", "","abbabbb","abbabbaaabbaaabbabb"]
for i in testcases:
    print(checkString(i))
1
UJJAVAL SHAH 7 जिंदा 2021, 19:05

सौभाग्य से, नियमों को नियमित अभिव्यक्ति के रूप में चित्रित किया जा सकता है:

  1. "ए" से शुरू करें: ^a
  2. "a" या "bba" की मनमानी राशि के साथ जारी रखें: (a|bba)*
  3. किसी भी बिंदु पर या केवल "bb" के साथ समाप्त करें: (bb$)?

संयुक्त रेगेक्स: ^a(a|bba)*(bb$)?

(आप शायद रेगेक्स को थोड़ा और सरल बना सकते हैं, हालांकि सुनिश्चित नहीं हैं)

पायथन में:

import re

def check_rules(s: str) -> bool:
    return bool(re.fullmatch(r"^a(a|bba)*(bb$)?", s))

कुछ परीक्षण:

def test_positive():
    assert check_rules("abba")
    assert check_rules("abbabb")
    assert check_rules("aaabbaabb")
    assert check_rules("abbabbabbaaa")


def test_negative():
    assert not check_rules("aba")
    assert not check_rules("baba")
    assert not check_rules("baabb")
    assert not check_rules("aabbbaa")

चियर्स

संपादित करें: रिकर्सन का उपयोग करके पायथन में प्रोग्राम के बारे में - आपको हमेशा सही काम के लिए सही तकनीक का उपयोग करना चाहिए और इस मामले में एक पुनरावर्ती कार्य उपयोगी नहीं है, क्योंकि पाइथन में रिकर्सन गहराई की सीमा है जिसे आप तक पहुंच सकते हैं यदि आप कुछ मिलियन वर्णों का विश्लेषण करने का प्रयास करते हैं तो बहुत तेज़। रेगुलर एक्सप्रेशन एक नियमित भाषा का विश्लेषण करने का एक प्रभावी तरीका है और तकनीकी रूप से यह यहीं रिकर्सन का उपयोग करता है (a|bba)* ;)

1
klamann 7 जिंदा 2021, 17:28

यह रहा आप......

def check_ab(str):
    if (len(str)==0):
        return True
    
    if (str[0] == 'a'):
        
        if (len(str[1:])>1 and str[1:3] == 'bb'):
            return check_ab(str[3:])
        
        else:
            return check_ab(str[1:])
        
    else:
        return False
    

str = input()
if (check_ab(str)):
    print("true")
else:
    print("false")
0
Ashish 27 जून 2021, 15:50