जांचें कि क्या एक स्ट्रिंग पूरी तरह से एक ही सबस्ट्रिंग से बना है

24

यह इस प्रश्न से लिया जाता है (संभोग की अनुमति के साथ)। मैं बोली:

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

कुछ उदाहरण:

'aa' //true
'aaa' //true
'abcabcabc' //true
'aba' //false
'ababa' //false
'weqweqweqweqweqw' // false

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

code-golf  decision-problem 
— ouflak
स्रोत
4
हम्म, मैं इस चुनौती को उस एक व्यक्ति के एक ठग के रूप में बंद करने जा रहा था , लेकिन मैंने देखा कि चरित्र गिनती पर अन्य एक स्कोर। तो शायद हमें दूसरे को बंद कर देना चाहिए (इसका भी एक स्वीकृत उत्तर है) इसके बजाय इस एक के दुपट्टे के रूप में।
— आउटगोल्फर
— आउटगोल्फर

जवाबों:

11

ब्रेकीलॉग , 4 3 बाइट्स

ġ=Ṁ

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

व्याख्या

ġ=Ṁ    Implicit input, say "abcabc"
ġ      Split into chunks of equal lengths (except maybe the last one): ["abc","abc"]
 =     Apply the constraint that all of the chunks are equal,
  Ṁ    and that there are multiple of them.

कार्यक्रम प्रिंट करता है true.अगर बाधाएं संतुष्ट हो सकती हैं, और false.यदि नहीं।

— Zgarb
स्रोत
मैं बस एक घंटे पहले इस पर ध्यान देने के बाद कुछ पाने की कोशिश कर रहा था ~j↙या =Ṁcकाम कर रहा था
— असंबंधित स्ट्रिंग
4
ओह, हाँ, यह एक बाइट छोटी हो सकती है:ġ=Ṁ
— असंबंधित स्ट्रिंग
( Ṁदो या दो से अधिक तत्वों की सूची के लिए विवश एक चर है)
— असंबंधित स्ट्रिंग
1
@ असंबंधित महान, धन्यवाद! मैंने वेरिएबल विकी पेज को चेक करने के लिए नहीं सोचा था।
— जर्गर्ब
1
बहुत सारे शानदार जवाब, और LUA उत्तर का मेरे दिल में एक विशेष स्थान है। मूल प्रश्न के बाद से अर्नुलद का उत्तर विशेष रूप से मीठा है, जो कि मैं इस पर आधारित (डूप नहीं) वास्तव में जावास्क्रिप्ट को टैग किया गया है। मुख्य रूप से इसे केवल इसलिए चुनना क्योंकि यह सभी भाषाओं के लिए सबसे छोटा प्रतीत होता है और, क्योंकि यह मेरा पहला प्रश्न है, मुझे एक बैज मिलता है।
— ouflak
19

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

एक बूलियन मान लौटाता है।

s=>/^(.*)\1+$/.test(s)

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

एक नियमित अभिव्यक्ति के बिना,  33  29 बाइट्स

या तो null(मिथ्या) या एक वस्तु (सत्य) लौटाता है ।

s=>(s+s).slice(1,-1).match(s)

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

NB: तकनीकी रूप से, को मैच के लिए एक नियमित अभिव्यक्ति में परिवर्तित किया जाता है () , इसलिए उपरोक्त शीर्षक एक झूठ है।रों

— Arnauld
स्रोत
9

grep, 19

grep -qxE '(.+)\1+'

परीक्षा

while read; do 
  <<<"$REPLY" grep -qxE '(.+)\1+' && t="true" || t="false"
  echo "$REPLY: $t"
done < infile

आउटपुट:

aa: true
aaa: true
abcabcabc: true
aba: false
ababa: false
weqweqweqweqweqw: false
— थोर
स्रोत
9

जाप , 6 बाइट्स

²é ¤øU

@ बग्घी के लिए एक बाइट धन्यवाद दिया

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

        Implicit input, stored in variable 'U'
²       U+U, "abcabc" -> "abcabcabcabc"
 é      Rotate 1 char to the right "abcabcabcabc" -> "cabcabcabcab"
   ¤    Remove first two chars, "cabcabcabcab" -> "bcabcabcab"
    øU  Check if U is in the above
— अज्ञान का अवतार
स्रोत
एक अच्छा :) आप एक बाइट को बचाने के लिए के p<space>साथ बदल सकते हैं ²।
— झबरा
9

