समूह थेरेपी: समूहों की पहचान करें

Question

एक प्रोग्राम लिखें, जो निर्धारित करता है कि दिए गए परिमित मैग्मा की गुणा तालिका एक समूह का प्रतिनिधित्व करती है या नहीं। एक मैग्मा एक बाइनरी ऑपरेशन के साथ एक सेट है जो बंद है, इसका मतलब है

• सभी के लिए जी, बी में जी, ए * बी फिर से जी (क्लोजनेस) में है

आज्ञा देना (जी, *) एक मैग्मा हो। (जी, *) एक समूह है अगर

• सभी के लिए, बी, सी में जी, (एक * बी) * सी = ए * (बी * सी) (संबद्धता)
• G में एक तत्व e मौजूद है जैसे कि e * a = a = सभी के लिए G में (तटस्थ तत्व का अस्तित्व)
• G में सभी के लिए G में ab है जैसे कि a * b = b * a = e जहां e न्यूट्रल एलिमेंट है (Existence of Inverse)

ऐनक

इनपुट n ^ 2-1 अक्षरों की एक स्ट्रिंग का है (मैग्मा के प्रत्येक तत्व के लिए एक वर्ण, अनुमत 0-9, az हैं) और बस ऑपरेटर द्वारा नाम को पढ़ते हुए, पंक्ति द्वारा तालिका रीड रो का प्रतिनिधित्व करता है। आप मान सकते हैं कि इनपुट एक वैध मैग्मा का प्रतिनिधित्व करता है (जिसका अर्थ है कि प्रत्येक तत्व हेडर पंक्ति / कॉलम में बिल्कुल एक बार शामिल होता है)।

उदाहरण: यहाँ हमारे पास Z_4 की तालिका है

+ | 0 1 2 3
-----------
0 | 0 1 2 3
1 | 1 2 3 0
2 | 2 3 0 1
3 | 3 0 1 2

इनपुट स्ट्रिंग हो जाएगा 012300123112302230133012। (या यदि हम प्रतीकों का उपयोग करते हैं तो यह भी हो सकता है nezdnnezdeezdnzzdneddnez)। ध्यान रखें कि पंक्ति और स्तंभ में तत्वों का क्रम समान नहीं होना चाहिए, इसलिए Z_4 की तालिका भी इस तरह दिख सकती है:

+ | 1 3 2 0
-----------
1 | 2 0 3 1
0 | 1 3 2 0
2 | 3 1 0 2
3 | 0 2 1 3

इसका अर्थ यह भी है कि प्रथम स्तंभ या प्रथम पंक्ति में तटस्थ तत्व आवश्यक नहीं है।

यदि यह एक समूह है, तो कार्यक्रम को तटस्थ तत्व का प्रतिनिधित्व करने वाले चरित्र को वापस करना है। यदि नहीं, तो उसे मिथ्या लौटना होगा (मान 0-9 az से अलग) मान

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

गैर-समूहों को आसानी से स्ट्रिंग के एक अंक को बदलकर या एक ऑपरेशन को परिभाषित करने वाली तालिकाओं को कृत्रिम रूप से बदलकर बनाया जा सकता है जो समूह के एक स्वयंसिद्ध खंडन करता है।

समूह

तुच्छ

* | x
-----
x | x

xxx

Neutral Element: x

एच (चतुर्भुज समूह)

* | p t d k g b n m 
-------------------
m | b d t g k p m n 
p | m k g d t n p b 
n | p t d k g b n m 
b | n g k t d m b p 
t | g m n p b k t d 
d | k n m b p g d t 
k | t b p m n d k g 
g | d p b n m t g k 

ptdkgbnmmbdtgkpmnpmkgdtnpbnptdkgbnmbngktdmbptgmnpbktddknmbpgdtktbpmndkggdpbnmtgk

Neutral Element: n

D_4

* | y r s t u v w x
-------------------
u | u x w v y t s r
v | v u x w r y t s
w | w v u x s r y t
x | x w v u t s r y
y | y r s t u v w x
r | r s t y v w x u
s | s t y r w x u v
t | t y r s x u v w


