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 |
|---|---|---|---|---|---|---|---|---|---|---|
p03085 | u206787454 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["from itertools import accumulate\nn, q = list(map(int, input().split()))\ns = input()\na = [list(map(int, input().split())) for i in range(q)]\n\nflg = []\n\nfor i in range(n-1):\n tmp = s[i:i+2]\n if tmp == 'AC':\n flg.append(1)\n else:\n flg.append(0)\n \nflg2 = [0] + flg\nflg2 = list(accu... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s304738857', 's643587284', 's108126886'] | [3064.0, 3064.0, 2940.0] | [18.0, 17.0, 20.0] | [368, 369, 120] |
p03085 | u207036582 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nif s == "A" : s = "T"\nelse if s == "T" : s = "A"\nelse if s == "C" : s = "G"\nelse : s = "C"\nprint(s)', 's = input()\nif s == "A" : s = "T"\nelse if s == "T" : s = "A"\nelse if s == "C" : s = "G"\nelse s = "C"\nprint(s)', 's = input()\nif s == "A" : s = "T"\nelif s == "T" : s = "A"\nelif s == "C" : s =... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s370302548', 's767057309', 's312247858'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [111, 109, 105] |
p03085 | u207464563 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\n\nif b == \'A\':\n print("T")\nelif b == \'C\':\n print("G")\nelif b == \'G\':\n print("C")\nelse b == \'T\':\n print("A")', 'b = input()\n# print(type(b))\n\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "G":\n print("C")\nelse:\n print("A")'] | ['Runtime Error', 'Accepted'] | ['s464077014', 's407572891'] | [2940.0, 3060.0] | [17.0, 19.0] | [130, 138] |
p03085 | u209918867 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s=input();['C' if s=='G' else'G','T' if s=='A' else'A'][s in'AT']", "s=input();print(['C' if s=='G' else'G','T' if s=='A' else'A'][s in'AT'])"] | ['Wrong Answer', 'Accepted'] | ['s030871715', 's757041510'] | [2940.0, 2940.0] | [18.0, 17.0] | [65, 72] |
p03085 | u211236379 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N, Q = map(int, input().split())\nS = input()\nt=[0]*(N+1)\nfor i in range(N):\n\tt[i + 1] = t[i] + (1 if S[i : i + 2] == 'AC' else 0)\nfor i in range(Q):\n\tl, r = map(int, input().split())\n\tprint(t[r-1] - t[l-1])\n ", "N, Q = map(int, input().split())\nS = input()\nt = [0] * (N+1)\nfor i in range(N):\n t[i+1] ... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s221132829', 's851357723', 's219567163'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [208, 219, 120] |
p03085 | u213497190 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["x=input()\ndic={'A':'T',\n 'C':'G',\n 'G':'C',\n 'T':,'A',\n }\n\nprint(dic[x])", "x=input()\ndic={'A':'T',\n 'C':'G',\n 'G':'C',\n 'T':'A',\n }\n \nprint(dic[x])"] | ['Runtime Error', 'Accepted'] | ['s981411229', 's889501787'] | [2940.0, 2940.0] | [17.0, 17.0] | [91, 91] |
p03085 | u215315599 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nout = ""\n\nif b == "A":\n out = "T"\nelif b == "C":\n out = G\nelif b = "G":\n out = "C"\nelse:\n out = "A"\nprint(out)\n', 'import sys\nimport os\nf = open(\'input.txt\',\'r\')\nsys.stdin = f\n\nb = input()\nout = ""\n\nif b == "A":\n out = "T"\nelif b == "C":\n out = "G"\nelif b == "... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s224227509', 's606762126', 's395713483'] | [2940.0, 3064.0, 2940.0] | [17.0, 17.0, 18.0] | [135, 200, 137] |
p03085 | u219503971 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s=input()\nif s='A':\n print('T')\nelif s='T':\n print('A')\nelif s='C':\n print('G')\nelif s='G':\n print('C')", "s=input()\nif s=='A':\n print('T')\nelif s=='T':\n print('A')\nelif s=='C':\n print('G')\nelse:\n print('C')\n"] | ['Runtime Error', 'Accepted'] | ['s595463218', 's960133704'] | [2940.0, 3060.0] | [17.0, 19.0] | [107, 105] |
p03085 | u220345792 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['N, Q = map(int, input().split())\ndata = input()\nresult = [0] * N\nfor i in range(N-1):\n if data[i] == "A" and data[i+1]:\n result[i+1] = result[i] + 1\n else:\n result[i+1] = result[i\n\nfor i in range(Q):\n l, r = map(int, input().split())\n print(result[r-1]-result[l-1])\n', 'b = input()\n\nif b == "A"... | ['Runtime Error', 'Accepted'] | ['s432366259', 's790320108'] | [2940.0, 2940.0] | [17.0, 17.0] | [276, 122] |
p03085 | u221345507 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["A = input()\nif A = 'A':\n print ('T')\nelif A = 'T':\n print ('A')\nelif A = 'G':\n print ('C')\nelse:\n print('G')", "A = input()\nif A == 'A':\n print ('T')\nelif A == 'T':\n print ('A')\nelif A == 'G':\n print ('C')\nelse:\n print('G')\n"] | ['Runtime Error', 'Accepted'] | ['s105129332', 's143794743'] | [2940.0, 2940.0] | [17.0, 17.0] | [120, 124] |
p03085 | u227082700 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s=input()\nif s=="A":print("A")\nelif s=="C":print("T")\nelif s=="G":print("C")\nelse:print("G")', 'd={"A":"T","T":"A","G":"C","C":"G"}\ns=""\nfor i in input():\n s+=d[i]\nprint(s)'] | ['Wrong Answer', 'Accepted'] | ['s316328544', 's307945540'] | [2940.0, 2940.0] | [17.0, 17.0] | [92, 77] |
p03085 | u227085629 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s = input()\nif s = 'A':\n print('T')\nelif s = 'T':\n print('A')\nelif s = 'G':\n print('C')\nelse:\n print('G')", "s = input()\nif s == 'A':\n print('T')\nelif s == 'T':\n print('A')\nelif s == 'G':\n print('C')\nelse:\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s559595446', 's237958591'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 112] |
p03085 | u228232845 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["from collections import defaultdict, deque\nimport sys\n\nINF = float('inf')\ndef LI(): return list(map(int, sys.stdin.buffer.readline().split()))\ndef I(): return int(sys.stdin.buffer.readline())\ndef LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()\ndef S(): return sys.stdin.buffer.readline... | ['Runtime Error', 'Accepted'] | ['s588698836', 's946923226'] | [3064.0, 3316.0] | [17.0, 21.0] | [734, 722] |
p03085 | u229518917 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S=input()\nacgt=['A','C','G','T']\n\nc=0\nans=0\n\nfor i in S:\n if i in acgt:\n c+=1\n ans=max(ans,c)\n else:\n c=0\nprint(ans)", 'b=input()\nif b==\'A\':\n print(\'T\')\nelif b==\'T\':\n print(\'A\')\nelif b=="C":\n print(\'G\')\nelse:\n print(\'C\')'] | ['Wrong Answer', 'Accepted'] | ['s400151008', 's629622231'] | [2940.0, 2940.0] | [17.0, 17.0] | [143, 112] |
p03085 | u230621983 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nprint('T' if b == 'A')\nprint('A' if b == 'T')\nprint('C' if b == 'G')\nprint('G' if b == 'C')", "b == input()\nprint('A' if b == 'T')", "b = input()\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s104174667', 's113783091', 's914194084'] | [2940.0, 2940.0, 3064.0] | [17.0, 16.0, 17.0] | [103, 35, 112] |
p03085 | u231122239 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["n, q = map(int, input().split(' '))\ns = input()\nc = [0] * n\nfor i in range(1, n):\n c[i] += c[i-1]\n if s[i-1:i+1] == 'AC':\n c[i] += 1\nfor _ in range(q):\n l, r = map(int, input().split(' '))\n print(c[r-1] - c[l-1])\n", "master = {\n 'A': 'T',\n 'T': 'A',\n 'C': 'G',\n 'G': 'C'\n}... | ['Runtime Error', 'Accepted'] | ['s413958642', 's588585944'] | [3060.0, 2940.0] | [17.0, 17.0] | [232, 90] |
p03085 | u231615655 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\n\nif "b"=="A":\n\tprint("T")\nelif "b"=="T":\n\tprint("A")\nelif "b"=="C":\n\tprint("G")\nelif "b"=="G":\n\tprint("C")', 'b=input()\n\nif b=="A":\n\tprint("T")\nelif b=="T":\n\tprint("A")\nelif b=="C":\n\tprint("G")\nelif b=="G":\n\tprint("C")'] | ['Wrong Answer', 'Accepted'] | ['s399386803', 's537788773'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 108] |
p03085 | u236566099 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = ''\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')", "b = ''\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelif b == 'G':\n print('C')\nelse:\n pass\n", "if b == 'A':\n print('T')\nelif b == 'T':\n print('A... | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s298046181', 's373516230', 's857946673', 's683212707'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [107, 130, 110, 135] |
p03085 | u239204773 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S = input()\n\nif S == 'A':\n print('T')\nelif S == 'C':\n print('G')\nelif S == 'G':\n print('C')\nelif S == 'T'::\n print('A')\n", "S = input()\n\nif S == 'A':\n print('T')\nelif S == 'C':\n print('G')\nelif S == 'G':\n print('C')\nelif S == 'T'::\n print('A')\n", "N,Q = map(int,input().spli... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s025128425', 's247157212', 's567362282', 's039849629'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 16.0, 19.0, 17.0] | [132, 132, 148, 131] |
p03085 | u243002383 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["def main():\n bases={\n 'A':'T',\n 'T':'A',\n 'C':'G',\n 'G':'C'\n }\n b=input()\n print(bases(b))", "def main():\n bases={\n 'A':'T',\n 'T':'A',\n 'C':'G',\n 'G':'C'\n }\n b=input()\n print(bases[b])", "bases={\n 'A':'T',\n 'T':'A',\n 'C':'G',\n 'G':'C'\n}\n\nprint(bases(input()))", "bases={\n 'A':'T',\... | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s192605621', 's297296987', 's602190086', 's623053111', 's751301564', 's624553093'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0, 17.0, 17.0, 17.0] | [94, 94, 75, 93, 78, 68] |
p03085 | u243572357 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["a = input()\nprint('A' if a=='A' else 'T' if a == 'C' else 'C' if a=='G' else 'G')", 'b=input()\nprint("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")'] | ['Wrong Answer', 'Accepted'] | ['s557672328', 's491512221'] | [2940.0, 2940.0] | [17.0, 18.0] | [81, 77] |
p03085 | u248221744 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b ='A':\n print('T')\nelif b = 'T':\n print('A')\nelif b = 'C':\n print('G')\nelse:\n print('C')", "b = input()\nif b =='A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s873115564', 's102503493'] | [2940.0, 2940.0] | [17.0, 17.0] | [108, 111] |
p03085 | u248670337 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input():\nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelif b == "C":\n print("G")', 'b = input():\nif b == "A":\n print("T")\nelif b = "T":\n print("A")\nelif b = "G":\n print("C")\nelif v = "C":\n print("G")', 'b = input();\nif b == "A":\n print("T")\nelif b = "T... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s319701607', 's544248202', 's879373116', 's111703401'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [122, 119, 119, 121] |
p03085 | u252964975 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['n=int(input())\nif n=="A":\n print("T")\nif n=="T":\n print("A")\nif n=="C":\n print("G")\nif n=="G":\n print("C")', 'n=str(input())\nif n=="A":\n print("T")\nif n=="T":\n print("A")\nif n=="C":\n print("G")\nif n=="G":\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s156500941', 's184518911'] | [2940.0, 2940.0] | [17.0, 17.0] | [110, 111] |
p03085 | u254871849 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['import sys\n\na = \'ATCG\'\nb = \'TAGC\'\nbond = dict(zip(a, b))\n\nprint(bond)\ndef main():\n b = sys.stdin.readline().rstrip()\n print(bond[b])\n\nif __name__ == "__main__":\n main()\n', 'import sys\n\nbond = dict((\'A\', \'T\'), (\'T\', \'A\',), (\'C\', \'G\'), (\'G\', \'C\'))\n\ndef main():\n b = sys.... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s376236074', 's489658009', 's155043212'] | [2940.0, 2940.0, 2940.0] | [22.0, 17.0, 17.0] | [178, 182, 151] |
p03085 | u259755734 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["A = open(0).read()\nB = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}\nprint(B[A])", "A = input()\nB = {'A':'T', 'T':'A', 'C':'G', 'G':'C'}\nprint(B[A])"] | ['Runtime Error', 'Accepted'] | ['s663995471', 's022675123'] | [2940.0, 2940.0] | [18.0, 17.0] | [71, 64] |
p03085 | u261891508 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['if input=="A":\n print("T")\nelif input=="T":\n print("A")\nelif input=="C":\n print("G")\nelse input=="G":\n print("C")', 's=input()\nif s=="A":\n print("T")\nelif s=="T":\n print("A")\nelif s=="C":\n print("G")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s582925308', 's684414262'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 104] |
p03085 | u262084284 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["# coding: utf-8\n\ns = input()\n\na1 = ['A','T']\na2 = ['C','G']\n\nprint(s)\nif s in a1:\n l = a1\nelse:\n l = a2\n\ntry:\n l.discard(s)\nexcept AttributeError:\n pass\n\n", "# coding: utf-8\n\ns = input()\n\na1 = ['A','T']\na2 = ['C','G']\n\nprint(s)\nif s in a1:\n l = a1\nelse:\n l = a2\n\nl.disc... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s319330700', 's363429759', 's801990663'] | [2940.0, 2940.0, 2940.0] | [19.0, 17.0, 17.0] | [166, 138, 135] |
p03085 | u262869085 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['ans ={"A":"C","C":"A","G":"T","T":"G"}\nprint(ans[input()])', 'ans ={"A":"T","T":"A","G":"C","C":"G"}\nprint(ans[input()])'] | ['Wrong Answer', 'Accepted'] | ['s483897093', 's319064613'] | [2940.0, 2940.0] | [17.0, 17.0] | [58, 58] |
p03085 | u266171694 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\n\nif b = 'A':\n print('T')\nelif b = 'T':\n print('A')\nelif b = 'C':\n print('G')\nelif b = 'G':\n print('C')\nelse:\n pass\n", "b = input()\n\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelif b == 'G':\n print('C')\nelse:\n pass\n"] | ['Runtime Error', 'Accepted'] | ['s158479561', 's298032441'] | [2940.0, 2940.0] | [17.0, 17.0] | [142, 146] |
p03085 | u268884249 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['a = list(input())\nb = ""\nc = ""\nfor i in range(len(a)):\n if(a[i] == "A" or a[i] == "G" or a[i] == "T" or a[i] == "C"):\n b += a[i]\n else:\n if(len(b)>len(c)):\n c = b\n b = ""\nprint(len(c))', 'a = input()\nif(a == "A"):\n print("T")\nelif(a == "T"):\n print("A")\nelif(a == "G"):\n print("C"... | ['Wrong Answer', 'Accepted'] | ['s011982429', 's525683265'] | [3060.0, 2940.0] | [17.0, 19.0] | [203, 115] |
p03085 | u273038590 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['#ABC122 A - Double Helix\nb=input()\nprint("A" if b=="A" else "T" if b=="C" else "C" if b=="G" else "G") ', 'b=input()\nprint("A" if b=="A" else "T" if b=="C" else "C" if b=="G" else "T") ', 'b=input()\nprint("A" if b=="A" else "T" if b=="C" else "C" if b=="G" else "G") ', 'b=input()\nprint("A" if b=="T" else "G" if ... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s057463333', 's117507144', 's327551225', 's380077050'] | [2940.0, 2940.0, 2940.0, 2940.0] | [19.0, 17.0, 18.0, 17.0] | [103, 78, 78, 78] |
p03085 | u277312083 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nif s == "A":\n print("C")\nelif s == "C":\n print("A")\nelif s == "G":\n print("T")\nelif s == "T":\n print("G")\n', 's = input()\nif s == "A":\n print("T")\nelif s == "T":\n print("A")\nelif s == "C":\n print("G")\nelif s == "G":\n print("C")\n'] | ['Wrong Answer', 'Accepted'] | ['s335652859', 's287667734'] | [2940.0, 2940.0] | [17.0, 17.0] | [130, 130] |
p03085 | u277641173 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s=input()\nle=len(s)\nlis=[]\nfor i in range(0,le):\n if s[i]!="A" and s[i]!="" and s[i]!="T" and s[i]!="G":\n lis.append(i)\nlo=0\nfor j in range(0,len(lis)-1):\n if lis[j+1]-lis[j]-1>=lo:\n lo=lis[j+1]-lis[j]-1\nif lis[0]>=lo:\n lo=lis[j]\nif len(lis)-lis[-1]+1>=lo:\n lo=len(lis)-lis[-1]-1\nprint(lo)', 's... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s187109017', 's204878009', 's341269773', 's538003600', 's222097997'] | [3064.0, 3064.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 18.0, 17.0] | [299, 287, 103, 118, 106] |
p03085 | u278444041 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['S = input()\nl= len(S)\nans = 0\n\nfor i in range(l):\n for j in range(l-i+1):\n seq = S[i:i+j]\n seq2 = seq.replace("A","").replace("G","").replace("T","").replace("C","")\n if seq2 == "":\n ans = max(ans, len(seq))\n\nprint(ans)', 'b = input()\nif b == "A":\n ans = "T"\nelif b ... | ['Wrong Answer', 'Accepted'] | ['s312440282', 's846531158'] | [3060.0, 2940.0] | [17.0, 17.0] | [254, 132] |
p03085 | u278868910 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["from functools import lru_cache\nMOD = 1000000007\n\ndef valid(s):\n f = 0\n if len(s) == 4:\n f = 1\n if (s[0] == 'A' and s[2:] == 'GC') or (s[0:2] == 'AG' and s[3] == 'C'):\n return 0\n return s[f:] != 'AGC' and s[f:] != 'ACG' and s[f:] != 'GAC'\n \n\n@lru_cache(maxsize=None)\nd... | ['Runtime Error', 'Accepted'] | ['s656649609', 's433017590'] | [3572.0, 2940.0] | [23.0, 17.0] | [615, 97] |
p03085 | u282875477 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=int(input())\nif b=A:\n print(T)\nif b=T:\n print(A)\nif b=C: \n print(G)\nif b=G \n print(C)', 'b=input()\nif b=A:\n print("T")\nif b=T:\n print("A")\nif b=C: \n print("G")\nif b=G: \n print("C")', "b=input()\n\nif b='A':\n print('T')\nelif b='T':\n print('A')\nelif b='G':\n print('C')\nelse:\n print(... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s527650453', 's567761229', 's836178173', 's842878423', 's711928641'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0] | [92, 95, 102, 95, 114] |
p03085 | u283751459 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = list(input())\n\nfor i in range(len(b)):\n if b[i] == "A":\n b[i] = "T"\n elif b[i] == "T":\n b[i] = "A"\n elif b[i] == "C":\n b[i] = "G"\n else:\n b[i] = "C"\n \nprint(b)\n', 'b = list(input())\n\nfor i in len(b):\n if b[i] == "A":\n b[i] = "T"\n elif b[i] == "T":\n b[i] = "A"\n elif ... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s063345784', 's601635313', 's921596306'] | [9052.0, 8868.0, 8984.0] | [22.0, 19.0, 23.0] | [183, 175, 192] |
p03085 | u288948615 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s = input()\n\nif s == 'A':\n print('T')\nelfi s == 'T':\n print('A')\nelif s == 'C':\n print('G')\nelse:\n print('C')", "s = input()\n\nif s == 'A':\n print('T')\nelif s == 'T':\n print('A')\nelif s == 'C':\n print('G')\nelse:\n print('C')\n"] | ['Runtime Error', 'Accepted'] | ['s781704108', 's563424752'] | [2940.0, 2940.0] | [17.0, 19.0] | [113, 114] |
p03085 | u291543340 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nmx = 0\nli = ["A", "T", "G", "C"]\nlen = 0\nfor i in s:\n if i in li:\n len += 1\n else:\n mx = max(mx, len)\n len = 0\n\nmx = max(mx, len)\n\nprint(mx)\n', 'b = input()\nif b == "A":\n print("T")\nif b == "T":\n print("A")\nif b == "G":\n print("C")\nif b == "C":\n ... | ['Wrong Answer', 'Accepted'] | ['s611583215', 's534545798'] | [3060.0, 2940.0] | [19.0, 17.0] | [180, 124] |
p03085 | u291925152 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['def atgc(base):\n b = base.lower()\n if b in ["a", "t", "g", "c"]:\n if b == "a":\n return "T"\n elif b == "t":\n return "A"\n elif b == "g":\n return "C"\n elif b == "c":\n return "G"', 'base = str(input())\n\nif base == "G":\n return_base = "C"\nelif base == "C":\n return_base = ... | ['Wrong Answer', 'Accepted'] | ['s552743178', 's787972546'] | [2940.0, 2940.0] | [17.0, 18.0] | [208, 189] |
p03085 | u292810930 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b == 'A':\n print('C')\nelif b == 'C':\n print('A')\nelif b == 'G':\n print('T')\nelse:\n print('G')\n", "b = input()\nif b == 'A':\n print('C')\nelif b == 'C':\n print('A')\nelif b == 'G':\n print('T')\nelse b == 'T':\n print('G')\n", "N, Q = map(int,input().split())\nS = inpu... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s569685175', 's624370950', 's653703472', 's835911410'] | [2940.0, 2940.0, 3064.0, 2940.0] | [17.0, 20.0, 17.0, 17.0] | [121, 130, 466, 121] |
p03085 | u294385082 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nl = 0\nlenmax = 0\n\nfor i in s:\n if i in "ACGT":\n l += 1\n else:\n lenmax = max(lenmax,l)\n l = 0\nprint(lenmax)', 's = input()\nl = 0\nlenmax = 0\n\nfor i in s:\n if i in "ACGT":\n l += 1\n else:\n lenmax = max(lenmax,l)\n l = 0\nlenmax = max(lenmax,l)\nprint(l)', "b = input()\n... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s319300188', 's923897685', 's107473491'] | [2940.0, 2940.0, 2940.0] | [19.0, 17.0, 17.0] | [129, 147, 113] |
p03085 | u294630296 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['\nN, Q = map(int, input().split())\nS = list(input())\n\nAClist = [0]\ncounter = 0\n\ni=0\nwhile i+1 < N:\n if S[i:i+2] == "AC":\n counter+=1\n\n AClist.append(counter)\n i+=1\n\n\nwhile Q > 0:\n l, r = input().split()\n r = int(r) \n l = int(l)\n\n print(AClist[r-1]-AClist[l-1])\n\n Q ... | ['Runtime Error', 'Accepted'] | ['s540223093', 's350162830'] | [3060.0, 2940.0] | [17.0, 17.0] | [303, 123] |
p03085 | u295294832 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N = input()\na=0\nb=0\nfor i in range(len(N)):\n\tif N[i] == 'A' or N[i] == 'T' or N[i] == 'C' or N[i] == 'G' :\n\t\ta+=1\n\telse: \n\t\tif a > b: b = a\n\t\ta=0\n\nprint(b)", 'a = "ACGT"\nprint(a[3-a.find(input())])'] | ['Wrong Answer', 'Accepted'] | ['s448896093', 's357338519'] | [2940.0, 2940.0] | [17.0, 17.0] | [158, 38] |
p03085 | u296150111 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['a=input()\nif a=A:\n print(T)\nelif a=T:\n print(A)\nelif a=C:\n print(G) \nelse:\n print(C)', 'a=input()\nif a=="A":\n print("T")\nelif a=="T":\n print("A")\nelif a=="C":\n print("G") \nelse:\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s037870491', 's182356812'] | [2940.0, 2940.0] | [17.0, 17.0] | [84, 102] |
p03085 | u297109012 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['if __name__ == "__main__":\n b = tuple(map(int, input().split(" ")))\n if b == "A":\n print("T")\n if b == "T":\n print("A")\n if b == "C":\n print("G")\n if b == "G":\n print("C")', 'if __name__ == "__main__":\n b = input()\n if b == "A":\n print("T")\n if b... | ['Runtime Error', 'Accepted'] | ['s722557350', 's123560938'] | [2940.0, 2940.0] | [17.0, 16.0] | [214, 186] |
p03085 | u297757054 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['def main():\n *S, = input()\n count = 0\n maximum = 0\n for i in S:\n if i == "A" or i == "C" or i == "G" or i == "T":\n count += 1\n else:\n if maximum < count:\n maximum = count\n count = 0\n print(max(count, maximum))\nmain()', 'def main(... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s395337907', 's669749297', 's982972645'] | [2940.0, 2940.0, 2940.0] | [18.0, 18.0, 17.0] | [293, 265, 176] |
p03085 | u299840026 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['n = input()\n\nif n == "A":\n print("A")\n\nif n == "C":\n print("T")\n\nif n == "G":\n print("C")\n\nif n == "T":\n print("G")\n', 'n = input()\n\nif n == "A":\n print("A")\nif n == "C":\n print("T")\nif n == "G":\n print("C")\nif n == "T":\n print("G")', "b = input()\nif b == 'A':\n print... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s072281893', 's723405751', 's137937564'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [128, 124, 123] |
p03085 | u300968187 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["n, q = map(int, input().split())\ns = input()\nl = [0] * q\nr = [0] * q\nfor i in range(0, q):\n l[i], r[i] = map(int, input().split())\nac_index = [False] * n\nfor i in range(n - 1):\n if s[i] + s[i + 1] == 'AC':\n ac_index[i] = True\nfor i in range(0, q):\n count = 0;\n for j in range(l[i] - 1, r... | ['Runtime Error', 'Accepted'] | ['s066585089', 's844253629'] | [3064.0, 3064.0] | [17.0, 17.0] | [379, 129] |
p03085 | u301302814 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["base = input()\na = ['A', 'T']\nb = ['G', 'C']\nif base in a:\n print([a[0], a[1]][if base == 'A'])\nelse:\n print([b[0], b[1]][if base == 'G'])", "base = input()\na = ['A', 'T']\nb = ['G', 'C']\nif base in a:\n print([a[0], a[1]][base == 'A'])\nelse:\n print([b[0], b[1]][base == 'G'])\n"] | ['Runtime Error', 'Accepted'] | ['s033136728', 's743464646'] | [2940.0, 2940.0] | [17.0, 17.0] | [140, 135] |
p03085 | u306950978 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nif b = "A":\n print("T")\nif b = "T":\n print("A")\nif b = "G":\n print("C")\nif b = "C":\n print("G")', 'b = input()\nif b == "A":\n print("T")\nif b == "T":\n print("A")\nif b == "G":\n print("C")\nif b == "C":\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s967953788', 's887518023'] | [2940.0, 2940.0] | [17.0, 17.0] | [119, 123] |
p03085 | u308460366 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["import sys\n\nS = list(input())\n\nlength = 0\nmaxlen = 0\n\nfor s in S:\n\tif s == 'A' or s == 'T' or s == 'C' or s == 'G' :\n\t\tlength += 1\n\telse :\n\t\tif length > maxlen:\n\t\t\tmaxlen = length\n\t\tlength = 0\n\nprint(maxlen)\n\n\n", "import sys\n\nS = list(input())\n\nlength = 0\nmaxlen = 0\n\nfor i,s in enu... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s151706690', 's653083671', 's891250596'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 19.0] | [210, 223, 118] |
p03085 | u309457741 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = int(input())\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "G":\n print("C")\nelse:\n print("A")', 'b = input()\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "G":\n print("C")\nelse:\n print("A")'] | ['Runtime Error', 'Accepted'] | ['s099896857', 's212939254'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 112] |
p03085 | u309834353 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['str = input()\nif str == "A":\n print(T)\nelif str == "T":\n print(A)\nelif str == "C":\n print(G)\nelif str == "G":\n print(C)', 'str = input()\nif str = "A":\n print("T")\nelif str = "T":\n print("A")\nelif str = "C":\n print("G")\nelif str = "G":\n print("C")', 'str = input()\nif str = "A":\n print(T)\nel... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s220074651', 's300068437', 's944519118', 's136527381'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [123, 127, 119, 131] |
p03085 | u310108817 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['if(b=="A"):\n print("T")\nif(b=="T"):\n print("A")\nif(b=="G"):\n print("C")\nif(b=="C"):\n print("G")', 'b=input()\n\nif(b=="A"):\n print("T")\nif(b=="T"):\n print("A")\nif(b=="G"):\n print("C")\nif(b=="C"):\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s676767380', 's886402910'] | [2940.0, 2940.0] | [17.0, 17.0] | [107, 118] |
p03085 | u310381103 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\n\nif b =='A':\n print('A')\n\nelif b =='C':\n print('T')\n\nelif b =='G':\n print('C')\n\nelif b =='T':\n print('G')", "b = input()\n\nif b =='A':\n result='A'\n\nelif b =='C':\n result='T'\n\nelif b =='G':\n result='C'\n\nelif b =='T':\n result='G'\n\nprint('result')", "b = input()\n\nif... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s410121790', 's518515169', 's680063020', 's689956630', 's038051931'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 18.0, 18.0] | [125, 142, 140, 153, 140] |
p03085 | u311592491 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nif b=A:\n print("T")\nelif b=T:\n print("A")\nelif b=C:\n print("G")\nelse:\n print("C")', 'b=input()\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="C":\n print("G")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s959497471', 's761055720'] | [8880.0, 8860.0] | [20.0, 23.0] | [95, 104] |
p03085 | u314089899 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['# -*- coding: utf-8 -*-\ntext = str(input())\n \nEnki_list = ["A","C","G","T"]\nTui_list = ["A","T","C","G"] \n\nfor i in range(len(Enki_list)):\n if Enki_list[i] == text:\n print(Tui_list[i])\n break', 's = str(input())\n\nif s=="A":\n print("T")\nelif s=="T":\n print("A")\nelif s=="C":\n print("G")\ne... | ['Wrong Answer', 'Accepted'] | ['s166375830', 's173482894'] | [2940.0, 2940.0] | [17.0, 17.0] | [202, 114] |
p03085 | u318925675 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S=input()\nn=len(S)\ni=0\ncount=0\nmaxcount=0\nwhile(n>0):\n if(S[i]=='A'or S[i]=='T' or S[i]=='G' or S[i]=='C'):\n count=count+1\n if(maxcount<count):\n maxcount=count\n else:\n if(maxcount<count):\n maxcount=count\n count=0\n n=n-1\n i=i+1\nprint(maxcoun... | ['Wrong Answer', 'Accepted'] | ['s839312955', 's783965979'] | [3064.0, 2940.0] | [17.0, 18.0] | [304, 57] |
p03085 | u322185540 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b == 'A':\n b = 'T'\nelif b == 'T':\n b = 'A'\nelif b == 'G':\n b = 'C' \nelse b == 'C':\n b = 'G' \n\nprint(b)", "b = input()\nif b == 'A':\n b = 'T'\nelif b == 'T':\n b = 'A'\nelif b == 'G':\n b = 'C' \nelse:\n b = 'G' \n \nprint(b)"] | ['Runtime Error', 'Accepted'] | ['s744668104', 's431216824'] | [2940.0, 2940.0] | [17.0, 17.0] | [123, 123] |
p03085 | u325264482 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\n\nif b == 'A':\n ans = 'A'\nelif b == 'C':\n ans = 'T'\nelif b == 'G':\n ans = 'C'\nelif b == 'T':\n ans = 'G'\n\nprint(ans)\n", 'B = input()\nans = ""\n\nfor b in B:\n if b == \'A\':\n ans += \'A\'\n if b == \'C\':\n ans += \'T\'\n if b == \'G\':\n ans += \'C\'\... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s088177324', 's683532900', 's604970118'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [139, 190, 139] |
p03085 | u328755070 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\n\nbig = ["A","T","G","C"]\ncou = ["T","A","C","G"]\n\nans = cou.index(b)\nprint(ans)', 'b = input()\n\nbig = ["A","T","G","C"]\nend = ["T","A","C","G"]\n\nans = end.index(b)\nprint(ans)', 'b = input()\n\nbig = ["A","T","G","C"]\ncou = ["T","A","C","G"]\n\nans = cou[big.index(b)]\nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s796159176', 's798205334', 's455751645'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [91, 91, 96] |
p03085 | u329036729 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\n\nma = 0\nfor i in range(len(s)):\n for j in range(0,len(s)-i+1):\n sbstr = s[i:i+j+1]\n print(i,j,sbstr)\n is_good = True\n for c in sbstr:\n if c not in "AGCT":\n is_good = False\n break\n if is_good:\n if (len(sb... | ['Wrong Answer', 'Accepted'] | ['s097249146', 's196929243'] | [3060.0, 2940.0] | [17.0, 17.0] | [361, 124] |
p03085 | u329058683 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['a=input()\nl=[]\nfor i in (list(a)):\n if i=="A" or i=="T" or i=="G" or i=="C":\n l.append(1)\n else:\n l.append(0)\nn=""\nfor i in l:\n n=n+str(i)\nm=[0]\nfor i in range(10):\n if \'1\'*i in n:\n m.append(i)\nprint(max(m))', 'd={"A":"T","C":"G","G":"C","T":"A"}\nprint(d[input()])'] | ['Wrong Answer', 'Accepted'] | ['s375606559', 's614167392'] | [3064.0, 2940.0] | [17.0, 17.0] | [220, 53] |
p03085 | u329455846 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["e_list = ['A', 'C', 'G', 'T']\nb = str(input())\nif b == e_list[1]:\n print(e_list[0])\nelif b == e_list[0]:\n print(e_list[1])\nelif b == e_list[2]:\n print(e_list[3])\nelif b == e_list[3]:\n print(e_list[2])", "e_list = ['A', 'C', 'G', 'T']\nb = str(input())\nif b == e_list[0]:\n print(e_list[3])\nel... | ['Wrong Answer', 'Accepted'] | ['s475847799', 's119990168'] | [3060.0, 3060.0] | [17.0, 17.0] | [212, 212] |
p03085 | u330799501 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\n\nans = [0]\ncnt = 0\nfor i in s:\n if (i == "A" or i == "C" or i == "G" or i == "T"):\n cnt+=1\n else:\n if (cnt > 0):\n ans.append(cnt)\n cnt = 0\nans.append(cnt)\nprint(max(ans))\n', '#k = int(input())\n#s = input()\n#a, b = map(int, input().split())\n#s, t = ... | ['Wrong Answer', 'Accepted'] | ['s105925585', 's878937199'] | [3060.0, 8944.0] | [19.0, 22.0] | [225, 293] |
p03085 | u331464808 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['l = input()\nif l =="A":\n print("T")\nif l =="T":\n print("A")\nif l =="C":\n print("G")\nelse:\n print("C")', 'l = input()\nif l =="A":\n print("T")\nelif l =="T":\n print("A")\nelif l =="C":\n print("G")\nelse:\n print("C")'] | ['Wrong Answer', 'Accepted'] | ['s433471174', 's634702027'] | [2940.0, 2940.0] | [17.0, 17.0] | [105, 109] |
p03085 | u333139319 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['d = input()\n\nif d == "A":\n print("T")\n \nelse if d == "T":\n print("A")\n\n \nelse if d == "C":\n print("G")\n \nelse:\n print("C")\n', 'd = input()\n\nif d == "A":\n print("T")\n \nelse if d == "T":\n print("A")\n\nelse if d == "C":\n print("G")\n \nelse:\n print("C")\n', '... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s607085558', 's880396477', 's113467236'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [144, 139, 121] |
p03085 | u334712262 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input().strip()\nif b == 'A':\n pirnt('T')\nif b == 'T':\n print('A')\nif b == 'G':\n print('C')\nif b == 'C':\n print('G')", "b = input().strip()\nif b == 'A':\n print('T')\nif b == 'T':\n print('A')\nif b == 'G':\n print('C')\nif b == 'C':\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s379855136', 's774831682'] | [2940.0, 2940.0] | [17.0, 17.0] | [123, 123] |
p03085 | u335422127 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b=input()\nb=input()\n\nif b=='A':\n print('T')\nelif b=='T':\n print('A')\nelif b=='C':\n print('G')\nelif b=='G':\n pring('C')", "b=input()\n\nif b=='A':\n print('T')\nelif b=='T':\n print('A')\nelif b=='C':\n print('G')\nelif b=='G':\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s952148549', 's298438740'] | [2940.0, 3060.0] | [18.0, 19.0] | [122, 112] |
p03085 | u335571733 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['if __name__ == "__main__":\n NQ = input().split(" ")\n N ,Q = int(NQ[0]),int(NQ[1])\n\n S = input()\n stack =[]\n for x in range(Q):\n lr = input()\n lr = lr.split(" ")\n l ,r = int(lr[0]),int(lr[1])\n target = S[l-1:r]\n num = target.split("AC")\n stack.append... | ['Runtime Error', 'Accepted'] | ['s835491678', 's088547114'] | [3064.0, 2940.0] | [17.0, 17.0] | [368, 182] |
p03085 | u337080722 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["print(input().replace('A', 'T').replace('T', 'A').replace('C', 'G').replace('G', 'C'))\n", "b = input()\n\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')\n"] | ['Wrong Answer', 'Accepted'] | ['s193740141', 's792526308'] | [2940.0, 2940.0] | [17.0, 17.0] | [87, 122] |
p03085 | u338208364 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N, M = list(map(int, input().split()))\nS = input()\na = []\nfor i in range(M):\n a.append(list(map(int, input().split())))\nfor i in range(M):\n print(S[a[i][0]-1:a[i][1]].count('AC'))", 'b = input()\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="G":\n print("C")\nelse:\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s094104250', 's871842038'] | [3060.0, 2940.0] | [17.0, 17.0] | [183, 106] |
p03085 | u349600366 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = int(input())\nprint("A" if b == T else "T" if b == A else\n "C" if b == G else "T")', 'b = int(input())\nprint("A" if b == "T" else "T" if b == "A" else\n "C" if b == "G" else "T")\n', 'b = int(input())\nprint("A" if b == "T" else "T" if b == "A" else\n "C" if b == "G" else "G")\n', 'b = input()\np... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s260483357', 's319837278', 's867039619', 's604300358'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 16.0] | [90, 97, 97, 92] |
p03085 | u350836088 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nb_dic = {"A":"T","T":"A","C":"G","G":"c"}\nprint(b-dic[b])', 'b = input()\nb_dic = {"A":"T","T":"A","C":"G","G":"C"}\nprint(b_dic[b])'] | ['Runtime Error', 'Accepted'] | ['s400022793', 's006580701'] | [2940.0, 2940.0] | [17.0, 17.0] | [69, 69] |
p03085 | u354623416 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\n \nif b == 'A':\n b = 'T'\nelif b == 'T':\n b = 'A'\nelif b == 'C':\n b = 'G'\nelse:\n b = 'C'\n \nprint(b)\nb = input ')\nif b = a\n", "b = input()\n \nif b = 'A':\n b = 'T'\nelif b = 'T':\n b = 'A'\nelif b = 'C':\n b = 'G'\nelse:\n b = 'C'\n \nprint(b)\nb = input ')\nif b = a\n"... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s203483187', 's457146992', 's330361246'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 19.0] | [144, 141, 120] |
p03085 | u355154595 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["n=input()\nif n==A:\n print('T')\nelif n==T:\n print('A')\nelif n=C:\n print('G')\nelse:\n print('C')", "n=input()\nif n==A:\n print('T')\nelif n==T:\n print('A')\nelif n==C:\n print('G')\nelse:\n print('C')\n", "n=input()\nif n=='A':\n print('T')\nelif n=='T':\n print('A')\nelif n=='C':\n print('G')\nelse... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s769730427', 's915290238', 's041873665'] | [2940.0, 2940.0, 3060.0] | [17.0, 17.0, 19.0] | [97, 99, 105] |
p03085 | u355649707 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["base = input()\n\nif base == 'A':\n print('T')\nelif base == 'T':\n print('A')\nelif base =- 'C':\n print('G')\nelse:\n print('C')", "base = input()\n\nif base == 'A':\n print('T')\nelif base == 'T':\n print('A')\nelif base == 'C':\n print('G')\nelse:\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s303746568', 's235964096'] | [2940.0, 2940.0] | [18.0, 17.0] | [125, 125] |
p03085 | u358254559 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s=input()\nif s=="A":\n print("T")\neilf s=="T":\n print("A")\neilf s=="C":\n print("G")\neilf s=="G":\n print("C")', 's=input()\nif s=="A":\n print("T")\nelif s=="T":\n print("A")\nelif s=="C":\n print("G")\nelif s=="G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s623767253', 's022566162'] | [2940.0, 2940.0] | [18.0, 18.0] | [111, 111] |
p03085 | u360515075 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\n\nprint ("A" if s =="G" else "G" if s =="A" else "C" if s=="T" else "T")', 's = input()\n\nprint ("A" if s =="T" else "T" if s =="A" else "C" if s=="G" else "G")'] | ['Wrong Answer', 'Accepted'] | ['s978667443', 's907992384'] | [2940.0, 2940.0] | [17.0, 17.0] | [83, 83] |
p03085 | u361826811 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["\n\nimport sys\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(10 ** 7)\n\nd = {'A': 'C', 'C': 'A', 'G': 'T', 'T': 'G'}\nb = readline().decode('utf8').split()\nprint(b[0])\nprint(d[b[0]])\n", "\n\nimport sys\n\nread = sys.stdin.buffe... | ['Wrong Answer', 'Accepted'] | ['s563590386', 's087658358'] | [3060.0, 2940.0] | [17.0, 17.0] | [308, 296] |
p03085 | u364541509 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b = 'A':\n print('T')\nelif b = 'T':\n print('A')\nelif b = 'C':\n print('G')\nelif b = 'G':\n print('C')", "b = input()\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelif b == 'G':\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s150124130', 's126242437'] | [2940.0, 2940.0] | [17.0, 18.0] | [117, 121] |
p03085 | u365491796 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["#ABC122B\nS = input()\nSC= S.replace('C','A')\nSCG = SC.replace('G','A')\nSCGT = SCG.replace('T','A')\nans = 0\nwk = 0\nfor i in range(int(len(S))):\n if SCGT[i:i+1] == 'A':\n wk += 1\n else:\n if wk >= ans:\n ans = wk\n wk =0\n\nif wk >= ans:\n ans = wk\nprint(ans)", '#ABC122... | ['Wrong Answer', 'Accepted'] | ['s217276558', 's305449662'] | [3064.0, 2940.0] | [17.0, 17.0] | [290, 130] |
p03085 | u366482170 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nprint(s.translate(str.maketrans({"A":"T","T":"A","C":"G","G":"C"})', 's = input()\nprint(s.translate(str.maketrans({"A":"T","T":"A","C":"G","G":"C"})))'] | ['Runtime Error', 'Accepted'] | ['s650701394', 's648209859'] | [2940.0, 2940.0] | [17.0, 17.0] | [78, 80] |
p03085 | u366577572 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s=input()\n\nif s=='A':\n\tprint 'T'\nelif s=='T':\n \tprint 'A'\nelif s=='G':\n \tprint 'C'\nelif s=='C':\n\tprint 'G'", "s=input()\n\nif s=='A':\n\tprint('T')\nelif s=='T':\n \tprint('A')\nelif s=='G':\n \tprint('C')\nelif s=='C':\n\tprint('G')"] | ['Runtime Error', 'Accepted'] | ['s079266792', 's832159794'] | [2940.0, 3060.0] | [17.0, 20.0] | [107, 111] |
p03085 | u366959492 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nif b="A":\n print("T")\nelif b="T":\n print("T")\nelif b="C":\n print("G")\nelse:\n print("C")\n ', 'b=input()\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="C":\n print("G")\nelse:\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s737602334', 's075000951'] | [2940.0, 2940.0] | [17.0, 17.0] | [114, 113] |
p03085 | u368016155 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\n\nif b==\'A\':\n print "T"\nif b==\'c\':\n print "G"\nif b==\'G\':\n print "C"\nif b==\'T\':\n print "A"', "b = input()\n\nif b=='A':\n print ('T')\nif b=='C':\n print ('G')\nif b=='G':\n print ('C')\nif b=='T':\n print ('A')"] | ['Runtime Error', 'Accepted'] | ['s857762742', 's392987179'] | [2940.0, 2940.0] | [17.0, 17.0] | [104, 112] |
p03085 | u371530330 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["enkitsui = {'A':'T','C':'G','T':'A','G':'C'}\nprint(enkitsui[b])", "b = int(input())\n\nenkitsui = {'A':'T','C':'G','T':'A','G':'C'}\nprint(enkitsui.value['b'])", "b = int(input())\n\nenkitsui = {'A':'T','C':'G','T':'A','G':'C'}\nprint(enkitsui['b'])", "b = input()\nenkitsui = {'A':'T','C':'G','T':'A','G':'C'}\nprint... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s342239579', 's443023772', 's865223290', 's758730571'] | [2940.0, 2940.0, 3064.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [63, 89, 83, 75] |
p03085 | u373274281 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nc = {\n 'A': 'A',\n 'C': 'T',\n 'G': 'C',\n 'T': 'G',\n}\nprint(c[b])\n", "b = input()\nc = {\n 'A': 'T',\n 'C': 'G',\n 'G': 'C',\n 'T': 'A',\n}\nprint(c[b])\n"] | ['Wrong Answer', 'Accepted'] | ['s363717253', 's091634204'] | [2940.0, 2940.0] | [17.0, 17.0] | [80, 80] |
p03085 | u374829922 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\n\nif b == 'A'{\n print('T')\n}else if b =='T'{\n print('A')\n}else if b == 'C'{\n print('C')\n}else{\n print('G')\n}", "b = input()\n \nif b == 'A':\n print('T')\nelif b =='T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')\n"] | ['Runtime Error', 'Accepted'] | ['s234948428', 's907805718'] | [2940.0, 2940.0] | [18.0, 17.0] | [123, 114] |
p03085 | u375172966 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s = list(input())\nacgt = ['A','C','G','T']\ncnt = 0\nans = 0\nfor i in range(len(s)):\n if s[i] in acgt:\n cnt+=1\n else:\n ans = max(ans,cnt)\n cnt = 0\nprint(ans)\n", "b = input()\ndic = {'A':'T','T':'A','C':'G','G':'C'}\nprint(dic[b])\n"] | ['Wrong Answer', 'Accepted'] | ['s675720416', 's339576411'] | [2940.0, 2940.0] | [17.0, 17.0] | [183, 66] |
p03085 | u379692329 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = int(input())\nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelse:\n print("G")', 'b = input()\nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelse:\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s372702977', 's890144780'] | [2940.0, 2940.0] | [16.0, 18.0] | [125, 120] |
p03085 | u384031061 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nr = ""\nif b == "A":\n r = "C"\nelif b == "C":\n r = "A"\nelif b == "G":\n r = "T"\nelse:\n r = "G"\nprint(r)\n ', 'b=input()\nr = ""\nif b == "A":\n r = "T"\nelif b == "T":\n r = "A"\nelif b == "C":\n r = "G"\nelif b == "G":\n r = "C"\nprint(r)\n '] | ['Wrong Answer', 'Accepted'] | ['s368403102', 's606877602'] | [2940.0, 2940.0] | [18.0, 17.0] | [127, 136] |
p03085 | u384261199 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = inout()\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "T":\n print("A")\nelse:\n print("C")', 'b = input()\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "T":\n print("A")\nelse:\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s396422650', 's735231239'] | [2940.0, 2940.0] | [17.0, 17.0] | [121, 122] |
p03085 | u385244248 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = int(input())\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "T":\n print("A")\nelse:\n print("C")\n', 'b = (input())\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "T":\n print("A")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s167969735', 's603359016'] | [2940.0, 2940.0] | [18.0, 17.0] | [126, 122] |
p03085 | u386249594 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N,Q = input().split()\nQ = int(Q)\nS = input()\n\nlist1 = []\n\nfor i in range(Q):\n l,r = map(int,input().split())\n l = l - 1\n list1.append(S[l:r].count('AC'))\n\nfor i in list1:\n print(i)", "N, Q = map(int, input().split())\nS = input()\nt=[0]*(N+1)\nfor i in range(N):\n t[i + 1] = t[i] + (1 if S[... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s398097968', 's809865752', 's562866620'] | [3060.0, 3060.0, 2940.0] | [18.0, 18.0, 18.0] | [192, 217, 125] |
p03085 | u387080888 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['dict={"A":"T","C":"G","T":"A","G":"C"}\ndict[input()]', 'dict={"A":"T","C":"G","T":"A","G":"C"}\ndict[input()]', 'dict={"A":"T","C":"G","T":"A","G":"C"}\nprint(dict[input()])'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s624908716', 's746227918', 's563173301'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [52, 52, 59] |
p03085 | u392519579 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\n\nc = {A:T,T:A,C:G,G:C}\n\nprint(c[b])', 'b = input()\n \nc = {"A":"T","T":"A","C":"G","G":"C"}\n \nprint(c[b])'] | ['Runtime Error', 'Accepted'] | ['s599436440', 's205861373'] | [2940.0, 2940.0] | [18.0, 17.0] | [47, 65] |
p03085 | u393253137 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nprint("A" if b=="A" else "T" if b=="C" else "C" if b=="G" else "G")', 'b=input()\nprint("A" if b=="T" else "T" if b=="A" else "C" if b=="G" else "G")'] | ['Wrong Answer', 'Accepted'] | ['s688603526', 's592678662'] | [2940.0, 2940.0] | [17.0, 17.0] | [77, 77] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.