केरेल जे अल्फबॉट सीक्वेंस जेनरेटर

स्कोर

प्रवेश करते ही यह अनुभाग भर जाएगा।

साधारण

1. bopjesvla    Perl                54
2. edc65        Javascript (ES6)    91
3. name         language            score
4. name         language            score
5. name         language            score

बोनस दौर

1. name   language   score
2. name   language   score
3. name   language   score
4. name   language   score
5. name   language   score

कारेल जे अल्फबोट

पृष्ठभूमि

जावा के लिए एक लोकप्रिय परिचयात्मक पाठ्यक्रम है केरेल जे। रोबोट (मैं इसे स्वयं उपयोग कर रहा हूं)। रोबोट सड़कों की एक ग्रिड (पॉजिटिव पूर्णांक y-निर्देशांक) और रास्ते (पॉजिटिव पूर्णांक x-निर्देशांक) के साथ-साथ बीपर्स के साथ इंटरैक्ट करता है, जिसे ग्रिड पर रखा और संग्रहीत किया जा सकता है (ध्यान दें कि कैरेल और किसी भी बीपर्स केवल जाली पर मौजूद हो सकते हैं अंक)। कारेल (रोबोट) केवल पांच क्रियाओं को करने के लिए है: 1 से आगे बढ़ें, जगह में बाएं मुड़ें, एक बीपर नीचे रखें, एक बीपर उठाएं और खुद को बंद करें।

मेरे कंप्यूटर विज्ञान वर्ग में, हमारा पहला असाइनमेंट कारेल को यह सीखने के लिए था कि कैसे दाहिने मुड़ें, चारों ओर मुड़ें, और 1 से आगे बढ़ने और एक बीपर लगाने की संयुक्त कार्रवाई करें। कुछ दिनों बाद एक असाइनमेंट इन विधियों का उपयोग करना था और वर्णमाला के अक्षरों का उत्पादन करने के लिए नए तरीके लिखना था।

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

जब भी मैंने private void draw#प्रत्येक चरित्र के लिए लिखा #, मैंने इसके बाद एक टिप्पणी जोड़ी, जो मुझे आज्ञाओं के अनुक्रम के लिए संक्षिप्त रूप से बताएगी, जिनकी मुझे आवश्यकता होगी।

मेरे पास मेरे निपटान में निम्नलिखित कमांड (pseudocode में लिखा गया है) (स्पष्टीकरण - ये केवल उपयोगी कमांड हैं)।

Turn Left
    Rotate the robot 90˚ counterclockwise
    Abbreviated as "l"

Turn Right
    Rotate the robot 90˚ clockwise
    Abbreviated as "r"

Move
    Move one space forwards
    Abbreviated as "m"

Put Beeper
    Put a beeper on the spot that Karel is on
    Abbreviated as "p"

Drop Beeper
    Move, then Put Beeper
    Abbreviated as "d"

Turn Around
    Turn Left, then Turn Left
    Abbreviated as "a"

शर्तेँ

रोबोट को निम्न क्रम में आगे बढ़ना चाहिए।

रोबोट न्यूनतम क्षेत्र के 5xN आयत के निचले बाएं कोने पर शुरू होता है जिसमें पत्र खींचा जाएगा।
रोबोट पत्र खींचता है।
रोबोट आयत के निचले दाएं कोने में जाता है।
रोबोट दो स्थानों को दाईं ओर ले जाता है और उत्तर / अप का सामना करना पड़ता है

एक उदाहरण के माध्यम से काम करते हैं। मान लीजिए हम ड्रा करना चाहते हैं A। रोबोट का स्थान अक्षर है जो इसकी दिशा (उत्तर, दक्षिण, पूर्व, पश्चिम) को इंगित करता है। यदि रोबोट एक बीपर और लोअरकेस के साथ स्पॉट पर है, तो अक्षर कैपिटल में है यदि रोबोट बिना बीपर के स्पॉट पर है। oबीपर्स के साथ स्पॉट का प्रतिनिधित्व करता है और .बीपर्स के बिना स्पॉट का प्रतिनिधित्व करता है।

जैसा कि हम बाद में देखेंगे, Aक्या यह है।