yrstuvwxuuxwvytsrvvuxwrytswwvuxsrytxxwvutsryyyrstuvwxrrstyvwxusstyrwxuvttyrsxuvw

Neutral Element: y

Z_6 x Z_2

x | 0 1 2 3 5 7 8 9 a b 4 6
---------------------------
0 | 0 1 2 3 5 7 8 9 a b 4 6 
1 | 1 2 3 4 0 8 9 a b 6 5 7 
2 | 2 3 4 5 1 9 a b 6 7 0 8 
7 | 7 8 9 a 6 2 3 4 5 0 b 1 
8 | 8 9 a b 7 3 4 5 0 1 6 2 
9 | 9 a b 6 8 4 5 0 1 2 7 3 
a | a b 6 7 9 5 0 1 2 3 8 4 
b | b 6 7 8 a 0 1 2 3 4 9 5 
3 | 3 4 5 0 2 a b 6 7 8 1 9 
4 | 4 5 0 1 3 b 6 7 8 9 2 a 
5 | 5 0 1 2 4 6 7 8 9 a 3 b 
6 | 6 7 8 9 b 1 2 3 4 5 a 0 

01235789ab46001235789ab4611234089ab6572234519ab67087789a623450b1889ab7345016299ab684501273aab6795012384bb678a0123495334502ab67819445013b67892a5501246789a3b66789b12345a0

Neutral Element: 0

A_4

* | i a b c d e f g h j k l
---------------------------
i | i a b c d e f g h j k l
a | a b i e c d g h f l j k
b | b i a d e c h f g k l j
c | c f j i g k a d l b e h
d | d h k b f l i e j a c g
e | e g l a h j b c k i d f
f | f j c k i g d l a h b e
g | g l e j a h c k b f i d
h | h k d l b f e j i g a c
j | j c f g k i l a d e h b
k | k d h f l b j i e c g a
l | l e g h j a k b c d f i

iabcdefghjkliiabcdefghjklaabiecdghfljkbbiadechfgkljccfjigkadlbehddhkbfliejacgeeglahjbckidfffjckigdlahbegglejahckbfidhhkdlbfejigacjjcfgkiladehbkkdhflbjiecgalleghjakbcdfi

Neutral Element: i

गैर-समूह

एक लूप (समूह लापता संघात्मकता, या तटस्थ तत्व वाला एक अर्ध-समूह)

* | 1 2 3 4 5
-------------
1 | 1 2 3 4 5 
2 | 2 4 1 5 3 
3 | 3 5 4 2 1 
4 | 4 1 5 3 2 
5 | 5 3 2 1 4

12345112345224153335421441532553214

Neutral Element: 1
(2*2)*3 = 4*3 = 5 != 2 = 2*1 = 2*(2*3)