जावा, 25 24 बाइट्स

ओलिवियर ग्रेजायर के लिए -1 बाइट धन्यवाद!
बोरिंग रेगेक्स उत्तर

s->s.matches("(.+)\\1+")

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

यह अजगर के जवाब से सिर्फ 1 बाइट लंबा है आआआआ अब मैं बंधा हुआ हूं :)

— बेंजामिन अर्कहार्ट
स्रोत
3
आप फाइनल $को हटा सकते हैं क्योंकि matchesविधि एक सटीक मिलान है, डिफ़ॉल्ट रूप से एक विकल्प मिलान नहीं।
— ओलिवियर ग्रेजायर
मैं भूल गया matchesखुद $को regex में जोड़ता है । धन्यवाद!
— बेंजामिन उर्फहार्ट
7

एक्सेल, 26 बाइट्स

=FIND(A1,A1&A1,2)<=LEN(A1)

A1 से इनपुट, जो भी सेल आप इस फॉर्मूले को आउटपुट करते हैं।

— सोफिया लेचनर
स्रोत
यदि आप एकल-अक्षर श्रेणी नाम (जैसे A) परिभाषित करते हैं और अपने इनपुट के रूप में सेट करते हैं तो आप 4 बाइट्स बचा सकते हैं ।
— I_saw_drones
@i_saw_drones - मुझे लगता है कि यह मानक I / O नियमों द्वारा अस्वीकृत है: यहाँ मेटा उत्तर का एक लिंक है जो उस पद्धति पर लागू होगा; यह वर्तमान में -36 मतों पर है।
— सोफिया लेचनर
क्षमा याचना, मैंने उस पोस्ट को नहीं देखा था, हालांकि इसके बारे में सोचते हुए, यह A1"चर" भी नहीं है क्योंकि इसमें इनपुट मूल्य शामिल है? :)
— i_saw_drones
1
मुझे लगता है कि इस तरह से अगर मैं इस तथ्य के साथ कुछ भी विशेष कर रहा था कि यह विशेष रूप से A1 है, जैसे कि अगर मैं किसी तरह से इसके ROW (_) पर निर्भर करता था तो 1. 1. हालांकि, यह एक्सेल फ़ंक्शन प्रदान करने का सबसे स्वाभाविक तरीका है एक मनमाना इनपुट।
— सोफिया लेचनर
7

आर , 28 बाइट्स

grepl("(.+)\\1+$",scan(,''))

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

सरल रेगेक्स संस्करण। R (कभी-कभी) Python के समान होता है, इसलिए यह TFeld के Python 2 regex उत्तर के समान होता है, यद्यपि यह छोटा होता है!

प्रश्न (यदि किसी को उत्तर पता है)

मैं अभी भी उलझन में हूं कि यह क्यों काम करता है, क्योंकि सबस्ट्रिंग किसी भी लंबाई का हो सकता है और हमेशा काम करेगा, और तब भी काम करता है जब मैं एक वैध स्ट्रिंग के सामने एक अक्षर जोड़ता हूं, जैसे "cABABABABAB"। यदि मैं व्यक्तिगत रूप से रेगेक्स पढ़ता हूं, तो मैं देखता हूं (.+), जो किसी भी लम्बाई के किसी भी समूह को पकड़ लेता है। और फिर \\1+$जो पकड़े गए समूह को अंत तक किसी भी समय दोहराता है।

तो यह सिर्फ "एबी" पर कब्जा क्यों नहीं करता है और यह पता चलता है कि यह स्ट्रिंग के अंत तक दोहराया जाता है, खासकर जब से कोई विकल्प निर्दिष्ट नहीं है कि प्रतिस्थापन कहाँ से शुरू हो सकता है?

— Sumner18
स्रोत
1
दिलचस्प है, यह आर के रेगेक्स इंजन में एक बग लगता है। विकल्प जोड़ने perl=TRUEसे यह कबाब से मेल खाता है, जैसा कि आप उम्मीद करेंगे। grep -E '(.*)\1+$'बैश में दौड़ना भी कबाब से मेल खाता है, हालांकि ईआरई grep -Eका उपयोग करता है, वही रेगेक्स स्वाद आर का समर्थन करने वाला है।
— ग्रैमी
2
मेरा अनुमान है कि यह गलत तरीके से लागू अनुकूलन है। .+एक पैटर्न की शुरुआत में बदलना ^.+एक महत्वपूर्ण अनुकूलन है, लेकिन अगर .+अंदर पर कब्जा कर रहा है तो यह वैध होना बंद हो जाता है।
— ग्रैमी
6