.ooo.
o...o
ooooo
o...o
o...o

यहाँ एक संभव समाधान है।

Grids   .....   .....   .....   .....   .....   .....   .....   .....   .....
        .....   .....   .....   .....   .....   .....   .....   .....   .....
        .....   .....   .....   N....   E....   oE...   ooE..   oooE.   oooW.
        .....   .....   N....   o....   o....   o....   o....   o....   o....
        n....   N....   o....   o....   o....   o....   o....   o....   o....

Letters           p       d       d       r       d       d       d       a

        .....   .....   .....   .....   .....   n....   e....   .E...   .oE..
        .....   .....   .....   .....   N....   o....   o....   o....   o....
        ooWo.   oWoo.   Wooo.   Nooo.   oooo.   oooo.   oooo.   oooo.   oooo.
        o....   o....   o....   o....   o....   o....   o....   o....   o....
        o....   o....   o....   o....   o....   o....   o....   o....   o....

          m       m       m       r       d       m       r       d       d

        .ooE.   .oooe   .ooos   .ooo.   .ooo.   .ooo.   .ooo.   .ooo.
        o....   o....   o....   o...S   o...o   o...o   o...o   o...o
        oooo.   oooo.   oooo.   oooo.   ooooS   ooooo   ooooo   ooooo
        o....   o....   o....   o....   o....   o...S   o...o   o...o
        o....   o....   o....   o....   o....   o....   o...S   o...E

          d       m       r       d       d       d       d       l

mmlचौथी गोली को पूरा करने के लिए अंतिम निहित है क्योंकि यह प्रत्येक पत्र में दिखाई देता है और क्योंकि मैं वापस नहीं जाना चाहता हूं और उपरोक्त प्रस्तावित समाधान में सब कुछ के लिए एक और दो कॉलम जोड़ना चाहता हूं।

इस प्रकार, बनाने के लिए एक समाधान Aहै pddrdddammmrdmrdddmrddddlmml।

ध्यान दें कि यह आपका समाधान नहीं है। आपका एल्गोरिथ्म हर कॉलम के माध्यम से जा सकता है, उचित स्थानों पर बीपर्स लगा सकता है और यह भरोसा नहीं कर सकता है कि अन्य बीपर्स को कहां रखा गया है या रखा जाएगा। कोई फर्क नहीं पड़ता कि आपका एल्गोरिथ्म क्या है, रोबोट ग्रिड पर प्रति जगह केवल एक बीपर रख सकता है।

कार्यक्रम

आपका प्रोग्राम इसके इनपुट के रूप में लेगा 5xN ग्रिड जो पत्र के लिए ग्रिड है। ध्यान दें कि इनपुट पर कोई रोबोट नहीं है; रोबोट को उत्तर की ओर नीचे (दक्षिण-पश्चिम) कोने पर माना जाता है।

आउटपुट अक्षरों का अनुक्रम होगा जो अनुक्रम के लिए आशुलिपि हैं।

नमूना इनपुट

.ooo.
o...o
ooooo
o...o
o...o

o...o.ooooo
o...o...o..
ooooo...o..
o...o...o..
o...o.ooooo

नमूना आउटपुट

pddrdddammmrdmrdddmrddddlmml

prmmmlmlmmdrdrdddlmlmmdrdrmmmdrddddlmmlprdddlmldmmrmrmdmlmldmmrdrddddrmmmdlmml

यह कोड गोल्फ, फाल्स है। मानक सीजी नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

बोनस दौर

नियम

यदि आप बोनस राउंड में भाग लेना चाहते हैं, तो अपने कोड को कुशल बनाना सुनिश्चित करें! नीचे मेरे द्वारा बनाए गए 5x5 पत्रों में से एक पुस्तकालय है जब यह चलता है। बोनस राउंड का उद्देश्य एक प्रोग्राम लिखना है जो उस के लिए एक अनुक्रम प्रिंट करता ABCDEFGHIJKLMNOPQRSTUVWXYZहै जिसमें संभव के रूप में कुछ चालें शामिल हैं। STDIN का कोई इनपुट नहीं है। कोड वर्गीकृत किया जाएगा नहीं कोड की लंबाई पर लेकिन इसकी पर "कदम स्कोर।" चाल स्कोर स्वीपर एल्गोरिदम को हतोत्साहित करने के लिए डिज़ाइन किया गया है जो आयत में हर बिंदु पर जाते हैं।