IP- पाश ( http://www.quasigroups.eu/contents/download/2008/16_2.pdf से )

* | 1 2 3 4 5 6 7
-----------------
1 | 1 2 3 4 5 6 7
2 | 2 3 1 6 7 5 4
3 | 3 1 2 7 6 4 5
4 | 4 7 6 5 1 2 3
5 | 5 6 7 1 4 3 2
6 | 6 4 5 3 2 7 1
7 | 7 5 4 2 3 1 6

123456711234567223167543312764544765123556714326645327177542316

Neutral Element: 1
2*(2*4) = 2*6 = 5 != 7 = 3*4 = (2*2)*4

Monoid (Quincunx द्वारा, धन्यवाद!)

मोनाडोस, मैगमास विद एसोसिएटिविटी और एक तटस्थ तत्व है।

* | 0 1 2 3
-----------
0 | 0 1 2 3
1 | 1 3 1 3
2 | 2 1 0 3
3 | 3 3 3 3

012300123113132210333333

Neutral Element: 0

एक और मोनॉयड

(गुणन मॉड 10, 5 के बिना) हम स्पष्ट रूप से व्युत्क्रम नहीं करते हैं, और संघटन गुणन मॉडुलो 10 द्वारा दिया जाता है।

* | 1 2 3 4 6 7 8 9
-------------------
1 | 1 2 3 4 6 7 8 9
2 | 2 4 6 8 2 4 6 8
3 | 3 6 9 2 8 1 4 7
4 | 4 8 2 6 4 8 2 6
6 | 6 2 8 4 6 2 8 4
7 | 7 4 1 8 2 9 6 3
8 | 8 6 4 2 8 6 4 2
9 | 9 8 7 6 4 3 2 1

Neutral Element: 1   12346789112346789224682468336928147448264826662846284774182963886428642998764321

Comments

सोचा था कि मैं एक और मेज, बहुत बड़ा, सिर्फ मनोरंजन के लिए जोड़ूंगा

— जस्टिन

बस मज़े के लिए, यहाँ एक और बहुत बड़ा 0-9a-zनियम है जो नियम को तोड़ता है : ideone.com/vC0ewt

— जस्टिन

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

— edc65

@ एडीसी समूह आवश्यक रूप से कम्यूटेटिव नहीं होते (कॉम्यूटेटिव ग्रुप को एबेलियन कहा जाता है)। समूह की परिभाषा पूर्ण है (यह सामान्य परिभाषा है), अतिरिक्त कुछ भी अतिरिक्त प्रतिबंध प्रदान करेगा। उन तालिकाओं में तटस्थ तत्व के साथ गुणा आमतौर पर पहली पंक्ति / कॉलम में होता है, और हेडर पंक्ति / कॉलम के तत्वों का क्रम आमतौर पर समान होता है, लेकिन आप फिर भी उन सम्मेलनों का पालन किए बिना एक वैध तालिका लिख ​​सकते हैं, जो मैं यहाँ शामिल करना चाहता था।

— flawr

मैंने कुछ टिप्पणियों को हटा दिया जो अप्रचलित प्रतीत हुईं। कृपया मुझे ऐसी किसी भी टिप्पणी के बारे में सूचित करें, जिसे अनलेट किया जाना चाहिए।

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

Answer 1

ऑक्टेव, 298 290 270 265 चार्ट

function e=g(s)
c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')');
for i=2:b a(a==a(i))=i-1;end;
a=a(2:b,2:b--);u=1:b;
e=(isscalar(e=find(all(a==u')))&&a(e,:)==u&&sum(t=a==e)==1&&t==t')*e;
for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;e=d(e+1);

265: हटाए गए अनावश्यक फ़ंक्शन हैंडल।

270: आखिरकार, ई कि हमेशा संतोषजनक ई केe==h लिए जाँच एक · ए और एच हमेशा एक · एच = एक संतोषजनक नहीं था आवश्यक नहीं था। यह उनके लिए अलग होना संभव नहीं है ( e · h =? )।

नीचे दिए गए समाधान के लिए स्पष्टीकरण से विवरण अभी भी प्रासंगिक हैं।

---

290:

function e=g(s)
c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')');
for i=2:b a(a==a(i))=i-1;end;
a=a(2:b,2:b--);u=1:b;
s=@isscalar;e=(s(e=find(all(a==u')))&&s(h=find(all(a'==u')'))&&sum(t=a==e)==1&&t==t')*e;
for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;e=d(e+1);

पहली पंक्ति

c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')'); बस इनपुट को nxn तालिका (ऑपरेशन चिह्न के स्थान पर शून्य वर्ण के साथ) में संग्रहीत करता है, और फिर लेक्सिकोग्राफ़िक रूप से स्तंभों और पंक्तियों को क्रमबद्ध करता है, ताकि पंक्तियाँ और स्तंभ समान क्रम प्राप्त करें:

+ | z a t b                        + | a b t z
-----------                        -----------
z | t b a z         becomes        a | t a z b
b | z a t b      ============>     b | a b t z
t | a z b t                        t | z t b a
a | b t z a                        z | b z a t

अब, मैं "a","b","t","z"मानक के लिए 1, 2, 3, 4फिर से तैयार करता हूं, ताकि मैं कुशलतापूर्वक तालिका को अनुक्रमित कर सकूं। यह रेखा द्वारा किया जाता है for i=2:b a(a==a(i))=i-1;end;। यह तालिका की तरह पैदावार देता है

0   1   2   3   4
1   3   1   4   2
2   1   2   3   4
3   4   3   2   1
4   2   4   1   3

, जहां हम पहली पंक्ति और कॉलम से छुटकारा पा सकते हैं a=a(2:b,2:b--);u=1:b;:

3  1  4  2
1  2  3  4
4  3  2  1
2  4  1  3

इस तालिका में दिए गए गुण हैं:

• यदि तटस्थ तत्व ई मौजूद है, तो ठीक एक ( isscalar) पंक्ति और एक कॉलम में पंक्ति वेक्टर का मूल्य होता है u=[1 2 3 ... number-of-elements]:

s=@isscalar;e=(s(e=find(all(a==u')))&&s(h=find(all(a'==u')'))&&...

• यदि प्रत्येक तत्व एक एक रिवर्स तत्व है एक ' , दो बातें पकड़: तटस्थ तत्व ई केवल प्रत्येक स्तंभ एक बार और केवल एक बार प्रत्येक पंक्ति (होता है sum(t=a==e)==1) और, को पूरा करने के लिए एक' · एक = एक · एक ' , की आवृत्तियां ई कर रहे हैं अनुवाद के संबंध में सममितt==t'

• a · b को सरल t(a,b)अनुक्रमण द्वारा प्राप्त किया जा सकता है । फिर हम बोरिंग लूप में संबद्धता की जांच करते हैं:

for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;

e=d(e+1)यदि तालिका किसी समूह का वर्णन नहीं करती है तो फ़ंक्शन तटस्थ तत्व को मूल तालिका ( ) या शून्य वर्ण में प्रकट करता है।

Comments

अच्छा किया और अच्छी तरह समझाया। 1 के बजाय तटस्थ तत्व वापस करना चाहिए

— edc65

सही किया, अब उचित मूल्य लौटाता है।

— pawel.boczarski

OCTAVE FTW =) मुझे दो चीजों (मैटलाब से आने वाली) के बारे में निश्चित नहीं है, लेकिन शायद आप इसका उपयोग अपने उत्तर को बेहतर बनाने के लिए कर सकते हैं: क्या `a (f (a == a (i))) = i-1` को कम किया जा सकता है को a(a==a(i))=i-1? इसके अलावा आप शायद के (...)^.5बजाय उपयोग कर सकते हैं sqrt(...)।

— flawr

@flawr धन्यवाद, वे दोनों ऑक्टेव (संस्करण 3.8.1) में काम करते हैं।

— pawel.boczarski

Answer 2

रूबी, 401 ... 272

f=->s{n=(s.size+1)**0.5
w=n.to_i-1
e=s[0,w].split''
s=s[w,n*n]
m={}
w.times{(1..w).each{|i|m[s[0]+e[i-1]]=s[i]}
s=s[n,n*n]}
s=e.find{|a|e.all?{|b|x=m[a+b]
x==m[b+a]&&x==b}}
e.all?{|a|t=!0
e.all?{|b|x=m[a+b]
t||=x==m[b+a]&&x==s
e.all?{|c|m[m[a+b]+c]==m[a+m[b+c]]}}&&t}&&s}

यह मेरा पहला माणिक्य कार्यक्रम है! यह एक लंबो फ़ंक्शन को परिभाषित करता है जिसे हम करके परीक्षण कर सकते हैं puts f[gets.chomp]। मैं falseअपने झूठे मूल्य के लिए लौटता हूं। फ़ंक्शन की पहली छमाही बस इनपुट को एक नक्शे में पार्स कर रही है, फिर दूसरी छमाही संभावनाओं की जांच करती है।

f=->s{
    n=((s.size+1)**0.5).to_i
    w=n-1
    e=s[0,w].split'' # create an array of elements of the potential group
    s=s[w,n*n]
    m={} # this map is what defines our operation
    w.times{
        (1..w).each{               # for each element in the row of the table
            |i|m[s[0]+e[i-1]]=s[i] # put the value into the map
        }
        s=s[n,n*n]
    }
    s=e.find{|a| # s is the identity
        e.all?{|b|
            x=m[a+b]
            x==m[b+a]&&x==b # is a the identity?
        }
    }
    e.all?{|a| # implicit return statement
        t = !0 # t = false
        e.all?{|b| # check for inverses
            x=m[a+b]
            t ||= x==m[b+a]&&x==s # t is now true if b was a's inverse
            e.all?{|c|
                m[m[a+b]+c]==m[a+m[b+c]] # check associativity
            }
        } && t
    }&&s
}

Comments

रूबी में गोल्फिंग के चमत्कारों में आपका स्वागत है! ;) nilकी तुलना में एक कम मिथ्या मूल्य है false। फ़ंक्शंस को लंबोदर के रूप में परिभाषित किया जा सकता है जैसे q=->{abort'false'}(यदि वे पैरामीटर लेते हैं, तो []इसके बजाय उन्हें कॉल करने के लिए उपयोग करें ())। मेरा मानना ​​है कि .charsआपको पहले से ही एक सरणी देनी चाहिए, इसलिए इसकी कोई आवश्यकता नहीं है .to_a। यदि आप एक अनुगामी newline की जरूरत नहीं है एक प्लस अंतरिक्ष की $><<तुलना में कम एक बाइट putsहै। Hash.newकोष्ठक की जरूरत नहीं है। यही सब मैं अभी देख सकता हूं। कीप आईटी उप! ;)

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

charsबात अजीब है। रूबी आप किस संस्करण का उपयोग कर रहे हैं?

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

@ मार्टिनबटनर 1.9.3

— जस्टिन

आह, ठीक है, मैं 2.1.5 के प्रलेखन को देख रहा हूं।

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

आप बदल सकते हैं Math.sqrt(...)के साथ ...**0.5। इसके अलावा, a if bफिर से लिखा जा सकता है: b&&aदो स्थानों से बचने के लिए

— क्रिस्टियन लुपस्कु

Answer 3

जावास्क्रिप्ट (ईएस 6) 285 243 278

परीक्षण करने के लिए स्निपेट चलाएं (ES6 होने के नाते यह केवल फ़ायरफ़ॉक्स पर काम करता है)

2 बग फिक्स संपादित करें । मैं तटस्थ तत्व को खोजने में गलत था, सिर्फ एक तरह से जांच कर रहा था। (बेहतर परीक्षण मामलों की आवश्यकता है !!!)

डबल इंडेक्स (जैसे @Quincunx) के बजाय सरल स्ट्रिंग कॉन्फैनेटेशन का उपयोग करके संपादित करें , मुझे नहीं पता कि मैं क्या सोच रहा था। इसके अलावा, सरल उलटा चेक, यह अभी भी काम करना चाहिए।

F=t=>(
  e=t.slice(0,d=Math.sqrt(t.length)|0),
  t=t.slice(d).match('.'.repeat(d+1),'g'),
  t.map(r=>{
    for(v=r[i=0],
        j=e.search(v)+1, // column for current row  element
        r!=v+e|t.some(r=>r[j]!=r[0])?0:n=v; // find neutral
        c=r[++i];
       )h[v+e[i-1]]=c
  },h={},n=''),
  e=[...e],!e.some(a=>e.some(b=>(
    h[a+b]==n&&--d, // inverse
    e.some(c=>h[h[a+b]+c]!=h[a+h[b+c]]) // associativity
  )
  ))&&!d&&n
)

input { width: 400px; font-size:10px }

Click on textbox to test - Result : <span id=O></span><br>
<input value='...' onclick='O.innerHTML=F(this.value)'> (?)
<br>Groups<br>
<input value='nezdnnezdeezdnzzdneddnez' onclick='O.innerHTML=F(this.value)'> (n)<br>
<input value='ptdkgbnmmbdtgkpmnpmkgdtnpbnptdkgbnmbngktdmbptgmnpbktddknmbpgdtktbpmndkggdpbnmtgk' onclick='O.innerHTML=F(this.value)'> (n)<br>
<input value='yrstuvwxuuxwvytsrvvuxwrytswwvuxsrytxxwvutsryyyrstuvwxrrstyvwxusstyrwxuvttyrsxuvw' onclick='O.innerHTML=F(this.value)'> (y)<br>
<input value='01235789ab46001235789ab4611234089ab6572234519ab67087789a623450b1889ab7345016299ab684501273aab6795012384bb678a0123495334502ab67819445013b67892a5501246789a3b66789b12345a0'onclick='O.innerHTML=F(this.value)'> (0)<br>
Non groups <br>
<input value='12345112345224153335421441532553214' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>
<input value='123456711234567223167543312764544765123556714326645327177542316' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>
<input value='012300123113132210333333' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>

Answer 4

हास्केल 391 बी

import Data.Maybe
import Data.List
o a b=elemIndex b a
l£a=fromJust.o a$l
a§b=[a!!i|i<-b]
f s|isJust j&&and(map(isJust.o h)s)&&and[or[p%q==e|q<-h]&&and[p%(q%r)==(p%q)%r|q<-h,r<-h]|p<-h]=[e]|True="!"where n=floor$(sqrt(fromIntegral$length s+1))-1;h=take n s;g=[s§[a..b]|(a,b)<-zip[1+n,2+n+n..][n+n,3*n+1..(n+1)^2]];v=s§[n,1+2*n..n+n*n];a%b=g!!(b£v)!!(a£h);j=o g h;e=v!!fromJust j

उन लोगों को शाप import!

import Data.Maybe
import Data.List

{- rename elemIndex to save characters -}
o a b=elemIndex b a

{- get the index of l in a -}
l£a=fromJust.o a$l

{- extract a sublist of a with indices b -}
a§b=[a!!i|i<-b]

f s |isJust j {-Identity-}
     &&and (map (isJust.o h) s) {-Closure-}
     &&and[
        or [p%q==e|q<-h] {-Inverse-}
        && and [ p%(q%r)==(p%q)%r | q<-h,r<-h ] {-Associativity-}
     |
        p<-h
     ]=[e]
    |True="!"
    where
    {-size-}    n=floor$(sqrt(fromIntegral$length s+1))-1
    {-horiz-}   h=take n s
    {-table-}   g=[s§[a..b]|(a,b)<-zip[1+n,2+n+n..][n+n,3*n+1..(n+1)^2]]
    {-vert-}    v=s§[n,1+2*n..n+n*n]
    {-operate-} a%b=g!!(b£v)!!(a£h)
                j=o g h {-index of the first row identical to the top-}
    {-ident-}   e=v!!fromJust j

व्याख्या

f::String->Stringe::Charपहचान तत्व, या तो स्ट्रिंग को मैप करता है !।

whereखंड चर और कार्यों का एक समूह है, जो मैं टिप्पणी की है बनाता है; v::[Int]तत्वों की ऊर्ध्वाधर सूची, h::[Int]क्षैतिज एक है।

%::Char->Char->Char समूह ऑपरेशन को उसके तर्कों पर लागू करता है।

g::[[Int]]समूह तालिका है (उपयोग करने के लिए डेरेफेरिंग के लिए %)

j::Maybe Intvयदि यह मौजूद है, तो पहचान का सूचकांक शामिल है, अन्यथा Nothing, यही कारण isJust jहै कि fपहचान के लिए स्थिति है ।

Comments

क्या आप थोड़ा समझा सकते हैं कि यहाँ क्या चल रहा है?

— xebtl

मैंने कुछ टिप्पणियां जोड़ दी हैं, लेकिन मूल सार 'समूह तालिका में परीक्षण लागू करें' है। ध्यान दें कि {- -}एक टिप्पणी है। क्या आपके पास कोई और विशिष्ट प्रश्न हैं, या क्या यह स्पष्ट है?

— अलेक्जेंडर-ब्रेट

धन्यवाद। मैं वास्तव में इसे समझने के लिए अनुमान लगाता हूं कि मुझे पहले कुछ हास्केल सीखने की आवश्यकता होगी :-)

— xebtl