पायथन में जांचें कि कोई स्ट्रिंग दूसरी स्ट्रिंग को बनाने के लिए दोहराई जा सकती है या नहीं

मान लीजिए हमारे पास दो स्ट्रिंग्स s और t हैं। हमें यह ढूंढना है कि स्ट्रिंग s को कितनी बार जोड़कर (concatenate) t उत्पन्न किया जा सकता है। यदि हम s का उपयोग करके t उत्पन्न नहीं कर सकते, तो -1 लौटाएं।

उदाहरण के लिए, यदि इनपुट s = "tom", t = "tomtomtom" है, तो आउटपुट 3 होगा क्योंकि हम "tom" को 3 बार जोड़कर "tomtomtom" प्राप्त कर सकते हैं।

समाधान दृष्टिकोण

यदि t की लंबाई s की लंबाई से विभाज्य नहीं है, तो असंभव है। अन्यथा, s को आवश्यक संख्या में दोहराएं और t से तुलना करें।

एल्गोरिदम चरण:

1. यदि len(t) % len(s) != 0, तो -1 लौटाएं
2. cnt = len(t) // len(s)
3. s = s * cnt (s को cnt बार दोहराएं)
4. यदि s == t, तो cnt लौटाएं
5. अन्यथा -1 लौटाएं

पायथन कार्यान्वयन

def solve(s, t):
    if len(t) % len(s) != 0:
        return -1
    cnt = len(t) // len(s)
    s = s * cnt
    if s == t:
        return cnt
    return -1

s = "tom"
t = "tomtomtom"
print(solve(s, t))  # 3

इनपुट

"tom", "tomtomtom"

आउटपुट

3

अन्य उदाहरण:

• s="ab", t="abab" → 2
• s="ab", t="aba" → -1 (लंबाई विभाज्य नहीं)
• s="ab", t="abba" → -1 (पैटर्न मेल नहीं खाता)