जेली ,  5  4 बाइट्स

अब मैं देखता हूं कि एक्सनोर की विधि का पालन ​​करने का सबसे इष्टतम तरीका है !

Ḋ;Ṗw

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

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

कैसे?

Ḋ;Ṗw - Link: list of characters, S   e.g. "abcabcabc"   or "abababa"
Ḋ    - dequeue S                           "bcabcabc"       "bababa"
  Ṗ  - pop from S                         "abcabcab"       "ababab"
 ;   - concatenate                "bcabcabcabcabcab"       "bababaababab"
   w - first index of sublist     3  ^---here!             0  (not found)
— जोनाथन एलन
स्रोत
4

पायथन 2 , 24 बाइट्स

lambda s:s in(s*2)[1:-1]

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

मूल प्रश्न के xnor के उत्तर से बेशर्मी से चुराया गया ।

अधिक सहज संस्करण:

पायथन 2 , 59 55 53 बाइट्स

lambda s:s in[len(s)/i*s[:i]for i in range(1,len(s))]

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

बोरिंग रेगेक्स संस्करण:

पायथन 2 , 44 बाइट्स

lambda s:re.match(r'(.+)\1+$',s)>0
import re

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

— TFeld
स्रोत
3

पॉवरशेल, 23 24 बाइट्स

पूरी तरह से नियमों से मेल खाने के लिए +1 बाइट

"$args"-match"^(.+)\1+$"

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

बहुत उबाऊ है। अन्य रेगेक्स उत्तरों के आधार पर। सौभाग्य से PowerShell \एक भागने चरित्र के रूप में उपयोग नहीं करता है !

— गेब्रियल मिल्स
स्रोत
यह रिटर्न trueके लिएaabcabc
— Mazzy
1
@ mazzy बस तय!
— गेब्रियल मिल्स
3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 70 बाइट्स

xnor का बेशर्म अनुकूलन ( 46 बाइट्स )

s=>(s+s).Substring(1,s.Length*2-2).Contains(s)

मेरा गैर रेगेक्स समाधान:

s=>s.Select((x,y)=>y).Count(z=>s.Replace(s.Substring(0,z+1),"")=="")>1

स्पष्टीकरण:

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

उदाहरण: abcabc

इंडेक्स 0 पर शुरू होने वाले संभावित सबस्ट्रिंग:

'a', 'ab', 'abc', 'abca', 'abcab', 'abcabc'

अगर हम उन्हें खाली तारों से बदल दें

Substring          Result

'a'         =>     'bcbc'
'ab'        =>     'cc'
'abc'       =>     ''
'abca'      =>     'bc'
'abcab'     =>     'c'
'abcabc'    =>     ''

चूँकि 'abcabc' के अलावा एक विकल्प है जो एक खाली स्ट्रिंग देता है, स्ट्रिंग पूरी तरह से दूसरे विकल्प ('abc') से बनी है।

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

— Innat3
स्रोत
3

पायथन 3 , 62 60 56 54 बाइट्स

-4 बाइट्स थैंक्स टू अर्बो