d: 1
l: 1
m: 4
p: 1
r: 1

पत्र

.ooo.   oooo.   ooooo   oooo.   ooooo   ooooo   .oooo   o...o
o...o   o...o   o....   o...o   o....   o....   o....   o...o
ooooo   oooo.   o....   o...o   oooo    oooo.   o.ooo   ooooo
o...o   o...o   o....   o...o   o....   o....   o...o   o...o
o...o   oooo.   ooooo   oooo.   ooooo   o....   oooo.   o...o

ooooo   ....o   o...o   o....   ooooo   o...o   ooooo   oooo.
..o..   ....o   o..o.   o....   o.o.o   oo..o   o...o   o...o
..o..   ....o   oo...   o....   o.o.o   o.o.o   o...o   oooo.
..o..   o...o   o..o.   o....   o...o   o..oo   o...o   o....
ooooo   .ooo.   o...o   ooooo   o...o   o...o   ooooo   o....

oooo.   oooo.   ooooo   ooooo   o...o   o...o   o...o   o...o
o..o.   o...o   o....   ..o..   o...o   o...o   o...o   .o.o.
o..o.   oooo.   ooooo   ..o..   o...o   .o.o.   o.o.o   ..o..
oooo.   o..o.   ....o   ..o..   o...o   .o.o.   o.o.o   .o.o.
....o   o...o   ooooo   ..o..   ooooo   ..o..   ooooo   o...o

o...o   ooooo
.o.o.   ...o.
..o..   ..o..
.o...   .o...
o....   ooooo

मूल चुनौती के रूप में एक ही प्रक्रिया का पालन किया जाना चाहिए: अक्षरों को प्रत्येक अक्षर के बीच एक अंतरिक्ष पृथक्करण के साथ एक समय में खींचा जाना चाहिए।

मानक सीजी नियम लागू होते हैं। सबसे कम चाल स्कोर जीत के साथ प्रवेश।

संक्षेप में, दोनों कोड अनिवार्य रूप से एक ही काम करेंगे। पहले कोड में कम से कम बाइट्स की संख्या होनी चाहिए, और दूसरे कोड में छोटी संख्या के चाल का उपयोग करना चाहिए।

code-golf

— आर्कटुरस
स्रोत

नीट चुनौती - कोई विचार नहीं है कि आप नीचे क्यों जा रहे हैं।

— देसुवि

धन्यवाद @Deusovi काश, वे समझाते कि मैं ऐसा क्यों कर सकता हूं जो कुछ भी स्पष्ट नहीं कर सकता है या इसे सुधारना नहीं है।

— आर्कटिकस

" करेल (रोबोट) केवल पाँच क्रियाओं को करने के लिए है ": मुझे लगता है कि आप " सक्षम " याद कर रहे हैं , और आप निश्चित रूप से पाँचवीं क्रिया को याद कर रहे हैं। और मुझे यकीन नहीं है कि बोनस राउंड क्या है: क्या आप उस व्यक्ति को इनाम देने जा रहे हैं जो सबसे अच्छा समाधान लिखता है?

— पीटर टेलर

शायद एक कोड गोल्फ चुनौती के बजाय इसे एक न्यूनतम चाल गोल्फ चुनौती में बदल दें? चूंकि यह दक्षता के बारे में है।

— LukStorms

चालों के सीमित सेट के साथ एक न्यूनतम चाल चुनौती कोड गोल्फ भाग के बिना दिलचस्प नहीं है। यह इष्टतम पथ BFS के लिए बहुत आसान होना चाहिए।

— bopjesvla 16

जवाबों:

perl -p0, 60 56 54 + 2 बाइट्स

गोल्फ़

/
/;$:="m"x"@-";$_=mmmmlma.s/
/rmr$:a/gr.mml;y/.o/md/;

टिप्पणियाँ

