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 | u790830953 | 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. | ['ref=imput()\n\nif (ref=="A"):\n print("T")\nelif (ref=="T"):\n print("A")\nelif (ref=="G"):\n print("C")\nelif (ref=="C"):\n print("G")', 'ref=input()\n\nif (ref=="A"):\n print("T")\nelif (ref=="T"):\n print("A")\nelif (ref=="G"):\n print("C")\nelif (ref=="C"):\n print("G")\n '] | ['Runtime Error', 'Accepted'] | ['s936155013', 's599855230'] | [2940.0, 2940.0] | [17.0, 17.0] | [130, 133] |
p03085 | u795323188 | 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()\nnum = []\nlists = ["A","c","G","T"]\ncount = 0\n\nfor i in range(len(s)):\n if s[i] in lists:\n count +=1\n else:\n num.append(count)\n count = 0\nelse:\n num.append(count)\nprint(max(num))\n \n ', 'enki = {"A":"T","T":"A","C":"G","G":"C"}\nB= input()\nprint(enki[B])'] | ['Wrong Answer', 'Accepted'] | ['s213240875', 's587212103'] | [2940.0, 2940.0] | [17.0, 17.0] | [224, 66] |
p03085 | u802963389 | 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 ret = "C"\nelif b == "C": \n ret = "A"\nelif b == "G": \n ret = "T"\nelif b == "T": \n ret = "G"\nprint(ret)', 'b = input()\n\nif b =="A":\n ret = "T"\nelif b == "T": \n ret = "A"\nelif b == "G": \n ret = "C"\nelif b == "C": \n ret = "G"\nprint(ret)\n'] | ['Wrong Answer', 'Accepted'] | ['s608105570', 's862838815'] | [2940.0, 2940.0] | [17.0, 17.0] | [131, 132] |
p03085 | u809457879 | 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'\n else 'T' if b=='A'\n else 'G' if b=='C'\n else 'C')", "b=input()\nprint('A' if b=='T'\n else 'T' if b=='A'\n else 'G' if b=='C'\n else 'C')"] | ['Runtime Error', 'Accepted'] | ['s765310259', 's778598120'] | [2940.0, 2940.0] | [17.0, 17.0] | [100, 95] |
p03085 | u811436126 | 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 s = s.replace("A", "T").replace("T", "A").replace("G", "C").replace("C", "G")\n print(s)\n\n\nif __name__ == \'__main__\':\n main()', "b = input()\n\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'G':\n print('C')\nelif b == 'C':\n print('G')\n"] | ['Wrong Answer', 'Accepted'] | ['s213371409', 's591900550'] | [2940.0, 2940.0] | [17.0, 17.0] | [162, 131] |
p03085 | u811512248 | 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 re\nN, Q = map(int, input().split())\nS = input()\nl = []\nr = []\nfor i in range(Q):\n li, ri = map(int, input().split())\n l += [li]\n r += [ri]\n\nfor ind in range(Q):\n substr = S[max(0, l[ind]-1) : min(r[ind], N)]\n #print(substr.count("AC"))\n print(len(re.findall("AC", S)))', 'b = inpu... | ['Runtime Error', 'Accepted'] | ['s852289107', 's351171550'] | [3188.0, 3060.0] | [19.0, 19.0] | [293, 129] |
p03085 | u814986259 | 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 = "G":\n print("C")\nelif b = "T":\n print("A")\nelif b = "C":\n print("G")', "b = input()\nd = dict()\nd['A'] = 'T'\nd['T'] = 'A'\nd['C'] = 'G'\nd['G'] = 'C'\n\nprint(d[b])\n"] | ['Runtime Error', 'Accepted'] | ['s116492054', 's424842799'] | [2940.0, 9028.0] | [17.0, 25.0] | [115, 88] |
p03085 | u817692975 | 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')\n"] | ['Runtime Error', 'Accepted'] | ['s233780317', 's601111886'] | [2940.0, 2940.0] | [17.0, 17.0] | [111, 116] |
p03085 | u818068030 | 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 = map(str, 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')", "b = map(str, input())\n\nif(b == 'A'):\n print('T')\nelif(b == 'T'):\n print('A')\nelif(b == 'C'):\n print('G')\nelse:\n print('C')", "b = input()\n\... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s037123550', 's162465451', 's261090514'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 19.0] | [144, 134, 134] |
p03085 | u818778128 | 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=raw_input()\n\nif b in {'A','T'}:\n if b == 'A':\n print('T')\n else:\n print('A')\nelif b in {'G','C'}:\n if b == 'G':\n print('C')\n elif b=='C':\n print('G')", 'b=map(str.input())\nif b=="A":\n print("T")\nelif b="G":\n print("C")\nelif b=="T":\n print("A")\nelif b=="C"... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s347650018', 's549560272', 's882812517', 's254476850'] | [2940.0, 2940.0, 2940.0, 2940.0] | [18.0, 17.0, 19.0, 18.0] | [191, 120, 128, 128] |
p03085 | u820052258 | 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. | ["\na = input()\n\nif a == 'A':\n print('C')\nelif a == 'C':\n print('A')\nelif a == 'G':\n print('T')\nelse:\n print('G')\n", "a = input()\n\nif a == 'A':\n print('T')\nelif a == 'T':\n print('A')\nelif a == 'G':\n print('C')\nelse:\n print('G')"] | ['Wrong Answer', 'Accepted'] | ['s183152759', 's166093560'] | [2940.0, 2940.0] | [17.0, 17.0] | [123, 121] |
p03085 | u822725754 | 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 numpy as np\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nb = readline()\nif b == 'A':\n\tprint('T')\nelif b == 'T':\n\tprint('A')\nelif b == 'G':\n\tprint('C')\nelse:\n\tprint('G') \n", "import numpy as np\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nb = readline... | ['Wrong Answer', 'Accepted'] | ['s042222858', 's646475840'] | [12388.0, 21276.0] | [149.0, 353.0] | [196, 205] |
p03085 | u825378567 | 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()\nword_list=list(S)\nfor i in range(Q):\n count=0\n flag =0\n l,r=map(int,input().split())\n box=word_list[l-1:r]\n for i in box:\n if i == 'A':\n flag =1\n elif i!= 'C':\n flag=0\n if flag == 0 and i=='C':\n flag = 0\n if flag == 1 and i =='C':\n... | ['Runtime Error', 'Accepted'] | ['s304933835', 's174184076'] | [3064.0, 2940.0] | [17.0, 17.0] | [348, 122] |
p03085 | u825769322 | 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()\nans,pair = ['A','C','G','T'],['C','A','T','G']\nfor i,j in zip(ans,pair):\n if j == b:\n print(i)", "b = input()\nans,pair = ['A','C','G','T'],['T','G','C','A']\nfor i,j in zip(ans,pair):\n if j == b:\n print(i)"] | ['Wrong Answer', 'Accepted'] | ['s218266601', 's063895481'] | [2940.0, 2940.0] | [17.0, 18.0] | [116, 116] |
p03085 | u825981710 | 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")\nelse:\n print("G")\n', 'b=input()\n\nif(b=="A"):\n print("T")\nif(b=="C"):\n print("A")\nif(b=="G"):\n print("C") \nelse:\n print("G")\n', 'b=input()\n\nif(b=="A"):\n print("T")\nelif(b=="T"):\n print("A")\nelif(b=="G"):\n print("C")\nelse:\n prin... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s646536490', 's675964835', 's069198757'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [58, 117, 117] |
p03085 | u826557401 | 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 -*-\nNQ = input().split(" ")\nS = str(input())\nN = int(NQ[0])\nQ = int(NQ[1])\nresult_list = []\nl = 0\nr = 0\nlr = ""\nfor i in range(0, Q):\n lr = input().split(" ")\n l = int(lr[0])\n r = int(lr[1])\n subStr_S = str(S[l-1:r]).replace("G", "").replace("T", "")\n result_list.append(subStr_S... | ['Runtime Error', 'Accepted'] | ['s590997689', 's481856460'] | [3064.0, 2940.0] | [17.0, 16.0] | [360, 191] |
p03085 | u826986938 | 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 sys import stdin\n\nb = int(stdin.readline().rstrip()))\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')\n", "from sys import stdin\n\nb = stdin.readline().rstrip()\n\nif b == 'A':\n print('T')\nif b == 'T':\n print('A')\nif b == 'G':... | ['Runtime Error', 'Accepted'] | ['s436699403', 's384862997'] | [2940.0, 2940.0] | [17.0, 17.0] | [172, 165] |
p03085 | u835353642 | 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()\n\nb = {"A":"A", "C":"T", "G":"C", "T":"G"}\nprint ( b[a])', 'a = input()\n\nb = {"A":"T","T":"A","C":"G","G":"C"}\nprint ( b[a])'] | ['Wrong Answer', 'Accepted'] | ['s416637361', 's506373573'] | [2940.0, 2940.0] | [17.0, 17.0] | [67, 64] |
p03085 | u835482198 | 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()\na = ''\nfor i in range(4):\n if b[i] == 'A':\n a += 'T'\n elif b[i] == 'T':\n a += 'A'\n elif b[i] == 'C':\n a += 'G'\n elif b[i] == 'G':\n a += 'C'\nprint(a)\n", "b = input()\na = ''\nfor i in range(len(b)):\n if b[i] == 'A':\n a += 'T'\n elif b[i] ==... | ['Runtime Error', 'Accepted'] | ['s500848859', 's144211989'] | [2940.0, 2940.0] | [17.0, 17.0] | [201, 206] |
p03085 | u838772890 | 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'}\ntmp = input()\nprint(Dict(tmp))", "Dict = {'A':'T','C':'G','T':'A','G':'C'}\ntmp = input()\nprint(Dict[tmp])"] | ['Runtime Error', 'Accepted'] | ['s519485200', 's795721589'] | [2940.0, 2940.0] | [19.0, 17.0] | [71, 71] |
p03085 | u839857256 | 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\ninput = sys.stdin.readline\nb = input()\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')\n", "import sys\n\ninput = sys.stdin.readline\nb = input()\nif b[0] == 'A':\n print('T')\nelif b[0] == 'T':\n print('A')\nelif b[0] == 'C':\n... | ['Wrong Answer', 'Accepted'] | ['s784177138', 's805945470'] | [2940.0, 2940.0] | [17.0, 17.0] | [160, 169] |
p03085 | u845937249 | 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('T')\n \nelif n == 'T'\n print('A')\n \nelif n == 'C'\n print('G')\n \nelif n == 'G'\n print('C')\n\nelse:\n pass\n", "n = input()\n\nif n == 'A':\n print('T')\n \nelif n == 'T'\n print('A')\n \nelif n == 'C'\n print('G')\n \nelif n == 'G'\n print('C')\n\n", "n = inp... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s580550731', 's884911809', 's000127801'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0] | [143, 130, 134] |
p03085 | u846077493 | 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 k = input()\n if k == "A":\n print("C")\n if k == "C":\n print("A")\n if k == "T":\n print("G")\n if k == "G":\n print("T")\n\n\nif __name__ == "__main__":\n main()\n', 'def main():\n k = input()\n if k == "A":\n print("T")\n if k == "T":\n ... | ['Wrong Answer', 'Accepted'] | ['s137703105', 's141414107'] | [2940.0, 2940.0] | [17.0, 17.0] | [212, 212] |
p03085 | u848882989 | 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\narg = input()\n\nif arg=='A': arg='T'\nif arg=='T': arg='A'\nif arg=='C': arg='G'\nif arg=='G': arg='C'\n\nprint(arg)", "import sys\n\narg = input()\n\nif arg=='A':\n arg='T'\nelif arg=='T':\n arg='A'\nif arg=='C':\n arg='G'\nelif arg=='G':\n arg='C'\n\nprint(arg)"] | ['Wrong Answer', 'Accepted'] | ['s094931296', 's427100489'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 142] |
p03085 | u850390157 | 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()\nS = input()\nfor i in range(int(Q)):\n l, r = (int(x) for x in input().split())\n sub_S = S[l-1:r]\n count = 0\n print('hoge')", "b = input()\n\nif b ==\t'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'] | ['s722247883', 's792094523'] | [2940.0, 2940.0] | [17.0, 19.0] | [156, 129] |
p03085 | u854685063 | 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. | ['k = input()\nif k == "A":\n print("A")\nif k == "C":\n print("T")\nif k == "G":\n print("C")\nif k == "T":\n print("G")', 'k = input()\nif k == "A":\n print("T")\nif k == "C":\n print("G")\nif k == "G":\n print("C")\nif k == "T":\n print("A")\n'] | ['Wrong Answer', 'Accepted'] | ['s045505424', 's228831397'] | [9028.0, 9028.0] | [28.0, 24.0] | [115, 116] |
p03085 | u855866205 | 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()\ndata = []\nfor i in range(q):data.append(list(map(int, input().split())))\nfor i in data:print(len(s[i[0]-1:i[1]].split('AC'))-1)", "s = input()\nif s=='A':print('T')\nelif s=='T':print('A')\nelif s=='C':print('G')\nelif s=='G':print('C')"] | ['Runtime Error', 'Accepted'] | ['s522242432', 's789689594'] | [3060.0, 2940.0] | [17.0, 17.0] | [172, 101] |
p03085 | u857130525 | 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 sys import (stdin, stout)\n\nCORR_TAB = {\n 'A': 'T',\n 'T': 'A',\n 'G': 'C',\n 'C': 'G'',\n}\n\nfor line in stdin:\n stdout.write(CORR_TAB[line.strip()] + '\\n')", "from sys import (stdin, stdout)\n\nCORR_TAB = {\n 'A': 'T',\n 'T': 'A',\n 'G': 'C',\n 'C': 'G',\n}\n\nfor line in stdin:\n stdout.write(C... | ['Runtime Error', 'Accepted'] | ['s969708322', 's019116588'] | [2940.0, 2940.0] | [17.0, 17.0] | [161, 161] |
p03085 | u857330600 | 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=str(input())\nl=[]\nfor i in range(len(s)):\n if s[i]=='A':\n l.append('T')\n if s[i]=='T':\n l.append('A')\n if s[i]=='G':\n l.append('C')\n if l[i]=='C':\n l.append('G')\nprint(''.join(l))\n", "s=str(input())\nl=[]\nfor i in range(len(s)):\n if s[i]=='A':\n l.append('T')\n if s[i]=='T':\n ... | ['Runtime Error', 'Accepted'] | ['s147306478', 's923380512'] | [2940.0, 2940.0] | [17.0, 17.0] | [198, 198] |
p03085 | u857408368 | 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# print(S)\n# print(len(S))\nlist = []\nfor i in range(len(S)):\n if(S[i] == "A" or S[i] == "C" or S[i] == "G" or S[i] == "T"):\n list.append(i)\n# print(list)\nNUM = []\nfor j in range(len(list)):\n num = 1\n for k in range(j,len(list)-1):\n # print("k:",k)\n # print("list[... | ['Wrong Answer', 'Accepted'] | ['s072373252', 's605801137'] | [3064.0, 2940.0] | [17.0, 17.0] | [772, 141] |
p03085 | u857428111 | 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=ACGT\nj=0\nfor i in range(4):\n if a[i]==N:\n \tj=i \nprint(a[3-j])', 'N=input()\na="ACGT"\nj=0\nfor i in range(4):\n if a[i]==N:\n \tj=i \nprint(a[3-j])'] | ['Runtime Error', 'Accepted'] | ['s153202431', 's312340171'] | [2940.0, 2940.0] | [17.0, 17.0] | [76, 78] |
p03085 | u864047888 | 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")\nelse if a=="T":\n print("A")\nelse if a=="C":\n print("G")\nelse if a=="G":\n print("C")', 'a=input()\nif a=="A":\n print("T")\nelif a=="T":\n print("A")\nelif a=="C":\n print("G")\nelif a=="G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s690916239', 's100153724'] | [2940.0, 2940.0] | [17.0, 17.0] | [128, 119] |
p03085 | u870062840 | 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. | ["File Edit Options Buffers Tools Python Help \n# -*- coding: utf-8 -*- ... | ['Runtime Error', 'Accepted'] | ['s854616291', 's756146257'] | [2940.0, 2940.0] | [17.0, 17.0] | [527, 154] |
p03085 | u872887731 | 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 = list(map(int,input().split()))\nS = input()\nL = []\nR = []\nfor i in range(Q):\n a = list(map(int,input().split()))\n L.append(a[0])\n R.append(a[1])\n\nS_count = []\ncount = 0\nA_flag = False\n\nfor i in range(len(S)):\n if A_flag == True:\n if S[i] == "C" :\n count += 1\n ... | ['Runtime Error', 'Accepted'] | ['s467506633', 's729963771'] | [3064.0, 2940.0] | [17.0, 18.0] | [513, 120] |
p03085 | u873616440 | 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. | ['seq = input()\nseq_list = []\nfor char in seq :\n if char == "A":\n char2 = "T"\n elif char == "T":\n char2 = "A"\n elif char == "G":\n char2 = "C"\n elif char == "C":\n char2 = "G"\n seq_list.append(char2)\nreturn("".join(seq_list))', 'def main():\n seq = input()\n seq_li... | ['Runtime Error', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s005668144', 's061726048', 's310667197', 's517423451', 's626372765', 's888734949', 's382632851'] | [2940.0, 2940.0, 3060.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 19.0, 17.0, 17.0, 17.0, 17.0] | [264, 302, 261, 291, 264, 245, 161] |
p03085 | u875028418 | 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)\nlongest=0\nfor i in range(L):\n for j in range(i+1):\n DUP=S[j:i]\n DUP=DUP.replace("A","#")\n DUP=DUP.replace("T","#")\n DUP=DUP.replace("G","#")\n DUP=DUP.replace("C","#")\n count=0\n for a in range(len(DUP)):\n if DUP[a]=="#":\n count+=1\n else:\n ... | ['Runtime Error', 'Accepted'] | ['s236896492', 's711287921'] | [3064.0, 2940.0] | [17.0, 17.0] | [740, 80] |
p03085 | u877220920 | 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)\n\nfor i in range(N):\n t[i+1] = t[i] + (1 if S[i:i+2] == 'AC' else 0)\n\nfor i in range(Q):\n l,r = map(int, input().split())\n print(t[r-1] - t[l-1])\n", "basis = input()\nif basis == 'A':\n print('T')\nelif basis == 'T':\n print('A')\neli... | ['Runtime Error', 'Accepted'] | ['s021801673', 's147566016'] | [3060.0, 2940.0] | [17.0, 18.0] | [214, 150] |
p03085 | u882858304 | 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=='T' : print('G')\nelif b=='C' : print('T')\nelif b=='G' : print('C')\nelse : print('A')\n", "b=input()\nif b=='A' : print('T')\nelif b=='T' : print('A')\nelif b=='G' : print('C')\nelse : print('G')"] | ['Wrong Answer', 'Accepted'] | ['s051820923', 's750869068'] | [2940.0, 2940.0] | [17.0, 17.0] | [101, 100] |
p03085 | u883040023 | 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"]\nans = 0\nANS = [0]\n\nfor i in range(len(s)):\n if s[i] in ACGT:\n ans += 1\n else:\n ans = 0\n \n ANS.append(ans)\n \nprint(max(ANS))', 'print({"A":"T","C":"G","G":"C","T":"A"}[input()])'] | ['Wrong Answer', 'Accepted'] | ['s883484208', 's855495238'] | [2940.0, 2940.0] | [17.0, 17.0] | [197, 49] |
p03085 | u883149667 | 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 = T\nelif b == "T":\n ans = A\nelif b == "G":\n ans = C\nelse:\n ans = G\n \nprint(ans)', 'b = input()\n\nif b == "A":\n ans = "T"\nelif b == "T":\n ans = "A"\nelif b == "G":\n ans = "C"\nelse:\n ans = "G"\n \nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s098249429', 's053014066'] | [2940.0, 2940.0] | [17.0, 18.0] | [115, 123] |
p03085 | u888641025 | 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('aaa')\n", 'import sys\n\ninput_line = sys.stdin.readline()\n\nenki_map = {\n "A": "T",\n "T": "A",\n "G": "C",\n "C": "G",\n}\n\nprint(enki_map[input_line.strip()])'] | ['Wrong Answer', 'Accepted'] | ['s100023243', 's748531924'] | [2940.0, 3060.0] | [17.0, 19.0] | [13, 146] |
p03085 | u889914341 | 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. | ["m = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}\nprint(m[input())", "m = {'A':'T', 'T':'A', 'G':'C', 'C':'G'}\nprint(m[input()])"] | ['Runtime Error', 'Accepted'] | ['s679689235', 's979040596'] | [2940.0, 2940.0] | [17.0, 17.0] | [57, 58] |
p03085 | u890638336 | 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(\'A,C,G,T?:\')\n\nif b == "A":\n b_ = "T"\n print(b_)\nelif b == "T":\n b_ = "A"\n print(b_)\nelif b == "C":\n b_ = "G"\n print(b_)\nelse:\n b_ = "C"\n print(b_)', 'b = input()\n\nif b == "A":\n b_ = "T"\n print(b_)\nelif b == "T":\n b_ = "A"\n print(b_)\nelif b == "C":\n... | ['Wrong Answer', 'Accepted'] | ['s823216649', 's447535022'] | [2940.0, 2940.0] | [17.0, 17.0] | [180, 169] |
p03085 | u891482208 | 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 = b.replace('A', 'T')\nb = b.replace('T', 'A')\nb = b.replace('C', 'G')\nb = b.replace('G', 'C')\nprint(b)", "b = input()\nb.replace('A', 'T')\nb.replace('T', 'A')\nb.replace('C', 'G')\nb.replace('G', 'C')\nprint(b)", "print('ATCG'['ATCG'.index(input()) ^ 1])"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s265376339', 's482061532', 's715048608'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [116, 100, 40] |
p03085 | u894839777 | 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. | ['#include<bits/stdc++.h>\nusing namespace std;\nint main(){\n\tchar a;\n\tcin>>a;\n\tswitch(a){\n\t\tcase "A":cout<<"T"<<endl;\n\t\tcase "T":cout<<"A"<<endl;\n\t\tcase "C":cout<<"G"<<endl;\n\t\tcase "G":cout<<"C"<<endl;\n\t}\n\treturn 0;\n}\n', '#include<bits/stdc++.h>\nusing namespace std;\nint main(){\n\tchar a;\n\t... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s364653787', 's884132207', 's666080209'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 18.0] | [215, 239, 75] |
p03085 | u896741788 | 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().lower().replace("a","T").replace("t","A")replace("c","G")replace("g","C"))', 'print({"A":"T","T":"A","G":"C","C":"G"}[input()])'] | ['Runtime Error', 'Accepted'] | ['s316299690', 's703476956'] | [2940.0, 2940.0] | [17.0, 17.0] | [88, 49] |
p03085 | u899929023 | 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())\n2 S = input()\n3 t = [0] * (N + 1)\n4 for i in range(N):\n5 t[i + 1] = t[i] + (1 if S[i : i + 2] == 'AC' else 0)\n6 for i in range(Q):\n7 l, r = map(int, input().split())\n8 print(t[r-1] - t[l-1])", "import numpy as np\n\ns=input()\n\nif s=='A':\n print('T')\n\nif s=='T':\n pri... | ['Runtime Error', 'Accepted'] | ['s108155890', 's907050809'] | [2940.0, 21892.0] | [17.0, 1820.0] | [223, 138] |
p03085 | u902380746 | 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\nimport math\nimport bisect\n\ndef main():\n s = input()\n if s == \'A\':\n print(\'T\')\n elif s == \'C\':\n print(\'G\')\n elif s == \'G\'\n print(\'C\')\n elif s == \'T\':\n print(\'A\')\n \nif __name__ == "__main__":\n main()\n', 'import sys\nimport math... | ['Runtime Error', 'Accepted'] | ['s624791621', 's981332698'] | [2940.0, 3060.0] | [17.0, 17.0] | [258, 259] |
p03085 | u902973687 | 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 = {'A':'A', 'C':'T', 'G':'C', 'T':'G'}\n\nb = int(input())\nprint(base[b])\n", "base = {'A':'A', 'C':'T', 'G':'C', 'T':'G'}\n \nb = input()\nprint(base[b])", "base = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}\n \nb = input()\nprint(base[b])"] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s373664293', 's897921301', 's749666632'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [77, 72, 72] |
p03085 | u903948194 | 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 re\n\nS = input()\nlmax = 0\n\nfor i in range(len(S)):\n for j in range(i, len(S)):\n ss = S[i:j+1]\n l = re.findall(r'[^ACGT]', ss)\n if len(l) == 0:\n lmax = max(lmax, len(ss))\n else:\n continue\nprint(lmax) ", "b = input()\n\nif b == 'A':\n ans = 'T'\... | ['Wrong Answer', 'Accepted'] | ['s940890180', 's858188969'] | [3188.0, 2940.0] | [19.0, 17.0] | [258, 137] |
p03085 | u904943473 | 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())\nstr = input()\nfor i in range(q):\n l,r = map(int, input().split())\n sub_str = str[(l-1):r]\n count = 0\n for j in range(len(sub_str)):\n if (sub_str[j:j+2] == 'AC'):\n count += 1\n print(count)", "b = input()\n \nif (b == 'A'):\n print('T')\nelif (b == 'T'):\n print('... | ['Runtime Error', 'Accepted'] | ['s257903150', 's243176305'] | [3064.0, 2940.0] | [17.0, 17.0] | [232, 131] |
p03085 | u905850328 | 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()\nX = ['A', 'T']\nY = ['G', 'C']\nprint(str(X - b) if b in X else str(Y - b))", "b = input()\nX = {'A', 'T'}\nY = {'G', 'C'}\nprint(''.join(X - {b}) if b in X else ''.join(Y - {b}))"] | ['Runtime Error', 'Accepted'] | ['s459864008', 's034440861'] | [2940.0, 2940.0] | [17.0, 17.0] | [85, 97] |
p03085 | u907468986 | 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. | ['c = input()\n\np = {}\np["A"] = "A"\np["C"] = "T"\np["G"] = "C"\np["T"] = "G"\n\nprint(p[c])', 'c = input()\n\np = {}\np["A"] = "T"\np["G"] = "C"\np["T"] = "A"\np["C"] = "G"\n\nprint(p[c])'] | ['Wrong Answer', 'Accepted'] | ['s596024845', 's498516381'] | [2940.0, 2940.0] | [18.0, 18.0] | [84, 84] |
p03085 | u908349502 | 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()\ncount = 0\nx = [0]\n\nfor i in S:\n if i in ('A','C','G','T'):\n count += 1\n else:\n x.append(count)\n count = 0\nx.append(count)\n\nprint(max(x))", "import re\nN, Q = map(int,input().split())\nS = input()\n\nfor i in range(Q):\n l, r = map(int,input().split())\n Si = S[l-1:r]\n \n m = re... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s034930734', 's255807447', 's637172382'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0] | [159, 173, 112] |
p03085 | u910756197 | 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 == "G":\n print("C")\nelif b == "C":\n print("G")\nelse b == "T":\n print("A")\n ', 'b = input()\nif b == "A":\n print("T")\nelif b == "G":\n print("C")\nelif b == "C":\n print("G")\nelse:\n print("A")\n \n'] | ['Runtime Error', 'Accepted'] | ['s242977336', 's847693067'] | [2940.0, 2940.0] | [17.0, 17.0] | [124, 116] |
p03085 | u912158215 | 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()\nmaxlength = 0\nlength = 0\nfor i in S:\n if i in 'ATGC':\n length += 1\n else:\n length =0\n maxlength = max(maxlength, length)\nprint (maxlength)", 'b = input()\nDNA = {"A":"T","T":"A","C":"G","G":"C"}\nprint (DNA[b])'] | ['Wrong Answer', 'Accepted'] | ['s371634759', 's960299614'] | [2940.0, 2940.0] | [18.0, 17.0] | [159, 66] |
p03085 | u913662443 | 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().rstrip()\nd = {'A':'A','C':'T','G':'C','T':'G'}\nprint(d[S])", "S = input().rstrip()\nd = {'A':'T','C':'G','G':'C','T':'A'}\nprint(d[S])"] | ['Wrong Answer', 'Accepted'] | ['s912838324', 's451251354'] | [2940.0, 2940.0] | [17.0, 17.0] | [70, 70] |
p03085 | u914330401 | 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("G")\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 b == \'C\':\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s922041527', 's606381460'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 121] |
p03085 | u914773681 | 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 b = input()\n argc = len(b)\n data = []\n for i in range(argc):\n if (b[i]=='A'):\n data.append('T')\n elif (b[i]=='T'):\n data.append('A')\n elif (b[i]=='C'):\n data.append('G')\n else:\n data.append('C')\n print(data)\nmain()\n", "def main... | ['Wrong Answer', 'Accepted'] | ['s874525053', 's363110989'] | [2940.0, 3060.0] | [17.0, 18.0] | [291, 340] |
p03085 | u914797917 | 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 \nelif b=='G':\n print(C')\n \nelif b=='T':\n print('A')\nelif b=='C':\n print('G') ", "b = input()\n\nif b=='A':\n print('G')\nelif b=='G':\n print('A')\nelif b=='T':\n print('C')\nelif b=='C':\n print('T') ", "b = input()\n\nif b=='A':\n print('T')\n \nelif b=='G... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s305534611', 's539853346', 's691858720'] | [2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0] | [120, 115, 121] |
p03085 | u917733926 | 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. | ['tmp = input()\n\nout_1 = 0\ntmp_s = []\nfor c in tmp:\n if c == "A" or c == "G" or c == "T" or c == "C":\n tmp_s.append(c)\n else:\n if out_1 < len(tmp_s):\n out_1 = len(tmp_s)\n tmp_s = []\nprint(out_1)', 'tmp = input()\n\nif tmp == "A... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s291984250', 's502565976', 's321230744'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [274, 65, 130] |
p03085 | u918123058 | 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 a='T'\nelif b=='T':\n a='A':\nelif b=='C':\n a='G':\nelse:\n a='C'\n print(a)", "b=input()\nif b=='A':\n a='T'\nelif b=='T':\n a='A'\nelif b=='C':\n a='G'\nelse:\n a='C'\nprint(a)"] | ['Runtime Error', 'Accepted'] | ['s320932849', 's416509773'] | [2940.0, 2940.0] | [17.0, 18.0] | [96, 101] |
p03085 | u918601425 | 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()\nif X=="A":\n print("T")\nelif X="T":\n print("A")\nelif X="G":\n print("C")\nelse:\n print("G")', 'X=input()\nif X=="A":\n print("T")\nelif X=="T":\n print("A")\nelif X=="G":\n print("C")\nelse:\n print("G")\n'] | ['Runtime Error', 'Accepted'] | ['s993332414', 's571458284'] | [2940.0, 2940.0] | [17.0, 17.0] | [102, 105] |
p03085 | u921632705 | 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 = int(input())\nif X == "A":\n \tprint("T")\nelif X == "T":\n \tprint("A")\nelif X == "C":\n \tprint("G")\nelse:\n\tprint("C")', 'X = int(input())\nif X = "A":\n \tprint("T")\nelif X = "T":\n \tprint("A")\nelif X = "C":\n \tprint("G")\nelse:\n\tprint("C")\n ', 'X = int(input())\nif X == "A":\n \tprint("T"... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s351302037', 's433307967', 's499762766', 's722679770', 's619760441'] | [8976.0, 8852.0, 9088.0, 8836.0, 8876.0] | [24.0, 22.0, 27.0, 25.0, 22.0] | [119, 121, 128, 113, 123] |
p03085 | u921830178 | 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 set="set_A"\nif S=="C":\n set="set_C"\nif S=="G":\n set="set_G"\nif S=="T":\n set="set_T"\n\nif set == "set_A":\n ans = "A"\nif set == "set_C":\n ans = "T"\nif set == "set_G":\n ans = "C"\nif set == "set_T":\n ans = "G"\nprint(ans) ', 'S = input()\nif S=="A":\n ... | ['Wrong Answer', 'Accepted'] | ['s041103404', 's777159713'] | [3060.0, 3064.0] | [17.0, 17.0] | [267, 265] |
p03085 | u922416423 | 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 = str(input())\n\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 = str(input())\n\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'G':\n print('C')\nelif b == 'C':\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s442937116', 's890919876'] | [2940.0, 2940.0] | [17.0, 17.0] | [121, 135] |
p03085 | u923105140 | 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")\nelse:\n print("C")\n ', 's = list(input())\n\nL = []\ncnt = 0\n\nfor x in s:\n if x == "A" or x == "C" or x == "G" or x == "T":\n cnt += 1\n else:\n L.append(cnt)\n cnt = 0\nL.append(cnt)\n\nprin... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s252375328', 's564401980', 's998556581'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [107, 193, 110] |
p03085 | u924308178 | 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\nlength,question = map(int, input().split())\nstring = input()\ne = [[int(i) for i in input().split()] for i in range(question)]\nc = 0\ntmp = []\n\nfor i in e:\n s = \'\'\n for j in range(i[0],i[1]+1):\n s+=string[j-1]\n \n for n in range(len(s)):\n if s[n:n+2] == "AC":\n ... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s287785214', 's661140637', 's636581667'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [340, 129, 129] |
p03085 | u928784113 | 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")\nelse b == "G":\n print("C")\nelse:\n print("G")', 'b = input()\nL = [["A","T"],["C","G"]]\nfor i in range(2):\n if b in L[i]:\n if L[i][0] == b:\n print(L[i][1])\n else:\n print(L[i][0])'] | ['Runtime Error', 'Accepted'] | ['s184599118', 's309773622'] | [2940.0, 2940.0] | [17.0, 17.0] | [120, 167] |
p03085 | u934099192 | 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())\n\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()\n\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'G':\n print('C')\nelif b == 'C':\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s828227620', 's966097955'] | [2940.0, 2940.0] | [17.0, 17.0] | [135, 130] |
p03085 | u934442292 | 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\ninput = sys.stdin.readline\n\n\ndef main():\n b = input().rstrip()\n\n if b == "A":\n ans = "C"\n elif b == "C":\n ans = "A"\n elif b == "G":\n ans = "T"\n else:\n ans = "G"\n\n print(ans)\n\n\nif __name__ == "__main__":\n main()\n', 'import sys\n\ninput ... | ['Wrong Answer', 'Accepted'] | ['s498124781', 's168173274'] | [9020.0, 9100.0] | [27.0, 26.0] | [272, 272] |
p03085 | u937132382 | 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()\n\nif a="A" or "T":\n if a=="T":\n b="A"\n if a=="A":\n b="T"\n\nif a="C" or "G":\n if a=="C":\n b="G"\n if a=="G":\n b="C"\n\nprint(b)', 'a=input()\n\nif a=="A" or "T":\n if a=="T":\n b="A"\n if a=="A":\n b="T"\n\nif a=="C" or "G":\n if a=="C":... | ['Runtime Error', 'Accepted'] | ['s026347669', 's813262894'] | [2940.0, 2940.0] | [17.0, 18.0] | [171, 173] |
p03085 | u940279019 | 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()\ngene = ['A','T','C','G']\n\nlength = len(S)\nans = 0\ntmp = 0\n\nfor i in range(length):\n if S[i] in gene:\n tmp += 1\n else:\n tmp = 0\n if tmp >= ans:\n ans = tmp\nprint(ans)", 'b = input()\nif(b == "A"):\n print("T")\nelif(b == "T"):\n print("A")\nelif(b == "C"):\n print("G"):\nelse:\n... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s739227256', 's955078117', 's047901129'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [188, 116, 115] |
p03085 | u941284420 | 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=str(input)\nif b=="T":\n b="A"\nelif b=="A":\n b="T"\nelif b=="G":\n b="C"\nelif b=="C":\n b="G"\nprint(b)', 'b=str(input)\nif b=="T":\n b="A"\nelif b=="A":\n b="T"\nelif b=="G":\n b="C"\nelif b=="C":\n b="G"\n', 'b=str(input())\nif b=="T":\n b="A"\nelif b=="A":\n b="T"\nelif b=="G":\n b="C"\nelif b=="C"... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s477351353', 's477493237', 's090806241'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [103, 95, 105] |
p03085 | u943314973 | 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)\n', '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'] | ['s835002771', 's294590469'] | [9012.0, 8900.0] | [24.0, 32.0] | [96, 113] |
p03085 | u945181840 | 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 = 'C'\nelif b == 'C':\n b = 'A'\nelif b == 'G':\n b = 'T'\nelif b == 'T':\n b = 'G'\n\nprint(b)", "b = input()\n\nif b == 'A':\n b = 'T'\nelif b == 'C':\n b = 'G'\nelif b == 'T':\n b = 'A'\nelif b == 'G':\n b = 'C'\n\nprint(b)"] | ['Wrong Answer', 'Accepted'] | ['s081943575', 's572927175'] | [2940.0, 2940.0] | [17.0, 17.0] | [128, 128] |
p03085 | u945405878 | 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. | ['\ns = input()\nif s == \'A\':\n ans = \'T\'\nelif s== \'T\':\n ans = \'A\'\nelif s == \'G\':\n ans = \'C\'\nelif s == \'C\':\n ans = \'G\'\nelse:\n print("error")', "s = input()\nif s == 'A':\n print('C')\nelif s== 'C':\n print('A')\nelif s == G:\n print('T')\nelse:\n print('G')", 's = inpu... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s182365802', 's218084982', 's796801653'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [150, 117, 165] |
p03085 | u948212056 | 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 = input()\n if b = 'A':\n print ('T')\n elif b = 'T':\n\tprint ('A')\n elif b = 'G':\n\tprint ('C')\n else:\n print ('G')", "if __name__ == '__main__':\n b = input()\n if b == 'A':\n print('T')\n elif b == 'T':\n print('A')\n elif b == 'G':\n print('C')\n elif b... | ['Runtime Error', 'Accepted'] | ['s317805709', 's385964365'] | [2940.0, 2940.0] | [17.0, 17.0] | [152, 166] |
p03085 | u957513998 | 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({'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}[input()])", "print({'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}[input()])"] | ['Runtime Error', 'Accepted'] | ['s972547957', 's870111143'] | [2940.0, 2940.0] | [17.0, 18.0] | [58, 56] |
p03085 | u957957759 | 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')\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'] | ['s907068287', 's980957789'] | [2940.0, 2940.0] | [16.0, 17.0] | [109, 112] |
p03085 | u959651981 | 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 = ["A":"T","G":"C","C":"G","T":"A"]\nprint(d[input()])', "d = {'A':'T','T':'A','G':'C','C':'G'}\nprint(d[input()])\n"] | ['Runtime Error', 'Accepted'] | ['s659700329', 's247088894'] | [2940.0, 2940.0] | [17.0, 19.0] | [55, 56] |
p03085 | u960171798 | 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()\nif x = "A":\n print("T")\nelif x = "T":\n print("A")\nelif x = "C":\n print("D")\nelse x = "D":\n print("C")', 'b = input()\nif b = "A":\n print("T")\nelif b = "T":\n print("A")\nelif b = "C":\n print("D")\nelse:\n print("C")', 'b = input()\nif b == "A":\n print("T")\nelif b == "T":\n print("A"... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s246261835', 's343530081', 's419733494', 's527359481', 's790758179', 's921695460', 's051963633'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 17.0, 18.0] | [117, 109, 121, 117, 117, 138, 87] |
p03085 | u960570220 | 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\nb = input()\n\nif b == ('A'):\n print(T)\n\nelif b == ('C'):\n print(G)\n\nelif b == ('T'):\n print(A)\n\nelif b == ('G'):\n print(C)\n", "\n\nb = input()\n\nif b == ('A'):\n print(T)\n\nif b == ('C'):\n print(G)\n\nif b == ('T'):\n print(A)\n\nif b == ('G'):\n print(C)", "\n\nb = input()\... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s920318829', 's945615571', 's903054211'] | [8660.0, 9104.0, 8976.0] | [26.0, 26.0, 25.0] | [207, 200, 208] |
p03085 | u962942039 | 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"\nelse if b == "T":\n b = "A"\nelse if b == "C":\n b = "G"\nelse if b == "G":\n b = "C"\nprint(b)', 'b = input()\nif b[i] == "A":\n b[i] = "T"\nelse if b[i] == "T":\n b[i] = "A"\nelse if b[i] == "C":\n b[i] = "G"\nelse if b[i] == "G":\n b[i] = "C"\nprint(b)', 'b = input()\nf... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s115251855', 's631563537', 's696724152', 's860066532', 's157315566'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 18.0, 17.0] | [127, 151, 179, 164, 118] |
p03085 | u965602776 | 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 = {"A": "C", "C": "A", "G": "T", "T": "G"}\nprint(D[input()])', 'D = {"A": "T", "T": "A", "C": "G", "G": "C"}\nprint(D[input()])'] | ['Wrong Answer', 'Accepted'] | ['s764277477', 's427173756'] | [2940.0, 2940.0] | [17.0, 17.0] | [62, 62] |
p03085 | u967835038 | 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 = str(input())\nif n == 'A':\n print('A')\nelif n == 'C':\n print('T')\nelif n == 'G':\n print('C')\nelse:\n print('G')\n", "n = str(input())\nif n == 'A':\n print('T')\nelif n == 'C':\n print('G')\nelif n == 'G':\n print('C')\nelse:\n print('A')\n"] | ['Wrong Answer', 'Accepted'] | ['s429249023', 's129421917'] | [2940.0, 2940.0] | [17.0, 17.0] | [126, 126] |
p03085 | u969190727 | 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" else "A" if B="T" else "G" if B="C" else "C" if B="G")', 'b=input()\nprint("T" if B=="A" else "A" if B=="T" else "G" if B=="C" else "C" if B=="G")\n', 'S=input()\nSS=S+"X"\nACGT=["A","C","G","T"]\nm=0\nfor i in range(len(S)):\n j=0\n while SS[i+j] in ACGT:\n j+=1 \n m=max(m,j)\np... | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s308199864', 's595878657', 's913434053', 's962383381', 's647474216'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0, 17.0, 17.0] | [83, 88, 134, 88, 77] |
p03085 | u970002663 | 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\n\ncount = 0\nmax = 0\nfor i in range(len(s)):\n if s[i] == "A" or s[i] == "G" or s[i] == "T" or s[i] == "C":\n count += 1\n if (i == len(s)-1) and (max < count):\n max = count\n else:\n if max < count:\n max = count\n count... | ['Wrong Answer', 'Accepted'] | ['s469294926', 's721625740'] | [3060.0, 2940.0] | [17.0, 17.0] | [318, 154] |
p03085 | u970809473 | 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 = "C":\n print("G")\nelif s = "G":\n print("C")\nelif s = "T":\n print("A")', 's = input()\nif s == "A":\n print("T")\nelif s == "C":\n print("G")\nelif s == "G":\n print("C")\nelif s == "T":\n print("A")'] | ['Runtime Error', 'Accepted'] | ['s358625555', 's630509532'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 121] |
p03085 | u970899068 | 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())\n\nif input()==A:\n print('T')\nelif input()==T:\n print('A')\nelif input()==C:\n print('G')\nelse:\n print('C')", 'n = int(input())\nmod = 10**9+7\n \ndp = [[[[0]*4 for _ in range(4)] for _ in range(4)] for _ in range(n+1)]\n\n\n\ndp[0][3][3][3] = 1\n \n\n#A:=0,G:=1,C:=2,T:=3\n \n\nfor i in range(... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s132609480', 's571331962', 's508002722'] | [2940.0, 3444.0, 2940.0] | [17.0, 20.0, 17.0] | [122, 1668, 112] |
p03085 | u972892985 | 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())\n\nif b == A:\n print("T")\nelif b == T:\n print("A")\nelif b == G:\n print("C")\nelse:\n print("G")', 'ソースコード \n\nCopy\nCopy\nb = int(input())\n \nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelse:\n print("G")', 'b = int(input())\n \nif b == "A":\n p... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s679640589', 's751607201', 's888117970', 's113010460'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [112, 150, 119, 114] |
p03085 | u977605150 | 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 = int(input())\n\nif s == 'A':\n print('T')\nelif s == 'T':\n print('A')\nelif s == 'G':\n print('C')\nelif s == 'C':\n print('G')", "s = input()\n\nif s == 'A':\n print('T')\nelif s == 'T':\n print('A')\nelif s == 'G':\n print('C')\nelif s == 'C':\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s761897649', 's728983645'] | [9108.0, 9100.0] | [20.0, 27.0] | [135, 130] |
p03085 | u979060189 | 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 = str(input())\nlists = list(list(map(int, input().split())) for i in range(q))\nAC_index = []\ncounter = 0\n\nfor i in range(n-1):\n if s[i] + s[i+1] == 'AC':\n AC_index.append(i)\n\nfor i in range(q):\n l, r = (lists[i][0]-1), (lists[i][1]-1)\n for j in AC_index:\... | ['Runtime Error', 'Accepted'] | ['s906063055', 's548188860'] | [3064.0, 2940.0] | [20.0, 17.0] | [392, 101] |
p03085 | u981002188 | 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")\neif b == "G":\n print("C")\nelse:\n print("G")', 'b = input()\n\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'] | ['s352489066', 's204206531'] | [2940.0, 2940.0] | [18.0, 17.0] | [120, 121] |
p03085 | u981853376 | 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')\n"] | ['Runtime Error', 'Accepted'] | ['s563255218', 's471115500'] | [2940.0, 2940.0] | [17.0, 17.0] | [101, 113] |
p03085 | u982198202 | 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()\ndic = {'A':'T', 'C':'G'}\n\ns = dic.get(b)\nif s == None:\n if b == 'T':\n print('A')\n else:\n print('C')\n", "b = input()\ndic = {'A':'T', 'C':'G'}\n\ns = dic.get(b)\nif s == None:\n if b == 'T':\n print('A')\n else:\n print('C')\nelse:\n print(s)"] | ['Wrong Answer', 'Accepted'] | ['s502885299', 's394951911'] | [2940.0, 2940.0] | [17.0, 17.0] | [132, 150] |
p03085 | u982762220 | 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('C')\nelif s == 'C':\n print('A')\nelif s == 'G':\n print('T')\nelse:\n print('G')\n\n", "s = input()\n\nif s == 'A':\n print('T')\nelif s == 'C':\n print('G')\nelif s == 'G':\n print('C')\nelse:\n print('A')\n\n"] | ['Wrong Answer', 'Accepted'] | ['s262697430', 's999569111'] | [2940.0, 2940.0] | [17.0, 17.0] | [123, 123] |
p03085 | u987170100 | 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()\ncurrent = 0\nret = 0\nfor x in S:\n if x in 'ACGT':\n current += 1\n ret = max(ret, current) \n else:\n current = 0\nprint(ret) ", "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') "] | ['Wrong Answer', 'Accepted'] | ['s179261809', 's772592778'] | [2940.0, 2940.0] | [17.0, 20.0] | [167, 123] |
p03085 | u988004923 | 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 = list(map(int, input().split()))\ns = input()\nfor i in range(q):\n l, r = list(map(int, input().split()))\n print(len(s[l - 1:r].split("AC")) - 1)\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")'] | ['Runtime Error', 'Accepted'] | ['s206834509', 's226983458'] | [2940.0, 2940.0] | [17.0, 18.0] | [156, 113] |
p03085 | u989326345 | 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=str(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=str(input())\nif b=='A':\n print('T')\nelif b=='C':\n print('G')\nelif b=='G':\n print('C')\nelse:\n print('A')\n"] | ['Wrong Answer', 'Accepted'] | ['s619151373', 's419794306'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 118] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.