lambda s:s in(len(s)//l*s[:l]for l in range(1,len(s)))
  1. स्ट्रिंग में सभी संभव उपसर्गों पर Iterate करें।
  2. उपसर्ग से बाहर स्ट्रिंग बनाने की कोशिश करें।
  3. लौटें कि क्या यह किसी भी उपसर्ग के साथ सफल होता है।

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

— movatica
स्रोत
1
अच्छा जवाब! f=छोड़ा जा सकता है; अनाम कार्यों को आम तौर पर अनुमति दी जाती है। इसके अलावा, पायथन 2 पर स्विच करके और anyनिर्माण के बजाय एक सूची की सदस्यता की जांच करके , आप 55 बाइट्स
— ArBo
1
सूची सदस्यता के साथ अच्छा पकड़, thanx! मैं पायथन 2 पर नहीं जाऊंगा, क्योंकि यह भाषा को स्विच करने जैसा है, जो स्पष्ट रूप से यहां नहीं है;
— मूलांक
1
@movatica हेडर में, 'f =' (\ python में लाइन निरंतरता वर्ण है) डाल दिया
— आर्टेमिस
सच में, \ N भी एक भागने चरित्र है। यहाँ, कोड स्वरूपण के बिना, आपको हेडर में क्या रखना चाहिए: f = \
— आर्टेमिस मोनिका
2

जाप , 10 बाइट्स

एक सकारात्मक संख्या लौटाता है यदि सत्य और 0 यदि असत्य है। यदि आप बूल आउटपुट चाहते हैं तो केवल -¡ध्वज जोड़ें

å+ k@rXÃÊÉ

å+ k@rXÃÊÉ      Full program. Implicit input U.
                    e.g: U = "abcabcabc"
å+              Take all prefixes 
                         U = ["a","ab","abc","abca","abcab","abcabc","abcabca","abcabcab","abcabcabc"]
   k@           Filter U by:
     rXÃ        Values that return false (empty string)
                when replacing each prefix in U
                e.g: ["bcbcbc","ccc","","bcabc","cabc","abc","bc","c",""]
                                take ↑                             and ↑
                     U = ["abc","abcabcabc"]
         ÊÉ     Get U length and subtract 1. Then return the result

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
2

भूसी , 6 बाइट्स

Ṡ€ȯhtD

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

मुझे ऐसा लगता है कि यह इष्टतम से एक बाइट अधिक है, लेकिन मुझे ऐसी व्यवस्था नहीं मिली जिससे स्पष्ट रचना ȯअनावश्यक हो।

व्याख्या

Ṡ€      Find the argument in the result of applying the following function to the argument
  ȯhtD  Duplicate the argument, then remove the first and last elements.
— सोफिया लेचनर
स्रोत
2
€htD¹टाल जाता है ȯ।
— 19
यह बढ़िया है! मैंने इस बारे में सोचा था λ€htD¹लेकिन मुझे महसूस नहीं हुआ कि लंबोदर को जोड़ दिया जाएगा
— सोफिया लेचनर
2

गणितज्ञ 11.x, 74 बाइट्स

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&

जहां, भर में, #इनपुट स्ट्रिंग का प्रतिनिधित्व करता है, और

StringCases[#,<pattern>]

पैटर्न से मेल खाते इनपुट स्ट्रिंग के सबस्ट्रिंग पाता है

StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")

इस पैटर्न में मैचों की आवश्यकता होती है x, इसे स्ट्रिंग की शुरुआत में शुरू करना चाहिए और इस शर्त को पूरा करना चाहिए कि (1) मैच पूरे इनपुट स्ट्रिंग नहीं है और (2) यदि हम रिक्त स्ट्रिंग के साथ इनपुट स्ट्रिंग में मैच की घटनाओं को प्रतिस्थापित करते हैं हम खाली स्ट्रिंग प्राप्त करते हैं। अंत में, मैचों की सूची की तुलना खाली सूची से करें,

{}!=

है Trueअगर मैचों की सूची अरिक्त है और Falseमैचों की सूची खाली है, तो।

परीक्षण के मामलों:

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aaa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["abcabc"]
(*  True  *)

तथा

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aba"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["ababa"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["weqweqweqweqweqw"]
(*  False  *)
— एरिक टावर्स
स्रोत
2

पायथन 3, 84 बाइट्स

import textwrap
lambda s:any(len(set(textwrap.wrap(s,l)))<2 for l in range(1,len(s)))

प्रतिस्थापन के प्रत्येक संभावित लंबाई का परीक्षण करने के लिए स्ट्रिंग को लंबाई के टुकड़ों में विभाजित करने के textwrap.wrapलिए ( इस उत्तर के लिए धन्यवाद ) का उपयोग करता है n। विभाजित टुकड़ों को फिर एक सेट में जोड़कर एक दूसरे से तुलना की जाती है। यदि सभी टुकड़े समान हैं, और सेट लंबाई 1 का है, तो स्ट्रिंग को एक दोहराए जाने वाला स्ट्रिंग होना चाहिए। मैंने <2इसके बजाय इस्तेमाल किया ==1क्योंकि यह एक बाइट बचाता है, और इनपुट स्ट्रिंग की लंबाई शून्य से अधिक होने की गारंटी थी।

यदि ऐसा नहीं है n, जिसके लिए लंबाई का दोहराव nपूरे स्ट्रिंग को बना देता है, तो पूरे फ़ंक्शन के लिए गलत लौटें।

— Delya Erricson
स्रोत
2

05AB1E , 5 बाइट्स

पिछले प्रश्न से xnor की विधि 05AB1E में भी इष्टतम प्रतीत होती है।

«¦¨så

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

«       # append input to input
 ¦¨     # remove the first and last character of the resulting string
   så   # check if the input is in this string
— Emigna
स्रोत
1
बेशक .. मैं एक 05AB1E उत्तर देने वाला था जब मैंने देखा कि कोई नहीं था। सहकर्मी ने मुझसे कुछ सवाल पूछे और उसकी छुट्टी के बारे में बात की। मैं स्क्रीन पर वापस देखता हूं: एक नया उत्तर। टाडा, फिर से एक्सडी
— केविन क्रूज़सेन
@ केविनक्रूजसेन: यह विशिष्ट है। मेरे साथ भी कई बार ऐसा हो चुका है;)
— एमिगा
2

क्लीन , 73 बाइट्स

रेगेक्स का उपयोग नहीं करता है।

import StdEnv,Data.List
$s=or[isPrefixOf s(cycle t)\\t<-tl(tails s)|t>[]]

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

परिभाषित करता है $ :: [Char] -> Bool।
जांचता है कि क्या दी गई स्ट्रिंग अंत से ली गई किसी उप-स्ट्रिंग के दोहराव का एक उपसर्ग है।

— Οurous
स्रोत
2

सी ++ (जीसीसी) , 36 बाइट्स

#define f(x)(x+x).find(x,1)<x.size()

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

Xnor के समाधान का दूसरा पोर्ट। अभिव्यक्ति में तर्क का विस्तार करने के लिए एक मैक्रो का उपयोग करता है। तर्क को प्रकार का माना जाता है std::string।

— jxh
स्रोत
1

QlikView चर, 27 बाइट्स

इसे एक चर के रूप में परिभाषित किया जाना चाहिए, जो तब आपको मापदंडों को पारित करने की अनुमति देता है, जैसे $1कि आपके इनपुट मूल्य के रूप में।

यह रिटर्न 0या -1(QlikView के लिए बराबर TRUE()समारोह)।

=substringcount($1&$1,$1)>2
— i_saw_drones
स्रोत
1

स्विफ्ट, 196 बाइट्स

func r(s:String)->Bool{guard let k=s.dropFirst().firstIndex(where:{$0==s.first}) else{return false};let v=s[...k].dropLast();var w=v;while s.hasPrefix(w) && s.count>=(w+v).count{w+=v};return s==w}

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

— onnoweb
स्रोत
मैं स्विफ्ट का उपयोग नहीं करता, लेकिन मुझे यकीन है कि अतिरिक्त व्हाट्सएप को हटाया जा सकता है
— बेंजामिन अर्कहार्ट
@ बेंजामिन के सुझाव का उपयोग करते हुए 193 बाइट्स ।
— आर्टेमिस
@ArtemisFowl या यहां तक ​​कि 123 बाइट्स
— रोमन पॉडीमोव
1

टी-एसक्यूएल, 47 बाइट्स

@ Xnor की विधि का उपयोग करना :

DECLARE @ varchar(max)='ababab'

PRINT sign(charindex(@,left(@+@,len(@)*2-1),2))

पुराना उत्तर रखना क्योंकि इसमें कुछ अच्छी गोल्फिंग (67 बाइट्स) शामिल हैं:

DECLARE @y varchar(max)='abababa'

,@ INT=0WHILE
replace(@y,left(@y,@),'')>''SET
@+=1PRINT @/len(@y)^1

स्पष्टीकरण: यह स्क्रिप्ट बार-बार इनपुट '@' के इनपुट '@y' को '' @ '' अक्षर से बदलने की कोशिश कर रही है, जबकि '' @ '' को बढ़ाती है।

यदि आप 'ab' को 'ababab' में बदल देते हैं, तो आपके पास एक खाली स्ट्रिंग नहीं है

आखिरकार रिजल्ट खाली हो जाएगा। यदि यह तब होता है जब लूप वेरिएबल वेरिएचर की लंबाई के बराबर होता है, तो मानदंड गलत होता है / 0 क्योंकि '@' = len (@y) (कोई दोहराव वाला वर्चर नहीं था)।

iif(@=len(@y),0,1)

इसमें गोल्फ हो सकता है

@/len(@y)^1

क्योंकि '@y' की लंबाई 0 नहीं हो सकती और '@' की लंबाई @y से अधिक नहीं होगी।

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

— t-clausen.dk
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.