/\n/; # capture the length of the first line
$:="m"x"@-"; # assign a string of m's with that length to $:
s/^/mmmmlmll/; # move to the starting position (-1,0)
s/\n/rmr$:rr/g; # replace all newlines with kareliage returns
y/.o/md/; # replace dots with moves and o's with drops
s/$/mml/; # append mml

— bopjesvla
स्रोत

पर्ल का अच्छा उपयोग @-, पर्ल प्रश्न में गोल्फिंग के सुझावों पर साझा करने के लिए एक उपयोगी हो सकता है !

— डोम हेस्टिंग्स

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

बुनियादी चुनौती के लिए पहले प्रयास करें।

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण (फ़ायरफ़ॉक्स में परीक्षण)

कोड स्निपेट दिखाएं

// BASIC CHALLENGE ANSWER

f=s=>`mmmmr${[...s].map(c=>c<' '?[`mrmr${b}a`,b=m][0]:(b+=m,c>m?'pm':m),b=m='m').join``}ml`

/* ALSO ...
f=s=>`mmmmr${s.replace(/.|\s/g,c=>c<' '?[`mrmr${b}a`,b=m][0]:(b+=m,c>m?'pm':m),b=m='m')}ml`
*/


// TEST
// now, I need to implement Karel (and test it) to do a significant test
// (a super limited version of Karel, of course. Just what is needed)

Karel=(cmd, width, height) =>  // even if for this test we have a limited height to handle
{ 
  var grid = [...('.'.repeat(width)+'\n').repeat(height)],
  o = width+1,
  p = o*(height-2)+1,
  d = [-o, 1, o, -1], // direction offsets
  q = 0, // face up
  s = [...grid],    
  steps = [];

  s[p] = 'n';
  steps.push([s.join``,'-']);
  
  [...cmd].forEach(c => 
    (
      c == 'l' ? q = q-1 &3
      : c == 'r' ? q = q+1 &3
      : c == 'a' ? q = q+2 &3
      : c == 'm' ? p += d[q]
      : c == 'p' ? grid[p] = 'o'
      : c == 'd' ? grid[p += d[q]] = 'o'
      : 0,
      s = [...grid],  
      s[p] = s[p] == 'o' ? 'NESW'[q] : 'nesw'[q],
      steps.push([s.join``,c])
    )
  )
  return [s.join``,steps]
}  
function go(cmd)
{
  var result = Karel(cmd,260,7)
  RESULT.innerHTML = result[0];
  STEPS.innerHTML = 'Steps:<br>'+result[1].map(x=>'<pre>'+x.join('\n')+'</pre>').join('')
}
function test(input)
{
  var exp = input.innerHTML;
  var cmd = f(exp);
  var result = Karel(cmd,20,7)
  CMD.innerHTML = cmd;
  RESULT.innerHTML = result[0];
  STEPS.innerHTML = 'Steps:<br>'+result[1].map(x=>'<pre>'+x.join('\n')+'</pre>').join('')
}

pre {
  float: left;
  border: 1px solid #888;
  margin: 2px
}

div {
  clear: both;
}

#CMD {
  word-break: break-all;
  white-space: normal;
  width:50%;
  overflow:auto;
}

#Y {
  width:50%;
}

Test cases (click to run a test)<br>
<pre id=T1 onclick='test(this)'>.ooo.
o...o
ooooo
o...o
o...o</pre>
<pre id=T2 onclick='test(this)'>o...o.ooooo
o...o...o..
ooooo...o..
o...o...o..
o...o.ooooo</pre>
<div>Command string:<br><pre id=CMD></pre></div>
<div>
Your Command:<br><input id=Y><button onclick='go(Y.value)'>-></button>
</div>  
<div>Result:<br><pre id=RESULT></pre></div>
<div id=STEPS>Steps</div>

स्निपेट का विस्तार करें

बोनस चुनौती - पूर्ण वर्णमाला = 869 के लिए स्कोर

फ़ायरफ़ॉक्स में नीचे wnippet का परीक्षण करना (बेहतर पूर्ण स्क्रीन)

जैसा कि मुझे निश्चित इनपुट / फिक्स्ड आउटपुट चुनौतियां पसंद नहीं हैं , आप अपने इनपुट को आज़मा सकते हैं। बस याद रखें, केवल पत्र मुद्रित होंगे।

