problem_id
stringlengths
6
6
user_id
stringlengths
10
10
time_limit
float64
1k
8k
memory_limit
float64
262k
1.05M
problem_description
stringlengths
48
1.55k
codes
stringlengths
35
98.9k
status
stringlengths
28
1.7k
submission_ids
stringlengths
28
1.41k
memories
stringlengths
13
808
cpu_times
stringlengths
11
610
code_sizes
stringlengths
7
505
p02546
u001689394
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if not list[x-1] == list[-1]:\n if list[x] == list[x+1]:\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n n = n - 1\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n n = n - 1\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n n = n - 1\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "n = input()\na = 's'\nb = 'es'\nif n[-1] == 's':\n n = n + b\nelse:\n n = n + a", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n n = n - 1\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n n = n - 1\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n n = n - 1\n y = 1\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "list = []\nx = 0\ny = 0\nn = int(input())\nfor i in range(n):\n a,b = map(int,input().split())\n list.append(a)\n list.append(b)\nfor _ in range(n):\n if list[x] == list[x+1]:\n if not list[x+1] == list[-1]:\n if list[x+2] == list[x+3]:\n if not list[x+3] == list[-1]:\n if list[x+4] == list[x+5]:\n y = 1\n if not x+7 > len(list):\n x = x + 2\nif y == 0:\n print('No')\nelse:\n print('Yes')", "n = input()\na = 's'\nb = 'es'\nif n[-1] == 's':\n n = n + b\nelse:\n n = n + a\nprint(n)"]
['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted']
['s039487440', 's119616299', 's436867598', 's441767902', 's492205887', 's312485570']
[8936.0, 9116.0, 9028.0, 9228.0, 9084.0, 9016.0]
[27.0, 34.0, 27.0, 21.0, 28.0, 24.0]
[500, 522, 79, 522, 474, 88]
p02546
u013227739
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nif l[-1] == 's':\n s += 'es'\nelse:\n s += 's'", 's = input()\nl = []\nfor i in s:\n l.append(i)\nif l[-1] == \'s\':\n l.append(\'es\')\n print("".join(j for j in l))\nelse:\n l.append(\'s\')\n print("".join(j for j in l))\n \n \n \n \n \n ']
['Runtime Error', 'Accepted']
['s967267890', 's590706178']
[8960.0, 9112.0]
[24.0, 31.0]
[61, 235]
p02546
u014170064
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['x = input()\nif x.endswith("s") == True:\n x = x + "es"\nelse:\n x = x + "s"', 'x = input()\nif x.endswith("s") == True:\n x = x + "es"\nelse:\n x = x + "s"\nprint(x)']
['Wrong Answer', 'Accepted']
['s745677340', 's358497855']
[9080.0, 8920.0]
[27.0, 26.0]
[74, 83]
p02546
u027977105
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N = int(input())\nz = 0\nfor a in range(N):\n for b in range(N):\n c = N - (a+1)*(b+1)\n if c > 0:\n z = z+1\n else:\n pass\nprint(z)', 's = input()\nif s[-1]=="s":\n t = s + "es"\nelse:\n t = s + "s"\nprint(t)']
['Runtime Error', 'Accepted']
['s876956801', 's845656598']
[9064.0, 9080.0]
[26.0, 25.0]
[170, 74]
p02546
u032625182
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["import os,sys\nc=0\n\nn=input()\nfor i in range(int(n)):\n m=input()\n one=m[0]\n two=m[2]\n if(one==two):\n c+=1\n \nif(c>=3):\n print('Yes')\nelse:\n print('No')\n", "import os,sys\n\ns=input()\nn=len(s)\nif s[n-1]=='s':\n s=s+'es'\nelse:\n s=s+'s'\n\nprint(s)"]
['Runtime Error', 'Accepted']
['s998157104', 's300557894']
[9164.0, 9028.0]
[26.0, 29.0]
[178, 90]
p02546
u034194513
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = list(input())\n\nes = list("es")\nss = list("s")\n\nprint(len(s))\n\n\nf = s[len(s)-1]\nprint(f)\n\nif f == "s":\n ans = s+es\n ans = "".join(ans)\n print(ans)\nelse:\n ans = s+ss\n ans = "".join(ans)\n print(ans)\n \n', 's = list(input())\n\nes = list("es")\nss = list("s")\n\n#print(len(s))\n\n\nf = s[len(s)-1]\n#print(f)\n\nif f == "s":\n ans = s+es\n ans = "".join(ans)\n print(ans)\nelse:\n ans = s+ss\n ans = "".join(ans)\n print(ans)\n \n']
['Wrong Answer', 'Accepted']
['s312740921', 's588080099']
[9120.0, 9032.0]
[34.0, 31.0]
[209, 211]
p02546
u035453792
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\nif s[-1]=="s":\n print(s+"es")\nelse:\n print(s)', 's = input()\nif s[-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']
['Wrong Answer', 'Accepted']
['s770945909', 's540100328']
[8940.0, 8976.0]
[27.0, 26.0]
[59, 63]
p02546
u039526919
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s=input()\nif s[-1]=='s':\n print(s[:-1]+'es')\nelif s[-1]!='s':\n print(s[:-1]+'s')", 'from pattern.en import pluralize, singularize\ns=input()\nprint(pluralize(s))', "s=input()\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')"]
['Wrong Answer', 'Runtime Error', 'Accepted']
['s569734355', 's786356193', 's247164242']
[9088.0, 8948.0, 9020.0]
[31.0, 29.0, 32.0]
[82, 75, 65]
p02546
u050103839
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = str(input())\nif S[-1] == 's':\n S += 's'\nelse:\n S += 'es'\nreturn S\n\n", "S = str(input())\nif S[-1] == 's':\n\tS += 's'\nelse:\n\tS += 'es'\nprint(S)", "S = str(input())\nif S[-1] != 's':\n S += 's'\nelse:\n S += 'es'\nprint(S)"]
['Runtime Error', 'Wrong Answer', 'Accepted']
['s726196521', 's852647444', 's490519169']
[9012.0, 9016.0, 9084.0]
[32.0, 33.0, 30.0]
[73, 69, 71]
p02546
u057362336
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s=input()\nif s[-1]=='s':\n s+='es'\nelse:\n s+='s'", "s=input()\nif s[-1]=='s':\n s+='es'\nelse:\n s+='s'\nprint(s)"]
['Wrong Answer', 'Accepted']
['s403951392', 's673707969']
[9076.0, 9076.0]
[31.0, 31.0]
[49, 58]
p02546
u060012100
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s= input()\nif s.endwith('s'):\n print(s+'es')\nelse:\n print(s+'s')", "s= input()\nif s.endswith('s'):\n print(s+'es')\nelse:\n print(s+'s')"]
['Runtime Error', 'Accepted']
['s871107146', 's839278517']
[9084.0, 9076.0]
[23.0, 30.0]
[66, 67]
p02546
u061835391
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s=input()\nn=len(s)\nif s[n-1]!=s:\n s=s[0:n-1]+'s'\nelse:\n s=s[0:n-1]+'es'\nprint(s)", "s=input()\nn=len(s)\nif s[n-1]!='s':\n s=s[0:n]+'s'\nelif s[n-1]=='s':\n s=s[0:n]+'es'\nprint(s)\n"]
['Wrong Answer', 'Accepted']
['s875057069', 's196072887']
[9032.0, 9024.0]
[27.0, 27.0]
[82, 93]
p02546
u063346608
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S = input()\n\nif len(S)-1 =="e" :\n\tprint(S + "s")\nelse :\n\tprint(S + "es")', 'S = input()\n\nif S[len(S)-1] =="s" :\n\tprint(S + "es")\nelse :\n\tprint(S + "s")']
['Wrong Answer', 'Accepted']
['s087174427', 's225669140']
[9100.0, 9032.0]
[32.0, 30.0]
[72, 75]
p02546
u071905150
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nif s[s.length-1] == 's':\n print(s+'es')\nelse:\n print(s+'s')\n\n", "s = input()\nif s[len(s)-1] == 's':\n print(s+'es')\nelse:\n print(s+'s')\n\n"]
['Runtime Error', 'Accepted']
['s064896218', 's118599423']
[9080.0, 9012.0]
[27.0, 29.0]
[79, 77]
p02546
u075109824
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['import inflect\ns = input()\n\np = inflect.engine()\nprint(p.plural(s))', '# import inflect\ns = input()\n\n# p = inflect.engine()\n# print(p.plural(s))\n\n\nif s[-1:] == "s":\n print(s+"es")\nelse:\n print(s+"s")']
['Runtime Error', 'Accepted']
['s602145761', 's427308694']
[9080.0, 9084.0]
[24.0, 30.0]
[67, 134]
p02546
u085186789
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["words = input()\nif words[-1] != s:\n words += 's'\nelse:\n words += 'es'\nprint(words)\n \n \n ", 'words = input()\nif words[-1] != s:\n words += "s"\nelse:\n words += "es"\nprint(words)\n \n \n \n', 'words = input()\nif words[-1] != "s":\n words += "s"\nelse:\n words += "es"\nprint(words)\n \n \n \n']
['Runtime Error', 'Runtime Error', 'Accepted']
['s598459942', 's976766112', 's375503948']
[8996.0, 8792.0, 9064.0]
[26.0, 21.0, 28.0]
[92, 93, 95]
p02546
u087590461
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["N= int(input())\ncount=0\nfor i in range(N):\n\tp,q=map(int,input().split(' '))\n\tif p==q:\n\t\tcount+=1\n\telse:\n\t\tcount=0\n\nif count>=3:\n\tprint('Yes')\nelse:\n \tprint('No')", '# -*- coding: utf-8 -*-\n"""Untitled3.ipynb\n\nAutomatically generated by Colaboratory.\n\nOriginal file is located at\n https://colab.research.google.com/drive/1VVfPJl7_dXodPfxyID5RNKhqW1ZRqVux\n"""\n\nN= int(input())\ncount=0\nfor i in range(N):\n p,q=map(int,input().split(\' \'))\n if count<3:\n if p==q:\n count+=1\n else:\n count=0\n else:\n pass\n\nif count>=3:\n print(\'Yes\')\nelse:\n print(\'No\')', "S= input()\nif S[-1]=='s':\n\tS+='es'\nelse:\n\tS+='s'\nprint(S)"]
['Runtime Error', 'Runtime Error', 'Accepted']
['s653089307', 's845717695', 's904687663']
[9164.0, 9104.0, 9084.0]
[25.0, 27.0, 27.0]
[162, 405, 57]
p02546
u090068671
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = input()\nif S[-1]=='s':\n print(S+'s')\nelse:\n print(S+'es')", "def resolve():\n\tS = input()\n\tif S[-1] =='s':\n\t\tprint(S+'es')\n\telse:\n\t\tprint(S+'s')\nresolve()"]
['Wrong Answer', 'Accepted']
['s135306876', 's637403593']
[9088.0, 9024.0]
[27.0, 30.0]
[63, 92]
p02546
u092061507
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['import bisect\nN, K = map(int, input().split())\n\nLR = [list(map(int, input().split())) for i in range(K)]\nS = set()\nfor i in LR:\n for j in range(i[0], i[1]+1):\n S.add(j)\nL = sorted(list(S))\n\ndp = [0 for i in range(N)]\ndp[0] = 1\nfor i in range(1, N):\n x = bisect.bisect(L, i)\n t = L[:x]\n for j in t:\n dp[i] += dp[i-j]\n dp[i] = dp[i] % 998244353\n\nprint(dp[-1] % 998244353)\n', "S = input()\n\nif S[-1] == 's':\n print(S + 'es')\nelse:\n print(S + 's')\n"]
['Runtime Error', 'Accepted']
['s696179687', 's333814525']
[9020.0, 9080.0]
[28.0, 26.0]
[399, 75]
p02546
u093838453
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n = int(input())\ncount=0\n\nfor num in range(n):\n d1,d2 = map(int,input().split())\n if d1 == d2:\n count += 1\nelse:\n if count>0:\n print("Yes")\n else:\n print("No")', 's=input()\n\nif s.endswith("s"):\n print(s+"es")\nelse:\n print(s+"s")\n']
['Runtime Error', 'Accepted']
['s344447384', 's703564861']
[9172.0, 9072.0]
[21.0, 29.0]
[192, 72]
p02546
u101850722
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\np = ""\n\nif(s.endswith("s")){\n p = s + "es"\n}else{\n p = s + "s"\n}\n\nprint(s)', 's = input()\np = ""\n\nif(s.endswith("s")):\n p = s + "es"\nelse:\n p = s + "s"\n\nprint(p)\n']
['Runtime Error', 'Accepted']
['s705893424', 's331360661']
[8864.0, 9004.0]
[27.0, 25.0]
[88, 86]
p02546
u105862524
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["word = int(input())\n\nif word[-1] == 's': \n\tprint(word + 'es')\nelse:\n\tprint(word + 's')", "word = input()\n \nif word[-1] == 's':\n\tprint(word + 'es')\nelse:print(word + 's')"]
['Runtime Error', 'Accepted']
['s849086045', 's155029037']
[9148.0, 9072.0]
[27.0, 28.0]
[86, 79]
p02546
u106311097
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["#!python3.8\n# -*- coding: utf-8 -*-\n# abc179/abc179_b\nimport sys\n\ns2nn = lambda s: [int(c) for c in s.split(' ')]\nss2nn = lambda ss: [int(s) for s in list(ss)]\nss2nnn = lambda ss: [s2nn(s) for s in list(ss)]\ni2s = lambda: sys.stdin.readline().rstrip()\ni2n = lambda: int(i2s())\ni2nn = lambda: s2nn(i2s())\nii2ss = lambda n: [i2s() for _ in range(n)]\nii2nn = lambda n: ss2nn(ii2ss(n))\nii2nnn = lambda n: ss2nnn(ii2ss(n))\n\ndef main():\n return\n\nmain()\n", "#!python3.8\n# -*- coding: utf-8 -*-\n# abc179/abc179_a\nimport sys\n\ns2nn = lambda s: [int(c) for c in s.split(' ')]\nss2nn = lambda ss: [int(s) for s in list(ss)]\nss2nnn = lambda ss: [s2nn(s) for s in list(ss)]\ni2s = lambda: sys.stdin.readline().rstrip()\ni2n = lambda: int(i2s())\ni2nn = lambda: s2nn(i2s())\nii2ss = lambda n: [i2s() for _ in range(n)]\nii2nn = lambda n: ss2nn(ii2ss(n))\nii2nnn = lambda n: ss2nnn(ii2ss(n))\n\ndef main():\n S = i2s()\n if S[-1] != 's':\n print(S + 's')\n else:\n print(S + 'es')\n return\n\nmain()\n"]
['Wrong Answer', 'Accepted']
['s552738512', 's454246346']
[9120.0, 9132.0]
[33.0, 27.0]
[450, 542]
p02546
u110207693
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["if s[-1] == 's': \n s += 'es' \nelse: \n s += 's' \nprint(s) ", "s = input() \nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's' \nprint(s)"]
['Runtime Error', 'Accepted']
['s278211830', 's270240582']
[9080.0, 9072.0]
[30.0, 26.0]
[174, 175]
p02546
u111559399
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
[" x= str(input())\na=list(x)\nl=len(a)\nif a[l-1]=='s':\n print(x+'es')\nelse:\n print(x+'s')", "x= str(input())\na=list(x)\nl=len(a)\nif a[l-1]=='s':\n print(x+'es')\nelse:\n print(x+'s')"]
['Runtime Error', 'Accepted']
['s897330088', 's950473533']
[9004.0, 8976.0]
[23.0, 30.0]
[92, 91]
p02546
u124445903
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=input()\nt=len(s)\nif s[t-1]==s:\n s=s+"es"\nelse:\n s=s+\'s\'\n ', "st=input()\nt=len(st)\nn=t-1\nif st[n]=='s':\n st=st+'es'\nelse:\n st=st+'s'\nprint(st)\n \n "]
['Wrong Answer', 'Accepted']
['s258374583', 's452246526']
[9024.0, 9036.0]
[30.0, 26.0]
[64, 92]
p02546
u128282559
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n = int(input())\na = []\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if d1 == d2:\n a.append(True)\n else:\n a.append(False)\na.append(False)\na.append(False)\nfor i in a:\n if i == True:\n if a[a.index(i)+1] and a[a.index(i)+2]:\n print("Yes")\n exit()\nprint("No")', 's =str(input())\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")']
['Runtime Error', 'Accepted']
['s193331499', 's644945074']
[9188.0, 9088.0]
[28.0, 34.0]
[321, 77]
p02546
u146803137
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\nn = int(input())\nx = [0 for i in range(n)]\ny = [0 for i in range(n)]\nans = 'No'\n\nfor i in range(n):\n x[i],y[i] = map(int,input().split())\n\nfor i in range(n-2):\n if (x[i] == y[i])and(x[i+1] == y[i+1])and(x[i+2] == y[i+2]):\n ans = 'Yes'\n\nprint(ans)", "import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\nn = int(input())\nx = [0 for i in range(n)]\ny = [0 for i in range(n)]\nans = 'No'\n\nfor i in range(n):\n x[i],y[i] = map(int,input().split())\n\nfor i in range(n-2):\n if (x[i] == x[i])and(x[i+1] == x[i+1])and(x[i+2] == x[i+2]):\n ans = 'Yes'\n\nprint(ans)", "import math\nini = lambda : int(input())\ninm = lambda : map(int,input().split())\ninl = lambda : list(map(int,input().split()))\ngcd = lambda x,y : gcd(y,x%y) if x%y else y\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0:\n cnt+=1\n temp //= i\n arr.append([i, cnt])\n if temp!=1:\n arr.append([temp, 1])\n if arr==[]:\n arr.append([n, 1])\n return arr\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i:\n divisors.append(n//i)\n divisors.sort()\n return divisors\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\nmod = 10**9 + 7\n\n#maincode-------------------------------------------------\n\ns = input()\nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's'\nprint(s)"]
['Runtime Error', 'Runtime Error', 'Accepted']
['s710156920', 's777065594', 's513701325']
[9248.0, 9244.0, 9296.0]
[24.0, 31.0, 29.0]
[2239, 2239, 2050]
p02546
u153823221
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\n\nif s[-1] = "s":\n print(s + "es")\nelse:\n print(s + "s")', 'n = int(input())\np = [list(map(int,input().split())) for i in range(n)]\n\n\na = p[0]\nb = 0\nans = 0\ntf = 1\n\nfor j in range(n):\n if sum(p[j]) // 2 *2 ==sum(p[j]):\n ans += 1\n else:\n ans = 0\n if ans ==3:\n tf = 0\n print("Yes")\n break\n \nif tf == 1:\n print("No")', 's = input()\n \nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")\n\n \n']
['Runtime Error', 'Runtime Error', 'Accepted']
['s434864040', 's532593061', 's863774928']
[9000.0, 9080.0, 9080.0]
[25.0, 25.0, 33.0]
[69, 276, 76]
p02546
u163528399
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N=int(input())\ny=0\nfor j in range(1,N):\n for k in range(1,N): \n if (N-k)%j==0:\n y=y+1\nprint(y)', 'x=input()\nif x[-1]==("s"):\n print(x+"es")\nelif x[-1]!=("s"):\n print(x+"s")']
['Runtime Error', 'Accepted']
['s264784307', 's462287311']
[9152.0, 9088.0]
[27.0, 32.0]
[115, 80]
p02546
u167542063
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=input()\nif s[-1]==s:\n\ts1= s +"es"\n \tprint(s1)\nelse:\n \ts2 = s +"s"\n \tprint(s2)', 's=input()\nif s[-1]==s:\n\ts1= s +"es"\n print(s1)\nelse:\n \ts2 = s +"s"\n print(s2)', 's3="s"\nes="es"\nS=input()\nif S[-1]=="s":\n\ts1= S + es\n\tprint(s1)\nelse:\n\ts2 = S + s3\n\tprint(s2)']
['Runtime Error', 'Runtime Error', 'Accepted']
['s391923894', 's841354424', 's579260456']
[9008.0, 8940.0, 9032.0]
[28.0, 29.0, 30.0]
[84, 82, 92]
p02546
u175590965
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\nif s[-1] == "s":\n print(s+"s")\nelse:\n print(s+"es")', 's = input()\nif s[-1] == "s":\n print(s+"es")\nelse:\n print(s+"s")']
['Wrong Answer', 'Accepted']
['s230531987', 's063870122']
[8948.0, 9008.0]
[30.0, 29.0]
[69, 69]
p02546
u181138123
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['def createPlural(s):\n if s[-1] == "s":\n return s[:-1] + "es"\n else:\n return s + "s"\n\ns = input()\ns_plural = cratePlural\nprint(s_plural)', 'def createPlural(s):\n if s[-1] == "s":\n return s + "es"\n else:\n return s + "s"\n\ns = input()\ns_plural = createPlural(s)\nprint(s_plural)']
['Runtime Error', 'Accepted']
['s529748994', 's226015735']
[9100.0, 9084.0]
[25.0, 31.0]
[155, 154]
p02546
u185405877
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n=input()\nl=len(n)\nif n[l-1]==s:\n print(n+"es")\nelse:\n print(n+"s")', 'n=input()\nl=len(n)\nif n[l-1]=="s":\n print(n+"es")\nelse:\n print(n+"s")']
['Runtime Error', 'Accepted']
['s308092352', 's657090324']
[9088.0, 9112.0]
[26.0, 30.0]
[69, 71]
p02546
u221272125
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\na = 's'\nif s[-1] == 's':\n a = 'es'\ns.append(a)", "s = input()\na = 's'\nif s[-1] == 's':\n a = 'es'\ns = s + a\nprint(s)"]
['Runtime Error', 'Accepted']
['s051227810', 's290070017']
[9040.0, 9080.0]
[29.0, 34.0]
[61, 68]
p02546
u224392054
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['import math\n\nfrom fractions import Fraction as frac\n\nMOD = 1e9 + 7\n\ndef gcd(a, b):\n\n if b == 0:\n\n return a\n\n return gcd(b, a % b)\n\ndef lcm(a, b):\n\n return a * b // gcd(a, b)\n\ndef solve(case_no):\n\n s = str(input())\n\n if s[len(s) - 1] == \'s\':\n\n \tprint(s + "es") else:\n\n \tprint(s + \'s\')\n\nt = 1\n\n# t = int(input())\n\nfor i in range(1, t + 1):\n\n solve(i)', 'import math\n\nfrom fractions import Fraction as frac\n\nMOD = 1e9 + 7\n\ndef gcd(a, b):\n\n if b == 0:\n\n return a\n\n return gcd(b, a % b)\n\ndef lcm(a, b):\n\n return a * b // gcd(a, b)\n\ndef solve(case_no):\n\n s = str(input())\n\n if s[len(s) - 1] == \'s\':\n\n \tprint(s + "es")\n else:\n\n \tprint(s + \'s\')\n\nt = 1\n\n# t = int(input())\n\nfor i in range(1, t + 1):\n\n solve(i)']
['Runtime Error', 'Accepted']
['s107111510', 's916714167']
[9032.0, 10392.0]
[25.0, 39.0]
[382, 383]
p02546
u224989615
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count > 2:\n break\n elif d1 == d2:\n count += 1\n else:\n count == 0\nif count > 2:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count == 3:\n break\n elif d1 == d2:\n count += 1\n else:\n count == 0\nif count == 3:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\ncount = 0\nfor i in range(n):\n d1, d2 = map(int, input().split())\n if count > 2:\n break\n else:\n if d1 == d2:\n count += 1\n else:\n count = 0\nif count > 2:\n print("Yes")\nelse:\n print("No")', 's = input()\nif s[-1] == "s":\n print(s+"es")\nelse:\n print(s+"s")']
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
['s086544729', 's813446537', 's912385241', 's041566138']
[9168.0, 9080.0, 9156.0, 9024.0]
[24.0, 25.0, 29.0, 28.0]
[212, 214, 225, 65]
p02546
u244466744
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\n\nif s[-1] != "s":\n s.append("s")\n \nelse:\n s.append("es")\n \nprint(s)', 's = input()\n\nif s[-1] != "s":\n s = s + "s"\n \nelse:\n s = s + "es"\n \nprint(s)\n']
['Runtime Error', 'Accepted']
['s671205826', 's958168853']
[9088.0, 9088.0]
[25.0, 29.0]
[83, 80]
p02546
u253220242
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["word = input()\nif word[-1] == 's':\n return ''.join(word, 'es')\nelse:\n return ''.join(word, 's')", "word = input()\nif word[-1] == 's':\n print(word+'es')\nelse:\n print(word+'s')"]
['Runtime Error', 'Accepted']
['s178857821', 's636057908']
[8984.0, 8988.0]
[32.0, 30.0]
[97, 77]
p02546
u255438107
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["n = input()\n\nif n[len(n - 1)] == 's':\n print(n + 'es')\nelse:\n print(n + 's')", "n = input()\n\nif n[len(n) - 1] == 's':\n print(n + 'es')\nelse:\n print(n + 's')"]
['Runtime Error', 'Accepted']
['s785539412', 's735815019']
[9012.0, 9096.0]
[26.0, 26.0]
[82, 82]
p02546
u263173473
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n=int(input())\ncounter=0\nfor i in range(1,n+1):\n for j in range(1,n+1):\n for k in range(n-i*k,n+1):\n if((i*j+k)==n):\n counter=counter+1\nprint(counter)', "str1=input()\nif(str1[len(str1)-1]=='s'):\n print(str1+'es')\nelse:\n print(str1+'s')"]
['Runtime Error', 'Accepted']
['s440422062', 's628855648']
[9168.0, 9028.0]
[26.0, 27.0]
[186, 87]
p02546
u267549094
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=input()\nprint(s)\nif s[-1]==\'s\':\n print(s+"es")\nprint(s+"s")\n', "s=input()\nif s[-1]=='s':\n \ts+='es'\n \treturn s\ns+='s'\nreturn s\n", "s=input()\nif s[-1]=='s':\n s+='es'\n return s\ns+='s'\nreturn s", 's=str(input())\nif(s[-1]=="s"):\n \tprint(s+"es")\nelse:\n\tprint(s+"s")']
['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted']
['s589199499', 's627716770', 's934097827', 's416512307']
[9020.0, 9008.0, 9068.0, 9096.0]
[29.0, 24.0, 25.0, 31.0]
[63, 64, 61, 67]
p02546
u267933821
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S=input()\ns=len(S)\nif S[s] == "s":\n print(S+"es")\nelse:\n print(S+"s")\n ', 'S=input()\ns=len(S)\nif S[s-1] == "s":\n print(S+"es")\nelse:\n print(S+"s")']
['Runtime Error', 'Accepted']
['s538877372', 's005251006']
[9020.0, 9100.0]
[25.0, 29.0]
[76, 73]
p02546
u271123940
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nfor i in s:\n if s[-1] == 's':\n s.join('es')\n else:\n s.join('s')\nprint(s)", 's = input()\nl = []\nfor i in s:\n l.append(i)\nif l[-1] == \'s\':\n l.append(\'es\')\n print("".join(j for j in l))\nelse:\n l.append(\'s\')\n print("".join(j for j in l))']
['Wrong Answer', 'Accepted']
['s869577898', 's839344134']
[9020.0, 9132.0]
[28.0, 34.0]
[92, 170]
p02546
u271153916
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(sa + "s")', 's = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")']
['Runtime Error', 'Accepted']
['s484012292', 's420678745']
[9084.0, 9088.0]
[32.0, 31.0]
[74, 73]
p02546
u271853076
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nif s.endwith('s'):\n\tprint(s + 'es')\nelse:\n\tprint(s + 's')", "s = input()\nif s.endswith('s'):\n print(s + 'es')\nelse:\n print(s + 's')"]
['Runtime Error', 'Accepted']
['s532656705', 's046112013']
[9024.0, 9084.0]
[29.0, 32.0]
[69, 72]
p02546
u274755552
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S = input()\nif S[-1] = "s"\n\tprint( S + "es" )\nelse print( S + "s" )\n', 'S = input()\nif S[-1] == "s":\n\tprint( S + "es" )\nelse print( S + "s" )', 'S = input()\nif S[-1] == "s":\n\tprint( S, "es" )\nelse print( S, "s" )', "S = input()\nif re.findall('[a-z]+$', S) = 's'\n\tprint( S + 'es')\n\telse print( S + 's')", 'S = input()\n\tif S[-1] = "s"\n\t\tprint( S + "es" )\n\t\telse print( S + "s" )', 'S = input()\nif S[-1] = "s"\nprint( S + "es" )\nelse print( S + "s" )', 'S = input()\nif S[-1] = "s"\n\tprint( S, "es" )\nelse print( S, "s" )', 'S = input()\nif S[-1] = "s"\n\tprint( S + "es" )\n\telse print( S + "s" )', 'S = input()\nif S[-1] == "s":\n print( S + "es" )\nelse: \n print( S + "s" )']
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
['s053952474', 's100547614', 's332340989', 's398397362', 's544135726', 's567933669', 's606521010', 's669656623', 's075810422']
[9000.0, 9020.0, 8948.0, 9004.0, 9004.0, 8996.0, 9000.0, 9000.0, 9056.0]
[23.0, 27.0, 29.0, 27.0, 24.0, 24.0, 23.0, 27.0, 27.0]
[68, 69, 67, 85, 71, 66, 65, 68, 74]
p02546
u286422818
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['#!/usr/local/bin/python3\n\nN, X, M = map(int, input().split())\n\ndef f(x, m):\n return x**2 % m\n\ncheck = [False for _ in range(M)]\nd = [X]\nmax_x = 0\nfor _ in range(1, N+1):\n X = f(X, M)\n if check[X]:\n break\n else:\n check[X] = True\n d.append(X)\n\nidx = d.index(X)\nans = sum(d[:idx])\nN -= idx\nd = d[idx:]\n\nsumd = sum(d)\nans += N//len(d) * sumd\n\nans += sum(d[:N%len(d)])\n\nprint(ans)\n', "S = input()\nif S[-1] == 's':\n print(S+'es')\nelse:\n print(S+'s')"]
['Runtime Error', 'Accepted']
['s920420565', 's981555775']
[9208.0, 9084.0]
[24.0, 28.0]
[405, 69]
p02546
u308914480
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=input()\nif s[-1]=s:\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\n print(s1)\n ', 's=input()\nif s[-1]=s:\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\nprint(s1)', 's=input()\nif s[-1]="s":\n print(s[-1].replace("s","es"))\nelse:\n s1=s+"s"\nprint(s1)', 's=input()\nif(s[-1:]==\'s\'):\n s1=s+"es"\n print(s1)\nelse:\n s2=s+"s"\n print(s2)']
['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted']
['s023773188', 's172289695', 's405837618', 's487202471']
[9000.0, 9012.0, 9024.0, 9088.0]
[25.0, 27.0, 21.0, 26.0]
[86, 81, 83, 79]
p02546
u309120194
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = input()\n\na = S[:-1]\nb = S[-1]\nif b == 's': print(a + 'es')\nelse: print(a + 's')", "S = input()\n \nif S[-1] == 's': S += 'es'\nelse: S += 's'\nprint(S)"]
['Wrong Answer', 'Accepted']
['s799288703', 's658208987']
[9088.0, 8984.0]
[28.0, 26.0]
[83, 64]
p02546
u318533762
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s = input("Enter Input:")\n\nif s[len(s) - 1] != "s":\n s += "s"\n\nelif s[len(s) - 1] == "s":\n s += "es"\n\nprint(s)\n ', 's = input()\n\nif s[len(s) - 1] != "s":\n s += "s"\n\nelif s[len(s) - 1] == "s":\n s += "es"\n\nprint(s)\n ']
['Wrong Answer', 'Accepted']
['s944161654', 's092294715']
[9024.0, 9024.0]
[25.0, 27.0]
[122, 108]
p02546
u326408598
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S = input()\nif S[-1] == "s":\n print(S + "es")\n else:\n print(S + "s")', 's = input()\nif s[-1] != "s":\n print(s+\'s\')\nelif s[-1] == \'s\'\n print(s[:-1]+\'es\')', 'S = input()\nif S[-1] == "s":\n\tprint(S + "es")\nelse:\n \tprint(S + "s")']
['Runtime Error', 'Runtime Error', 'Accepted']
['s047798225', 's564803025', 's445960787']
[9008.0, 8952.0, 9080.0]
[24.0, 23.0, 29.0]
[73, 82, 69]
p02546
u345132740
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S=input()\nif (S[-1:]==s):\n print(S+"es")\nelse:\n print(S+"s")', 'S=input()\nif (S[-1:]=="s"):\n print(S+"es")\nelse:\n print(S+"s")']
['Runtime Error', 'Accepted']
['s762903259', 's835055129']
[8960.0, 9028.0]
[26.0, 27.0]
[62, 64]
p02546
u347502437
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['def main():\n N, X, M = map(int, input().split())\n NN = N\n li = []\n while X not in li and N != 0:\n li = li + [X]\n X = X ** 2 % M\n N -= 1\n \n if N == 0:\n print(sum(x for x in li))\n\n elif N != 0 and X in li:\n l = len(li)\n s = li.index(X)\n T = l - s\n q = (NN - s) // T\n r = (NN - s) % T\n print(sum(li[i] for i in range(s)) + sum(li[i] for i in range(s, len(li))) * q + sum(li[i] for i in range(s, s + r)))\n\n\nmain()', "S = input()\nl = len(S)\nif S[l-1] != 's':\n print(S + 's')\nelse:\n print(S + 'es')"]
['Runtime Error', 'Accepted']
['s802543888', 's573530042']
[9220.0, 9092.0]
[31.0, 25.0]
[500, 85]
p02546
u365416597
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\n\nif s[len(s)] == 's':\n print(s+'es')\nelse:\n print(s+'s') ", "s = input()\n\nif s[len(s)-1] == 's':\n print(s+'es')\nelse:\n print(s+'s') "]
['Runtime Error', 'Accepted']
['s553735161', 's190229851']
[9092.0, 9064.0]
[25.0, 30.0]
[76, 78]
p02546
u369133448
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['import collections\nn,x,m=map(int,input().split())\nif n==1 or x==0:\n print(x)\n exit()\nstart,end,loopcnt=0,0,0\na={x:0}\nwk=x\nfor i in range(1,m):\n wk=(wk*wk)%m\n if not wk in a:\n a[wk]=i\n else:\n start=a[wk]\n end=i\n break\na=sorted(a.items(),key=lambda x:x[1])\nkoteiindex=min(n,start)\nkoteiwa=0\nfor i in range(koteiindex):\n koteiwa+=a[i][0]\nloopcnt=(n-koteiindex)//(end-start)\nloopindex=start-1+(n-koteiindex)%(end-start)\nloopwa=0\namariwa=0\nfor i in range(start,end):\n if i<=loopindex:\n amariwa+=a[i][0]\n loopwa+=a[i][0]\nans=koteiwa+loopwa*loopcnt+amariwa\nprint(ans)\n', 's=input()\nif s[len(s)-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']
['Runtime Error', 'Accepted']
['s500583536', 's891654995']
[9396.0, 9032.0]
[25.0, 26.0]
[584, 67]
p02546
u371056862
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nif s[-1] == 's':\n s.append('es')\nelse:\n s.append('s')\nprint(s)", "s = input()\nif s[-1] == 's':\n s += 'es'\nelse:\n s += 's'\nprint(s)"]
['Runtime Error', 'Accepted']
['s919076628', 's223845585']
[9012.0, 9072.0]
[28.0, 32.0]
[76, 70]
p02546
u383805907
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = input()\nif S[-1] = 's':\n return S + 'es'\nelse:\n return S + 's'\n", "def solution():\n S = input()\n if S[-1] == 's':\n return S + 'es'\n else:\n return S + 's'\n\nprint (solution())"]
['Runtime Error', 'Accepted']
['s991257704', 's136833318']
[9000.0, 9080.0]
[26.0, 32.0]
[69, 115]
p02546
u384708632
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n = int(input())\ncount = 0\nfor i in range(n):\n if i == 0:\n count = 0\n else:\n if n % i == 0:\n count += (n//i) -1\n else:\n count += (n//i)\nprint(count)', 'n = int(input())\nd = [list(map(int, input().split())) for i in range(n)]\ncount = 0\njail = False\nfor i in range(n):\n if d[i][0] == d[i][1]:\n count += 1\n if count == 3:\n jail = True\n break \n else: count = 0\nif jail == True:\n print("Yes")\nelse : print("No")\n', 's = input()\nif s[-1:] == "s":\n print(s + "es")\nelse :\n print(s + "s")\n']
['Runtime Error', 'Runtime Error', 'Accepted']
['s069454513', 's469726919', 's436564176']
[9160.0, 9180.0, 9020.0]
[25.0, 30.0, 31.0]
[197, 307, 76]
p02546
u390493770
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['\n#include <string>\n\nusing namespace std;\n\nint main()\n{\n string s;\n cin >> s;\n if (s[s.size() - 1] == \'s\') {\n cout << s << "es";\n }\n else {\n cout << s << "s";\n }\n return 0;\n}\n', "s = input()\nprint(s+'es') if s.endswith('s') else print(s+'s')\n"]
['Runtime Error', 'Accepted']
['s662094881', 's478221933']
[8936.0, 8964.0]
[26.0, 30.0]
[228, 63]
p02546
u401481862
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n, x, m = map(int, input().split())\na = x\ns = 0\nh = []\nh.append(a)\ni = 0\nfl = 0\nwhile i < n:\n s += a\n a = (a*a) % m\n if a == 0:\n break\n i += 1\n if fl == 0 and a in h:\n fl = 1\n po = h.index(a)\n ss = 0\n for j in range(po):\n ss += h[j]\n s2 = s - ss\n f = (n - po) // (i - po)\n s2 *= f\n s = s2 + ss\n i2 = i - po\n i2 *= f\n i = i2 + po\n else:\n h.append(a)\nprint(s)', "S = input()\nif S[-1] == 's':\n a = S+'es'\nelse:\n a = S+'s'\nprint(a)\n"]
['Runtime Error', 'Accepted']
['s731246078', 's875986495']
[9200.0, 9080.0]
[30.0, 32.0]
[447, 73]
p02546
u402228762
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['a = int(input())\ncount = 0\nfor i in range(a):\n a,b = map(int,input().split())\n \n if (a==b):\n count += 1\n break\n else : \n count = 0\n\nif (count >= 3):\n \n print("Yes")\nelse :\n print("No")\n', 'a = input()\n\nif (a[-1] != "s"):\n a += "s"\n\nelse :\n a += "es"\n\nprint(a)']
['Runtime Error', 'Accepted']
['s806020433', 's710530821']
[9164.0, 9080.0]
[24.0, 29.0]
[231, 76]
p02546
u409609062
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["if __name__ == '__main__':\n try:\n singular = str(input())\n singular.lower()\n if singular[len(singular)-1] != 's':\n singular += 's'\n print(s)\n else:\n singular += 'es'\n print(s)\n except Exception:\n pass", "if __name__ == '__main__':\n try:\n s = str(input())\n s.lower()\n if s[len(s)-1] != 's':\n s += 's'\n print(s)\n else:\n s += 'es'\n print(s)\n except Exception:\n pass"]
['Wrong Answer', 'Accepted']
['s080839515', 's223994002']
[9036.0, 8960.0]
[28.0, 26.0]
[285, 243]
p02546
u414050834
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s=str(input())\nt=len(s)\nif s[t]=='s':\n print(s+'es')\nelse:\n print(s+'s')", "s=str(input())\nt=len(s)\nif s[t-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')\n"]
['Runtime Error', 'Accepted']
['s026977698', 's163791374']
[9116.0, 9084.0]
[25.0, 31.0]
[74, 77]
p02546
u438070303
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['singular = input()\nif singular[-1] == "s":\n print(singular + "es)\nelse:\n print(singular + "s")', ' singular = input()\n if singular[-1] == "s":\n print(singular + "es")\n else:\n print(singular + "s")', 'singular = input()\nif singular[-1] == "s":\n print(singular + "es")\nelse:\n print(singular + "s")']
['Runtime Error', 'Runtime Error', 'Accepted']
['s687987708', 's888941598', 's168329654']
[9004.0, 9000.0, 8948.0]
[28.0, 27.0, 29.0]
[100, 121, 101]
p02546
u441320782
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['from itertools import product\nN=int(input())\ncount=0\nlis=[i for i in range(1,N+1)]\nx=list(itertools.product(lis,repeat=3))\nfor i in x:\n if y[0]*y[1]+y[2]==N:\n count+=1\n\nprint(count)', 'n=input()\nif n[-1]=="s":\n print(n+"es")\nelse:\n print(n+"s")\n']
['Runtime Error', 'Accepted']
['s818818939', 's629528275']
[9128.0, 8972.0]
[25.0, 28.0]
[185, 62]
p02546
u442636632
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N = int(input())\nA = 1\nB = 1\nC = 1\nanswer = 0\nwhile C < N:\n B = 1\n while B < N:\n A = 1\n while A < N:\n if (A * B) + C == N:\n answer += 1\n\n A += 1\n\n B += 1\n\n C += 1\n\nprint(answer)\n', "S = input()\nif S[len(S)-1] == 's':\n answer = S + 'es'\nelse:\n answer = S + 's'\nprint(answer)\n"]
['Runtime Error', 'Accepted']
['s070869098', 's733623091']
[9156.0, 9080.0]
[29.0, 27.0]
[245, 98]
p02546
u447837274
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['chr = input("")\nnum = len(s)\n\nif chr[num-1] == "s":\n print(chr + "es")\nelse:\n print(chr + "s")\n \n ', 'chr = input("")\nnum = len(chr)\n\nif chr[num-1] == "s":\n print(chr + "es")\nelse:\n print(chr + "s")']
['Runtime Error', 'Accepted']
['s957524363', 's468680454']
[9012.0, 9024.0]
[29.0, 30.0]
[102, 98]
p02546
u453529685
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N = int(input())\ncount = 0\nfor C in range(1,N):\n for A in range(1,N-C+1):\n B = (N-C)/A\n if B.is_integer():\n count += 1\nprint(count)', "s = input()\nif s[-1] == 's':\n print(s + 'es')\nelse:\n print(s + 's')"]
['Runtime Error', 'Accepted']
['s874942064', 's990908382']
[9172.0, 9020.0]
[22.0, 30.0]
[143, 69]
p02546
u454472984
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n=int(input())\nflag=0\nans=0\n\nfor i in range(n):\n d1,d2=map(int,input().split())\n if d1==d2:\n flag+=1\n if flag==3:\n ans=1\n else:\n flag=0\nif ans!=1:\n print("No")\nelse:\n print("Yes")\n ', 's=input()\nif s[len(s)-1]=="s":\n print(s+"es")\nelse:\n print(s+"s")']
['Runtime Error', 'Accepted']
['s630639305', 's152484662']
[9172.0, 9120.0]
[30.0, 30.0]
[231, 71]
p02546
u463945054
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N = int(input())\n\nk=0\n\nfor s in range(1,N):\n k = (N-1) // s\n t += k \n \nprint (t)', 'N = int(input())\n\ncount = 0\n\nfor i in range(N):\n k, t = map(int, input().split())\n if count == 3:\n print ( "yes" )\n \n break\n \n if not k == t:\n count *= 0\n if k == t:\n count += 1 \nif not count == 3:\n print ("no")\n\n', 'S = str(input())\n\nif S[-1] == "s" :\n\n print( S + "es" )\n\nelse:\n\n print( S + "s" )\n']
['Runtime Error', 'Runtime Error', 'Accepted']
['s269786459', 's998297782', 's915210401']
[9144.0, 9112.0, 9024.0]
[30.0, 24.0, 29.0]
[83, 264, 82]
p02546
u466916194
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['st = input()\nif st[-1]=="s":\n st.append("es")\nelse:\n st.append("s")', 'st = input()\nif st[-1]=="s":\n name = st+"es"\nelse:\n name = st+"s"\nprint(name)']
['Runtime Error', 'Accepted']
['s805809178', 's613804356']
[9072.0, 9028.0]
[23.0, 23.0]
[69, 79]
p02546
u470481460
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=sys.stdin\nif s[len(s)-1] =="s":\n\tprint(s + "es")\nelse:\n\tprint(s + "s")', 's=input()\nif s[len(s)-1] =="s":\n\tprint(s + "es")\nelse:\n\tprint(s + "s")']
['Runtime Error', 'Accepted']
['s471007639', 's024969767']
[9088.0, 8880.0]
[23.0, 28.0]
[72, 70]
p02546
u511975155
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n,x,m = map(int,input().split())\ndef jouken(a,waru):\n return a**2%waru\nni = 0\nnum =0\nfor i in range(n-1):\n ni = x\n if i ==0:\n num+=x\n x = jouken(ni,m)\n num+=x\nprint(num)\n', "sentence = input()\nif sentence[-1] == 's':\n print(sentence+'es')\nelse:\n print(sentence+'s')"]
['Runtime Error', 'Accepted']
['s242175771', 's193757082']
[9032.0, 9052.0]
[23.0, 30.0]
[192, 93]
p02546
u523885719
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["import sys\ninput = sys.stdin.readline\nS = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')", "import sys\ninput = sys.stdin.readline\nS = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')", "S = input()\nif S[-1:] == 's':\n print(S+'es')\nelse:\n print(S+'s')"]
['Wrong Answer', 'Wrong Answer', 'Accepted']
['s664913094', 's977718542', 's833643813']
[8824.0, 9008.0, 8992.0]
[27.0, 31.0, 28.0]
[108, 108, 70]
p02546
u536235324
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['# -*- coding: utf-8 -*-\n"""\nCreated on Sat Sep 19 13:14:17 2020\n\n@author: Admin\n"""\n\n\nn,x,m=input().split()\nm=int(m)\na=[int(x)]\nfor i in range(1,int(n)):\n zp=a[i-1]\n z=zp**2\n a.append(z%m)\n \nprint(sum(a))', '# -*- coding: utf-8 -*-\n"""\nCreated on Sat Sep 19 13:03:22 2020\n\n@author: Admin\n"""\n\na=input()\nif a[-1]==\'s\':\n print(a+\'es\')\nelse:\n print(a+\'s\')']
['Runtime Error', 'Accepted']
['s578701638', 's462825611']
[9048.0, 9088.0]
[28.0, 30.0]
[216, 150]
p02546
u546853743
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s=list(input())\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')", "s=input()\nif s[-1]=='s':\n print(s,'es',sep='')\nelse:\n print(s,'s',sep='')"]
['Runtime Error', 'Accepted']
['s177076519', 's522830081']
[9084.0, 9028.0]
[24.0, 33.0]
[71, 79]
p02546
u548272916
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["string = input()\n\nif string[-1] != 's':\n new_string = string[0:-1] + 's'\nif string[-1] = 's':\n new_string = string[0:-1] +'es'\n \nprint(new_string)", "string = input()\n \nif string[-1] != 's':\n new_string = string[0:] + 's'\nif string[-1] == 's':\n new_string = string[0:] +'es'\n \nprint(new_string)"]
['Runtime Error', 'Accepted']
['s117033063', 's844445613']
[9016.0, 9008.0]
[31.0, 24.0]
[148, 146]
p02546
u564147564
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S = str(input())\n\nif S.endswith(\'s\'):\n S += "es"\nelse:\n S += "s"', 'S = str(input())\n\nif S.endswith(\'s\'):\n S += "es"\nelse:\n S += "s"\nprint(S)']
['Wrong Answer', 'Accepted']
['s764190367', 's989552605']
[9076.0, 9084.0]
[33.0, 29.0]
[66, 75]
p02546
u570991163
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['n=int(input())\nc,f=0,0\nwhile(n>0):\n a,b=map(int,input().split())\n if(a==b):\n c+=1\n else:\n c=0\n if(c>=3):\n f=1\n break\n n-=1\nif(f==1 or c>=3):\n print("Yes")\nelse:\n print("No")', "s=input()\nif(s[-1]=='s'):\n s+='es'\nelse:\n s+='s'\nprint(s)"]
['Runtime Error', 'Accepted']
['s888893519', 's128957642']
[9132.0, 8944.0]
[22.0, 28.0]
[192, 59]
p02546
u574888872
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['from unittest import TestCase, main\nfrom A import func\n\nclass test(TestCase):\n def test_with_valid_params(self):\n test_patterns = [\n ("apple","apples"),\n ("bus","buses"),\n ("box","boxs")\n ]\n\n for S,result in test_patterns:\n with self.subTest(S=S):\n self.assertEqual(func(S),result)\n\nif __name__ == "__main__":\n main()', 'def func(S):\n if S[-1] == "s":\n return S+"es"\n else:\n return S+"s"\n\n\nif __name__ == "__main__":\n S = input()\n print(func(S))']
['Runtime Error', 'Accepted']
['s783184437', 's598916195']
[16208.0, 9036.0]
[69.0, 29.0]
[355, 138]
p02546
u582686131
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["st = input()\n\nif st[-1] == 's':\n return st + 'es'\nelse:\n return st + 's'", "st = input()\n \nif st[-1] == 's':\n print(st + 'es')\nelse:\n print(st + 's')"]
['Runtime Error', 'Accepted']
['s344059027', 's746671413']
[8980.0, 9056.0]
[27.0, 29.0]
[74, 79]
p02546
u584153341
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['import math\n\nN = int(input())\n\nif N == 2:\n cnt = 1\nelif N == 3:\n cnt = 3\nelif N > 3:\n cnt = 3\n for i in range(1,N-1):\n A = N-i\n rA = math.sqrt(A)\n intA = math.floor(rA)\n if rA == intA:\n cnt -= 1\n if intA == 1:\n cnt += 1\n else:\n for j in range(1,intA+1):\n if A%j == 0:\n cnt += 2\n\nprint(cnt)', 'import math\n\nN = int(input())\n\nif N == 2:\n cnt = 1\nelif N == 3:\n cnt = 3\n \nelif N > 3:\n for i in range(1,N-1):\n A = N-i\n rA = math.sqrt(A)\n intA = math.floor(rA)\n if rA == intA:\n cnt -= 1\n if intA == 1:\n cnt += 1\n else:\n for j in range(1,intA+1):\n if A%j == 0:\n cnt += 2\n\nprint(cnt)', "S = input()\nl = len(S)\nif S[l-1]=='s':\n S = S + 'es'\nelse:\n S = S + 's'\nprint(S)"]
['Runtime Error', 'Runtime Error', 'Accepted']
['s912792989', 's971946817', 's383532273']
[9204.0, 9036.0, 9036.0]
[28.0, 30.0, 28.0]
[410, 403, 86]
p02546
u596847957
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N=int(input()) \nXY=[map(int, input().split()) for _ in range(N)]\nX,Y=[list(i) for i in zip(*XY)]\nans="No"\n\nfor j in range(0,N-2):\n if X[j]==Y[j] and X[j+1]==Y[j+1] and X[j+2]==Y[j+2]:\n ans="Yes"\n break\n\nprint(ans)', 'S=input()\ns="s"\nes="es"\n\nif S[len(S)-1]==s:\n S=S+es\nelse:\n S=S+s\n\nprint(S)']
['Runtime Error', 'Accepted']
['s595629258', 's173894624']
[9196.0, 9020.0]
[24.0, 27.0]
[238, 80]
p02546
u620243078
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = int(input())\nif s[-1] != 's':\n s += 's'\nelse:\n s += 'es'\nprint(s)", "s = input()\n\nif s[-1] != 's':\n\n s += 's'\n\nelse:\n\n s += 'es'\n\nprint(s)\n\n"]
['Runtime Error', 'Accepted']
['s838981182', 's195076850']
[9140.0, 9008.0]
[23.0, 31.0]
[71, 73]
p02546
u624812250
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['if S[-1] == "s":\n print(S + "es")\nelse:\n print(S + "s")', 'if S[-1] == s:\n print(S + "es")\nelse:\n print(S + "s")\n ', 'S = input()\nif S[-1] == "s":\n print(S + "es")\nelse:\n print(S + "s")']
['Runtime Error', 'Runtime Error', 'Accepted']
['s125860664', 's950178252', 's047696079']
[9048.0, 8900.0, 8944.0]
[28.0, 25.0, 31.0]
[57, 58, 69]
p02546
u627600101
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['\ndef segfunc(x, y):\n return min(x, y)\n#################\n \n#####ide_ele#####\nide_ele = 10**9\n#################\n \nclass SegTree:\n \n def __init__(self, init_val, segfunc, ide_ele):\n \n n = len(init_val)\n self.segfunc = segfunc\n self.ide_ele = ide_ele\n self.num = 1 << (n - 1).bit_length()\n self.tree = [ide_ele] * 2 * self.num\n \n for i in range(n):\n self.tree[self.num + i] = init_val[i]\n \n for i in range(self.num - 1, 0, -1):\n self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])\n \n def update(self, k, x):\n \n k += self.num\n self.tree[k] = x\n while k > 1:\n self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])\n k >>= 1\n \n def query(self, l, r):\n \n res = self.ide_ele\n \n l += self.num\n r += self.num\n while l < r:\n if l & 1:\n res = self.segfunc(res, self.tree[l])\n l += 1\n if r & 1:\n res = self.segfunc(res, self.tree[r - 1])\n l >>= 1\n r >>= 1\n return res\n\n\nN, Q = map(int, input().split())\n\n\n\nans = (N-2)**2\nyoko = [N-2 for _ in range(N-2)]\ntate = [N-2 for _ in range(N-2)] \nyoko = SegTree(yoko, segfunc, ide_ele)\ntate = SegTree(tate, segfunc, ide_ele)\nminy = N-2\nminx = N-2\nfor k in range(Q):\n\tn, x = map(int, input().split())\n\tif n == 1:\n\t\ty = x -2\n\t\tif y < miny:\n\t\t\tans -= minx\n\t\t\tminy = y\n\t\t\tyoko.update(min(minx, N-3), miny)\n\t\telse:\n\t\t\tans -= tate.query(y, N-1)\n\telse:\n\t\tx = x - 2\n\t\tif x < minx:\n\t\t\tans -= miny\n\t\t\tminx = x\n\t\t\ttate.update(min(miny, N-3), minx)\n\t\telse:\n\t\t\tans -= yoko.query(x, N-1)\nprint(ans)\n', "#from collections import deque\n#from heapq import heapify, heappop, heappush\n#from bisect import insort\n#from math import gcd\n#mod = 10**9 + 7\n#N = int(input())\n#N, K = map(int, input().split())\n#A = list(map(int, input().split()))\n\n#for k in range(N):\n\n#print(ans)\n#print('Yes')\n#print('No')\nS = input()\nif S[-1] != 's':\n\tprint(S + 's')\nelse:\n\tprint(S+'es')\n"]
['Runtime Error', 'Accepted']
['s015624524', 's323799913']
[9288.0, 8956.0]
[26.0, 25.0]
[2432, 379]
p02546
u629350026
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=str(input())\ns=list(s)\nif s[len(s)-1]=="s":\n print("".join(s)+"es")\nelse:\n print("".join()+"s")', 's=str(input())\ns=list(s)\nif s[len(s)-1]=="s":\n print("".join(s)+"es")\nelse:\n print("".join(s)+"s")']
['Runtime Error', 'Accepted']
['s346773925', 's430459996']
[9044.0, 9008.0]
[27.0, 27.0]
[99, 100]
p02546
u629355744
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["s = input()\nif s[-1]=='s':\n print(s+'es')\n else:\n print(s+'s')", "s = input()\nif s[-1]=='s':\n print(s+'es')\nelse:\n print(s+'s')"]
['Runtime Error', 'Accepted']
['s428129423', 's472659812']
[8944.0, 9096.0]
[27.0, 30.0]
[67, 67]
p02546
u635759013
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S = input()\nif S[-1:] = s:\n print(S+"es")\nelse:print(S+"s")', 'N = int(input())\nnums =[]\ncount = 0\nswitch = False\nfor i in range(N):\n nums.append([int(x) for x in input().split()])\n\nfor j in nums:\n if j[0] == j[1]:\n count += 1\n elif j[0] != j[1]:\n count = 0\n if count == 3:\n switch = True\nif switch == True:\n print("Yes")\nelif switch == False:\n print("No")\n', 'S = input()\nif S[-1:] == "s":\n print(S+"es")\nelse:print(S+"s")']
['Runtime Error', 'Runtime Error', 'Accepted']
['s666806644', 's996429501', 's835261327']
[9000.0, 9204.0, 9080.0]
[30.0, 26.0, 32.0]
[60, 333, 63]
p02546
u650932312
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = input()\nif S[-1] == 's':\n ans += 'es'\nelse:\n ans += 's'\nprint(ans)", "S = input()\nif S[-1] == 's':\n ans = S+'es'\nelse:\n ans = S+'s'\nprint(ans)"]
['Runtime Error', 'Accepted']
['s995569972', 's498401779']
[8956.0, 9016.0]
[27.0, 30.0]
[72, 78]
p02546
u654571388
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['val = input()\nvalf=val[-1]\nif(valf==s):\n print(val+"es")\nelse\n print(val+"s")', 'val = input()\nvalf=val[-1]\nif(valf=="s"):\n print(val+"es")\nelse:\n print(val+"s")']
['Runtime Error', 'Accepted']
['s650432712', 's136527973']
[8952.0, 8972.0]
[30.0, 28.0]
[83, 86]
p02546
u686817216
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['s=input()\ns_list=list(s)\n\nx=len(s_list)\n\na_list=reversed(s_list)\nif a_list[0]=="s":\n s_list[x]="e"\n s_list[x+1]="s"\nelse:\n s_list[x+1]="s"\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list[x-1]="e"\n s_list[x]="s"\nelse:\n s_list.append("s")\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list.append("es")\nelse:\n s_list.append("s")\n\nprint(s_list)', 's=input()\ns_list=list(s)\n \nx=len(s_list)\n\nif s_list[x-1]=="s":\n s_list.append("es")\nelse:\n s_list.append("s")\n\nprint("".join(s_list))']
['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted']
['s252416134', 's633020894', 's950944697', 's344723300']
[9104.0, 9032.0, 9092.0, 9088.0]
[27.0, 29.0, 31.0, 29.0]
[156, 138, 126, 135]
p02546
u689723321
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['S=input()\nl=len(S)\ns=list(S)\nif s[l]=="s":\n print(S+"es")\nelse:\n print(S+"s")', 'S=input()\nl=len(S)\ns=list(S)\nif s[l-1]=="s":\n print(S+"es")\nelse:\n print(S+"s")\n']
['Runtime Error', 'Accepted']
['s162093523', 's888210804']
[8992.0, 9008.0]
[26.0, 24.0]
[79, 82]
p02546
u694536861
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N = int(input())\ncount = 0\n\nfor a in range(1, N):\n tmp = (N-1) // a\n if a <= (N) // 2:\n count += tmp\n else:\n count += 1 \n\nprint(count)', "S = input()\n\nif S[-1] == 's':\n print(S + 'es')\nelse:\n print(S + 's')"]
['Runtime Error', 'Accepted']
['s679429607', 's529440703']
[9164.0, 9024.0]
[22.0, 26.0]
[152, 70]
p02546
u696886537
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["f=open('in','r')\ninput=lambda:f.readline().strip()\n\ns=input()\nif s[-1]!='s':print(s+'s')\nelse:print(s+'es')", "s=input()\nif s[-1]!='s':print(s+'s')\nelse:print(s+'es')"]
['Runtime Error', 'Accepted']
['s341679771', 's101541367']
[8944.0, 9064.0]
[31.0, 27.0]
[107, 55]
p02546
u715985689
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["print(input()+('es' if s[-1] == 's' else 's'))", "print(input().strip()+('es' if s[-1] == 's' else 's'))\n", "s = input()\nprint(s+('es' if s[-1] == 's' else 's'))"]
['Runtime Error', 'Runtime Error', 'Accepted']
['s069453263', 's913736740', 's043887810']
[8956.0, 8804.0, 8952.0]
[24.0, 27.0, 32.0]
[46, 55, 52]
p02546
u719044784
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['from pattern.text.en import singularize\n\nplurals = [int(input())]\n\nsingles = [singularize(plural) for plural in plurals]\nprint singles', 's=input()\nif s[-1]==s:\n print(s+"s")\nelse:\n print(s+"es")', "S=(input())\nif S[-1]=='s':\n S = S + 'es'\nelse:\n S = S + 's'\nprint(S)"]
['Runtime Error', 'Wrong Answer', 'Accepted']
['s368168806', 's812093880', 's214808389']
[8932.0, 9024.0, 9088.0]
[25.0, 25.0, 29.0]
[134, 63, 74]
p02546
u724295910
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
["S = input()\n\nif S[-1] == 's':\n S = S + 's'\nelse:\n S = S + 'es'\n\nprint(S)", "S = input()\n\nif S[-1] == 's':\n S = S + 'es'\nelse:\n S = S + 's'\n\nprint(S)\n"]
['Wrong Answer', 'Accepted']
['s160048104', 's150348506']
[9088.0, 9080.0]
[28.0, 24.0]
[74, 75]
p02546
u728050879
2,000
1,048,576
In the Kingdom of AtCoder, people use a language called Taknese, which uses lowercase English letters. In Taknese, the plural form of a noun is spelled based on the following rules: * If a noun's singular form does not end with `s`, append `s` to the end of the singular form. * If a noun's singular form ends with `s`, append `es` to the end of the singular form. You are given the singular form S of a Taknese noun. Output its plural form.
['N,X,M = map(int, input().split())\n\n\nA = [-1]*(M+100)\nA[0] = X\ni = 0\ntmpans = 0\nflag = False\ncheck = [-1]*(M+1)\nslice = -1\nwhile i< N-1:\n newa = A[i]**2%M\n i+= 1\n if check[newa] != -1:\n flag = True\n slice = check[newa]\n break\n A[i] = newa\n check[newa] = i\n\nif not flag:\n print(sum(A[:i+1]))\n\nelse:\n print(sum(A[:slice])+ sum(A[slice:i])*((N-slice)//(i-slice))+sum(A[slice:slice + (N-slice)%(i-slice)]))\n', 's = input()\nif s[-1] == "s":\n print(s + "es")\nelse:\n print(s + "s")\n']
['Runtime Error', 'Accepted']
['s592552107', 's377012692']
[9232.0, 9088.0]
[27.0, 25.0]
[444, 74]