// Optimal - working on small pattern but too slow (scale bad)
// So I build the total command letter by letter - that surely is NOT globally optimal

Key=sol=>sol.pos+' '+sol.setBits

Solve=(target, startRow, startDir, cmd)=>{
  // Target is a rectangle string 5x5, newline separated for total (5+1)*5 chars
  if (target[target.length-1] != '\n') target += '\n';
  
  var T = ~new Date()
  var width = 5, height = 5, startPos = (width+1)*startRow;
  var offset = [-width-1, 1, width+1, -1];
  var turns = [ "", "r", "rr", "l" ];
  var cmds = [ "m", "rm", "rrm", "lm", "d", "rd", "rrd", "ld" ];
  var visited = {}, scan =[[],[],[],[],[],[],[],[]], cscan;
  
  var baseSol = { steps:[], pos: startPos, dir: startDir, setBits: 0};
  var score = 0, j = 0
  var bit, key, turn, curSol, move, result
  var targetBits = 0; 
  [...target].map((c,i)=>targetBits |= ((c=='o')<<i)) // 30 bits
  
  // First step, from outside, set bit in mask if it's set in target
  if (target[startPos]=='o') baseSol.setBits = 1<<startPos;
  console.log(target, targetBits.toString(16))
  visited[Key(baseSol)] = scan[0].push(baseSol);
  

  for (j = 0; j<99; j++)
  {
     cscan = scan[j];
     scan.push([])
     
     // console.log(`T: ${T-~new Date} J: ${j} SC: ${cscan.length}`)
     while (cscan.length > 0)
     {
        baseSol = cscan.pop()
        //console.log('Base', baseSol.dir, baseSol.pos, baseSol.setBits.toString(16), baseSol.steps.length)
        for(turn = 0; turn < 4; turn++)
        {
           // set direction, move and drop if you can
           curSol = {};
           curSol.dir = baseSol.dir + turn & 3;
           curSol.pos = baseSol.pos + offset[curSol.dir];
           // console.log(turn, curSol.dir, curSol.pos)
           if(target[curSol.pos] > ' '
              || curSol.dir == 1 && target[curSol.pos]=='\n'
             ) // if inside grid or on right border facing east
           {
              score = j + (turn == 2 ? 3 : turn == 0 ? 1 : 2);
              bit = 1 << curSol.pos;
              if (targetBits & bit)
                 curSol.setBits = baseSol.setBits | bit, move = 4 | turn;
              else
                 curSol.setBits = baseSol.setBits, score += 3, move = turn;
              if (!visited[key = Key(curSol)]) 
              {
                 curSol.steps = [...baseSol.steps, move] // clone and add
                 // task completed if on  right border and all bits ok
                 if (target[curSol.pos]>' ')
                 { // not on right border, proceed  
                    visited[key] = scan[score].push(curSol)
                 }  
                 else if (curSol.setBits == targetBits)
                 {
                    result = curSol.steps.map(v=>cmds[v]).join``
                    result = (cmd == '' 
                    ? target[startPos]=='o' ? 'p' : '' 
                    : target[startPos]=='o' ? 'd' : 'm') + result;
                    console.log(`T: ${T-~new Date} J: ${j} CMD: ${result}`)
                    return [cmd+result, curSol.pos / (width+1) | 0];
                 }
              }
           }
        }
     }
  }
  // Miserable failure!
  return []
}  

console.log=(...x)=>LOG.innerHTML+=x+'\n';
// TEST
Karel=(cmd, width, height) =>  // even if for this test we have a limited height to handle
{ 
  var grid = [...('.'.repeat(width)+'\n').repeat(height)],
  o = width+1,p = o*(height-2)+1,d = [-o, 1, o, -1], // direction offsets
  steps = [],s = [...grid],q = 0; // face up

  s[p] = 'n';
  steps.push([s.join``,'-']);
  
  [...cmd].forEach(c => 
    (
      c == 'l' ? q = q-1 &3
      : c == 'r' ? q = q+1 &3
      : c == 'a' ? q = q+2 &3
      : c == 'm' ? p += d[q]
      : c == 'p' ? grid[p] = 'o'
      : c == 'd' ? grid[p += d[q]] = 'o'
      : 0,
      s = [...grid],  
      s[p] = s[p] == 'o' ? 'NESW'[q] : 'nesw'[q],
      steps.push([s.join``,c])
    )
  )
  return [s.join``,steps]
}  


var AlphabetMap = `.ooo..oooo..ooooo.oooo..ooooo.ooooo..oooo.o...o.ooooo.....o.o...o.o.....ooooo.o...o.ooooo.oooo..oooo..oooo..ooooo.ooooo.o...o.o...o.o...o.o...o.o...o.ooooo
o...o.o...o.o.....o...o.o.....o.....o.....o...o...o.......o.o..o..o.....o.o.o.oo..o.o...o.o...o.o..o..o...o.o.......o...o...o.o...o.o...o..o.o...o.o.....o.
ooooo.oooo..o.....o...o.oooo..oooo..o.ooo.ooooo...o.......o.oo....o.....o.o.o.o.o.o.o...o.oooo..o..o..oooo..ooooo...o...o...o..o.o..o.o.o...o.....o.....o..
o...o.o...o.o.....o...o.o.....o.....o...o.o...o...o...o...o.o..o..o.....o...o.o..oo.o...o.o.....oooo..o..o......o...o...o...o..o.o..o.o.o..o.o...o.....o...
o...o.oooo..ooooo.oooo..ooooo.o.....oooo..o...o.ooooo..ooo..o...o.ooooo.o...o.o...o.ooooo.o.........o.o...o.ooooo...o...ooooo...o...ooooo.o...o.o.....ooooo`.split('\n')
var LetterMap = [];
var l,row,m;

for (l=0;l<26;l++)
{
  for(m='',row=0;row<5;row++)
    m += AlphabetMap[row].substr(l*6,5)+'\n'
  LetterMap[l]=m;  
}

print=Message=>{
  var Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  var startRow = 4, cmd=''
  var startDir = 0 // start facing UP
  ;[...Message].forEach(l => (
    [cmd, startRow] = Solve(LetterMap[Alphabet.search(l)], startRow, startDir, cmd),
    startDir = 1, // after each letter will be facing RIGHT
    cmd += '\n' // addin a newline (scoring 0) just for readability
  ))

  if (startRow != 4) 
    cmd += 'mr'+'m'.repeat(4-startRow)+'rr' // on last row and facing up
  else 
    cmd += 'ml' // ...facing up

  // Recalc score
  var score = 0
  ;[...cmd].forEach(c=>score += c=='m'? 4 : c<' '? 0: 1)

  var robot = Karel(cmd.replace(/\n/g,''), 26*7, 7)
  O.innerHTML=cmd+'\nScore:'+score
  R.innerHTML=robot[0]
  RS.innerHTML=robot[1].join`\n`
}  

function test()
{
  var msg = I.value.toUpperCase()
  msg=msg.replace(/[^A-Z]/g,'')
  I.value=msg
  print(I.value)
}

test()

fieldset {
  padding:0;
}

pre {
  margin: 2px;
}

#RS {
  height: 200px;
  width: 50%;
  overflow:auto;
}

#I { width: 50% }

<fieldset ><legend>Message to print</legend>
<input id=I value='ABCDEFGHIJKLMNOPQRSTUVWXYZ'><button onclick='test()'>go</button></fieldset>
<fieldset ><legend>Command Result (newlines added for readability)</legend>
<pre id=O></pre></fieldset>
<fieldset ><legend>Robot output</legend>
<pre id=R></pre></fieldset>
<fieldset ><legend>Robot step by step</legend>
<pre id=RS></pre></fieldset>
<fieldset ><legend>log</legend>
<pre id=LOG></pre></fieldset>

स्निपेट का विस्तार करें

— edc65
स्रोत

कैसा रहा बोनस?

— आर्कटिकस

@ एड्रियन बोनस अच्छा चल रहा है। दुर्भाग्य से मेरे पास नौकरी भी है ... :)

— edc65

ठीक है! मैं तुम्हें दोष नहीं देता। आप केवल एक ही हैं जिन्होंने बोनस का प्रयास किया है।

— आर्कटिकस