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 | u600261652 | 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 "G" if b=="C" else "C")', 'b = input()\nprint("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")'] | ['Runtime Error', 'Accepted'] | ['s667938129', 's539855095'] | [2940.0, 2940.0] | [17.0, 17.0] | [84, 79] |
p03085 | u607072045 | 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\tprint('T')\nelse if s == 'T':\n\tprint('A')\nelse if s == 'G':\n\tprint('C')\nelse if s == 'C':\n\tprint('G')", "s = input()\nif s == 'A':\n\tprint('T')\nelif s == 'T':\n print('A')\nelif s == 'G':\n\tprint('C')\nelif s == 'C':\n\tprint('G')"] | ['Runtime Error', 'Accepted'] | ['s656311075', 's046931709'] | [2940.0, 2940.0] | [17.0, 17.0] | [126, 120] |
p03085 | u608327706 | 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\tprint("T")\nelif b == "C":\n\tprint("G")\nelif b == "G":\n\tprint("C")\nelse:\n\tprint("A")\n', 'b = input()\n\nif b == "A":\n\tprint("T")\nelif b == "C":\n\tprint("G")\nelif b == "G":\n\tprint("C")\nelse:\n\tprint("A")\n'] | ['Runtime Error', 'Accepted'] | ['s333086575', 's109873610'] | [2940.0, 2940.0] | [18.0, 18.0] | [115, 110] |
p03085 | u609814378 | 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("C")\nelif b == C:\n print("G")\nelif b == G:\n print("C")\n', 'b = input()\n\nif b==A:\n print("T")\nelif b==T:\n print("C")\nelif b==C:\n print("G")\nelif b==G:\n print("C")', 'S = input()\nACGT = ["A","C","G","T"]\n\nans = 0 \nans... | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s026510718', 's656454945', 's821866209', 's508487285'] | [2940.0, 2940.0, 3060.0, 2940.0] | [17.0, 17.0, 19.0, 18.0] | [123, 114, 265, 131] |
p03085 | u612635771 | 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==T else "T" if b==A else "G" if b==C else "C")', 'b = input()\nprint("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")'] | ['Runtime Error', 'Accepted'] | ['s253985684', 's724838673'] | [8964.0, 8816.0] | [19.0, 23.0] | [73, 79] |
p03085 | u617037231 | 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')\nif S == 'T':\n print('A')\nif S == 'G':\n print('C')\nelse:\n print('G')\n ", "S = input()\nif S == 'A':\n print('T')\nif S == 'T':\n print('A')\nif S == 'G':\n print('C')\nif S == 'C':\n print('G')"] | ['Wrong Answer', 'Accepted'] | ['s737299671', 's783331955'] | [2940.0, 2940.0] | [17.0, 18.0] | [114, 115] |
p03085 | u620480037 | 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("C")\nelif b=="C":\n print("A")\nelif b=="G":\n print("T")\nelif b=="T":\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")'] | ['Wrong Answer', 'Accepted'] | ['s615901323', 's243762418'] | [3060.0, 2940.0] | [19.0, 17.0] | [120, 120] |
p03085 | u620846115 | 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 = "T" else "T" if a ="A" else "G" if a ="C" else "C")', 'a = input()\nprint("A" if a =="T" else "T" if a =="A" else "G" if a =="C" else "C")'] | ['Runtime Error', 'Accepted'] | ['s342287751', 's909356228'] | [8880.0, 9008.0] | [19.0, 23.0] | [80, 82] |
p03085 | u621100542 | 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# Your code here!\nN,Q = map(int,input().split())\nS = input()\np = set()\nfor n,i in enumerate(S[:-1]):\n if i == "A" and S[n+1]=="C":\n p.add(n)\n#print(p)\nfor i in range(Q):\n a,b = map(int,input().split())\n #tmp = {}\n \n # print(tmp)\n # print(len(tmp&p))\n count=0\... | ['Runtime Error', 'Accepted'] | ['s711686577', 's889999837'] | [3060.0, 2940.0] | [17.0, 17.0] | [484, 121] |
p03085 | u621717057 | 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. | ["code = input()\nif code = 'A':\n\tprint('T')\nelif code = 'T':\n\tprint('A')\nelif code = 'G':\n\tprint('C')\nelif code = 'C':\n\tprint('G')\n", "code = input()\nif code = 'A':\n\tprint('T')\nelif code = 'T':\n print('A')\nelif code = 'G':\n print('C')\nelif code = 'C':\n print('G')\n", "code = str(input())\... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s341204946', 's437944549', 's439325049', 's943190638'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [129, 138, 142, 142] |
p03085 | u623687794 | 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. | ['array = [A,T,G,C]\nb = input()\nif b == array[0]:\n print (array[1])\nelif b == array[1]:\n print (array[0])\nelif b == array[2]:\n print (array[3])\nelse:\n print (array[2])', 'b = input()\nif b == "T":\n print "A"\nelif b == "A":\n print "T"\nelif b == "G":\n print "C"\nelse:\n print "G"', 'b = input()\nif ... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s036722855', 's088104900', 's368929155', 's959489907'] | [2940.0, 2940.0, 2940.0, 2940.0] | [18.0, 17.0, 16.0, 17.0] | [169, 108, 94, 177] |
p03085 | u625729943 | 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 = input().split()\nN = int(N)\nQ = int(Q)\nS=str(input())\n\nfor i in range(Q):\n l, r = input().split()\n l = int(l)\n r = int(r)\n print(S.count("AC", l-1, r))', 'b=str(input())\nif b=="A": print("T")\nelif b=="T": print("A")\nelif b=="C": print("G")\nelse: print("C")'] | ['Runtime Error', 'Accepted'] | ['s918284802', 's091705201'] | [3316.0, 2940.0] | [22.0, 17.0] | [171, 101] |
p03085 | u625963200 | 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\ninput = sys.stdin.readline\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 print('C')\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')\n"] | ['Wrong Answer', 'Accepted'] | ['s883349504', 's218171401'] | [2940.0, 2940.0] | [17.0, 17.0] | [151, 113] |
p03085 | u626337957 | 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\nbases = ['A', 'C', 'G', 'T']\n\nfor idx, base in enumerate(bases):\n if base == b:\n print(bases[int(~bin(idx))])", "b = input()\n\nbases = ('A', 'C', 'G', 'T')\n\nfor idx, base in enumerate(bases):\n if base == b:\n print(bases[int(~bin(idx))])\n break\n", "b = input()\n\nbases = ('A', 'C',... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s694760150', 's793655198', 's792339314'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [126, 137, 133] |
p03085 | u626684023 | 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()\nltrs = "ACGT"\ncurr_max = 0\ncurr_len = 0\nfor ltr in S:\n if ltr in ltrs:\n curr_len += 1\n else:\n curr_max = max(curr_max, curr_len)\n curr_len = 0\nprint(max(curr_len, curr_max))', 'b = input()\nstars = {"A": "T", "T": "A", "C": "G", "G": "C"}\nprint("{}".format(stars[b]))\... | ['Wrong Answer', 'Accepted'] | ['s469655830', 's698687120'] | [2940.0, 3064.0] | [17.0, 17.0] | [212, 90] |
p03085 | u629246993 | 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'] | ['s185335786', 's830780298'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 124] |
p03085 | u631712362 | 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()\nlongest_acgt = 0\n\ndef is_acgt(string):\n a_count = string.count("A")\n c_count = string.count("C")\n g_count = string.count("G")\n t_count = string.count("T")\n acgt_count = a_count + c_count + g_count + t_count\n string_count = len(string)\n if acgt_count == string_count:\n ... | ['Wrong Answer', 'Accepted'] | ['s988622196', 's122854243'] | [3064.0, 2940.0] | [18.0, 18.0] | [666, 117] |
p03085 | u631907864 | 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 = []\nfor i in S:\n l.append(i)\n\nc = 0\ncnt = []\nfor j in range(len(l)):\n if l[j] == 'A' or l[j] == 'T' or l[j] == 'C' or l[j] == 'G':\n c+=1\n cnt.append(c)\n else:\n cnt.append(c)\n c = 0\n\n#print(cnt)\nprint(max(cnt))", "b = input()\nif b == 'A':\n print(... | ['Wrong Answer', 'Accepted'] | ['s060631468', 's461653372'] | [3060.0, 2940.0] | [17.0, 17.0] | [261, 129] |
p03085 | u633355062 | 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. | ["acid = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}\nc = input()\nprint(acid(c))", "acid = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}\nc = input()\nprint(acid[c])"] | ['Runtime Error', 'Accepted'] | ['s709823730', 's952744158'] | [2940.0, 2940.0] | [19.0, 19.0] | [74, 74] |
p03085 | u641460756 | 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', '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', 'a=inp... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s103149385', 's514350379', 's586929735', 's688205289', 's760397359', 's328140817'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 18.0, 17.0] | [87, 97, 91, 91, 97, 129] |
p03085 | u642120132 | 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 == 'T' else 'T' if b == 'A' else 'C' if b == 'G' else 'G' if b == 'C')", "b = input()\nprint('A' if b == 'T' else 'T' if b == 'A' else 'C' if b == 'G' else 'G')"] | ['Runtime Error', 'Accepted'] | ['s995837226', 's722932800'] | [2940.0, 2940.0] | [18.0, 17.0] | [97, 85] |
p03085 | u642418876 | 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("T")\nelif b="C":\n print("G")\nelif b="G":\n print("C")\nelse:\n print("A")\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 '] | ['Runtime Error', 'Accepted'] | ['s415116647', 's308874821'] | [2940.0, 2940.0] | [17.0, 18.0] | [109, 112] |
p03085 | u642874916 | 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()\na = [list(map(int, input().split())) for i in range(q)]\n\ncum=[0]*n\nfor i in range(1, n):\n cum[i] = cum[i - 1]\n if s[i-1:i+1] == 'AC':\n cum[i]+=1\n print(cum)\n\nfor i in range(q):\n print(cum[a[i][1]-1]-cum[a[i][0]-1])", "dic = {\n 'A': 'T',\n... | ['Runtime Error', 'Accepted'] | ['s500968726', 's298344992'] | [3064.0, 2940.0] | [17.0, 17.0] | [278, 89] |
p03085 | u643363950 | 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 \ni = 0\nmax = 0\nfor s in S:\n if s == "A" or s=="C" or s=="G" or s=="T":\n i += 1\n if i >= max:\n max = i\n else:\n i = 0\n \nprint(max)', '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'] | ['s204653922', 's773899033'] | [2940.0, 2940.0] | [17.0, 18.0] | [160, 112] |
p03085 | u645127738 | 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\tprint("T")\nelif a=="T":\n print("A")\nelif a=="G":\n\tprint("C")\nelse:\n\tprint("G")'] | ['Runtime Error', 'Accepted'] | ['s745908182', 's229738184'] | [2940.0, 2940.0] | [22.0, 17.0] | [101, 103] |
p03085 | u647999897 | 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 func():\n b = input()\n\n if b == 'A':\n print('G')\n if b == 'G':\n print('A')\n if b == 'G':\n print('T')\n if b == 'T':\n print('G')\n\n\nif __name__ == '__main__':\n func()\n", "def func():\n b = input()\n\n if b == 'A':\n print('T')\n if b == 'T':... | ['Wrong Answer', 'Accepted'] | ['s985889323', 's664363783'] | [2940.0, 2940.0] | [18.0, 17.0] | [213, 213] |
p03085 | u652569315 | 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()\nl=['A','C','G','T']\nfor i in range(4):\n if b==l[i]:\n print(l[4-i])", "b=input()\nl=['A','C','G','T']\nfor i in range(4):\n if b==l[i]:\n print(l[3-i])\n"] | ['Runtime Error', 'Accepted'] | ['s503332788', 's233525414'] | [2940.0, 2940.0] | [17.0, 17.0] | [80, 81] |
p03085 | u655048024 | 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 pritn("T")\nelif b == "T":\n print("A")\nelif b == "c":\n print("G")\nelse:\n print("C")', 'b = str(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 = str(input())\nif b == "A":\n pritn("T")... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s176729798', 's450757527', 's800393850', 's455138348'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 19.0, 17.0] | [117, 133, 117, 134] |
p03085 | u657221245 | 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('A')\nif a == 'C':\n print('T')\nif a == 'G':\n print('C')\nif a == 'T':\n print('G')", "a = input()\nif a == 'A':\n print('T')\nelif a == 'C':\n print('G')\nelif a == 'G':\n print('C')\nelif a == 'T':\n print('A')\n\n"] | ['Wrong Answer', 'Accepted'] | ['s692206431', 's734570876'] | [2940.0, 2940.0] | [17.0, 17.0] | [115, 123] |
p03085 | u657901243 | 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. | ["inverse = ['A': 'T', 'T': 'A', 'G': 'C', 'C': 'G']\nprint(inverse[input()])\n", "base = 'ATAGCG'\nprint(base[base.index(input())+1])\n"] | ['Runtime Error', 'Accepted'] | ['s902058038', 's360748311'] | [2940.0, 2940.0] | [17.0, 17.0] | [75, 51] |
p03085 | u657994700 | 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()\nAC = [0] * N\n\nfor i in range(1, len(S)):\n if S[i-1] == 'A' and S[i] == 'C':\n AC[i] = AC[i-1] + 1\n else:\n AC[i] = AC[i-1]\n\n\nfor i in range(Q):\n start, end = map(lambda x:int(x)-1, input().split())\n print(AC[end] - AC[start])", "b = inp... | ['Runtime Error', 'Accepted'] | ['s701631029', 's574181334'] | [3064.0, 2940.0] | [17.0, 18.0] | [294, 113] |
p03085 | u661576386 | 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 = int(input()) \n\nif a == 'A' or a =='T':\n if a == 'A':\n print('T')\n else:\n print('A')\nelse:\n if a == 'G':\n print('C')\n else:\n print('G')", "a = input()\n\nif a == 'A' or a =='T':\n if a == 'A':\n print('T')\n else:\n print('A')\nelse:\n if a == 'G':\n print('C')\n else:\n ... | ['Runtime Error', 'Accepted'] | ['s781404771', 's180850988'] | [2940.0, 2940.0] | [17.0, 17.0] | [154, 148] |
p03085 | u661812507 | 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()\nflag=0\ncount=0\nbegin=0\nmax_begin=0\nmax_count=0\nfor i in range(len(S)):\n if flag==0:\n \n if S[i]=="A" or S[i]=="T" or S[i]=="C" or S[i]=="G":\n begin=i\n count+=1\n flag=1\n \n else:\n if S[i]=="A" or S[i]=="T" or S[i]=="C" or S[i... | ['Wrong Answer', 'Accepted'] | ['s947321629', 's185920483'] | [3064.0, 2940.0] | [17.0, 20.0] | [552, 104] |
p03085 | u662449766 | 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\nlen(max(re.sub(r'[^ACGT]', ' ', input()).split()))", "a = input()\nprint({'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}[a])"] | ['Wrong Answer', 'Accepted'] | ['s866615066', 's331444851'] | [3188.0, 2940.0] | [18.0, 17.0] | [60, 62] |
p03085 | u665038048 | 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 == "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'] | ['s017848661', 's348891622'] | [3316.0, 2940.0] | [24.0, 17.0] | [125, 120] |
p03085 | u666351996 | 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()\noutput = []\nfor i in range(Q):\n\tl, r = map(int, input().split())\n\tSlr = S[l - 1:r]\n\toutput.append(Slr.count('AC'))\nfor i in output:\n\tprint(i)\n", "N, Q = map(int, input().split())\nS = input()\noutput = []\nfor i in range(Q):\n\tl, r = map(int, input().split())... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s395502742', 's503520187', 's765806953', 's064363342'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [187, 196, 196, 112] |
p03085 | u667084803 | 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")\nif s="T":\n print("A")\n\nif s="G":\n print("C")\nif s="C":\n print("G")', 's=input()\nif s=="A":\n print("T")\nif s=="T":\n print("A")\n\nif s=="G":\n print("C")\nif s=="C":\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s242002267', 's274219484'] | [2940.0, 2940.0] | [17.0, 17.0] | [102, 106] |
p03085 | u667978773 | 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)\n ', 'b=input()\nif b==A:\n print(T)\nelif b==T:\n print(A)\nelif b==G:\n print(C)\nelse b==C:\n print(G)\n ', '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(... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s093738455', 's232277512', 's244913061', 's700834992'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [93, 98, 98, 57] |
p03085 | u668503853 | 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()\nli=[]\nt=0\nfor i in range(1,N):\n if S[i-1:i+1]=="AC":\n t+=1\n li.append(t)\nfor _ in range(Q):\n l,r=map(int,input().split())\n print(li[r-1]-li[l-1])\n', 'dna={"A":"T", "T":"A", "C":"G", "G":"C"}\nprint(dna[input()])'] | ['Runtime Error', 'Accepted'] | ['s845671529', 's042550601'] | [3060.0, 2940.0] | [17.0, 17.0] | [194, 60] |
p03085 | u671787293 | 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="G":\n print("C")\nelse:\n print("G")', 'n = int(input())\nif n="A":\n print("T")\nelif n="T":\n print("A")\nelif n="G":\n print("C")\nelse:\n print("G")', 'n = input()\nif n=="A":\n print("T")\nelif n=="T":\n print("A")\nelif n=="G":\n ... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s299080457', 's831345126', 's106681642'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0] | [103, 108, 106] |
p03085 | u672316981 | 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())\ndic = {'A':'C', 'C':'A', 'G':'T', 'T':'G'}\nbz = dic[b]\nprint(bz)", "b = str(input())\ndic = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}\nbz = dic[b]\nprint(bz)"] | ['Wrong Answer', 'Accepted'] | ['s746117462', 's012655140'] | [8972.0, 8936.0] | [25.0, 22.0] | [81, 81] |
p03085 | u672898046 | 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 = ["A, T"]\nc = ["C", "G"]\nif b is a[0]:\n print(a[1])\nif b is a[1]:\n print(a[0])\nif b is c[0]:\n print(c[1])\nif b is c[1]:\n print(c[0])', 'b = input()\na = ["A", T"]\nc = ["C", "G"]\nif b is a[0]:\n print(a[1])\nif b is a[1]:\n print(a[0])\nif b is c[0]:\n print(c[1])\nif b is c[1]:\n pr... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s392575686', 's513304740', 's048612620'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [151, 152, 36] |
p03085 | u673586777 | 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 = (int(i) for i in input().split(' ')) \nS = input()\nfor i in range(Q):\n l_i, r_i = (int(j) for j in input().split())\n matches = re.findall('AC', S[l_i-1:r_i])\n print(len(matches))", "ACGT = {'A':'T', 'C':'G', 'T':'A', 'G':'C'}\ninput_ACGT = input()\nprint(ACGT[input_ACGT])"] | ['Runtime Error', 'Accepted'] | ['s094015800', 's784416802'] | [3188.0, 2940.0] | [19.0, 17.0] | [203, 88] |
p03085 | u676192408 | 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\ndef twin(base):\n if base == 'A':\n a = 'C'\n elif base == 'C':\n a = 'A'\n elif base == 'G':\n a = 'T'\n else:\n a = 'G'\n print(a)\n \ntwin(b)", "b = 'A'\nif b == 'A':\n \tprint('C')\nelif b == 'C':\n \tprint('A')\nelif b == 'G':\n\tprint('T')\nelse:\n \tprint('G')", "b = input()... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s006401193', 's053722235', 's011263300'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 18.0] | [164, 110, 164] |
p03085 | u676407796 | 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("C")\nelif(b=="C"):\n print("A")\nelif(b=="G"):\n print("T")\nelse:\n print("G")', 'b = input()\n\nif(b=="A"):\n print("T")\nelif(b=="C"):\n print("G")\nelif(b=="G"):\n print("C")\nelse:\n print("A")'] | ['Wrong Answer', 'Accepted'] | ['s138309652', 's013832321'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 118] |
p03085 | u677121387 | 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()\nlr = [list(map(int,input().split())) for i in range(q)]\n\naclist = [0]\nacsum = 0\n\nfor i in range(1,n):\n if s[i-1] == "A" and s[i] == "C":\n acsum += 1\n aclist.append(acsum)\n\nfor i in range(q):\n ans = aclist [lr[i][0]-1] - aclist [lr[i][0]-2]\n i... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s876858321', 's918523695', 's732709282'] | [3064.0, 3188.0, 2940.0] | [17.0, 19.0, 17.0] | [386, 385, 129] |
p03085 | u681110193 | 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='T':\n print('A')\nelif s='G':\n print('C')\nelse:\n print('G')\n ", "s=input()\n \nif s=='A':\n print('T')\nelif s=='T':\n print('A')\nelif s=='G':\n print('C')\nelse:\n print('G')\n "] | ['Runtime Error', 'Accepted'] | ['s619297285', 's747369837'] | [2940.0, 2940.0] | [17.0, 17.0] | [111, 115] |
p03085 | u685971021 | 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 = int(input())\nb = int(input())\nc = int(input())\nd = int(input())\ne = int(input())\nk = int(input())\n\nif e - a <= k:\n print('Yay!')\nelse:\n print(':(')\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"] | ['Runtime Error', 'Accepted'] | ['s940220916', 's090821524'] | [2940.0, 2940.0] | [17.0, 17.0] | [158, 126] |
p03085 | u687766076 | 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 = sys.stdin.readline()\nif s == 'A':\n print('T')\nelif s == 'G':\n print('C')\nelif s == 'C':\n print('G')\nelse:\n print('A')\n", "import sys\n\ns = sys.stdin.readline()\nif 'A' in s:\n print('T')\nelif 'G' in s:\n print('C')\nelif 'C' in s:\n print('G')\nelse:\n print('A')\n... | ['Wrong Answer', 'Accepted'] | ['s050851851', 's634639197'] | [2940.0, 2940.0] | [17.0, 17.0] | [146, 146] |
p03085 | u691018832 | 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 = 0\natgc = [0] * len(S)\n\nfor i in S:\n if ('A' in i) or ('C' in i) or ('G' in i) or ('T' in i):\n atgc[n] += 1\n else:\n n += 1\n \nans = max(atgc)\nprint(ans)", "b= input()\n\nif b=='A':\n b='T'\nelif b=='T':\n b='A'\nelif b=='G':\n b='C':\nelif b=='C':\n b='G'\nprint... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s724786425', 's901751881', 's355935495'] | [3060.0, 2940.0, 2940.0] | [17.0, 16.0, 17.0] | [193, 103, 50] |
p03085 | u693933222 | 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()\n\nif (X == “A”):\n print(“T”)\nelif (X ==“T”):\n print(“A”)\nelif (X == “G”):\n print(“C”)\nelse:\n print(“G”)\n', 'X = input()\n\nif (X == A):\n print(“T”)\nelif (X ==T):\n print(“A”)\nelif (X == G):\n print(“C”)\nelse:\n print(“G”)', 'X = input()\n\nif (X == "A"):\n print("T"... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s128807641', 's993676727', 's368251128'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 20.0] | [155, 136, 127] |
p03085 | u694536861 | 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'):\n ", "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'] | ['s911949613', 's496080546'] | [2940.0, 2940.0] | [17.0, 17.0] | [125, 121] |
p03085 | u700929101 | 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","C","T","G"]\nb = input()\nn = int(base.index(b))\nprint(base[3-n])', 'base = ["A","C","G","T"]\nb = input()\nn = int(base.index(b))\nprint(base[3-n])'] | ['Wrong Answer', 'Accepted'] | ['s924941189', 's173699338'] | [2940.0, 2940.0] | [17.0, 17.0] | [77, 77] |
p03085 | u702582248 | 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 = ["A", "C", "G", "T"]\nb=input()\nprint(a[:-1-a.index(b)])', 'a = ["A", "C", "G", "T"]\nb=input()\nprint(a[-1-a.index(b)])'] | ['Wrong Answer', 'Accepted'] | ['s308107193', 's705231686'] | [2940.0, 2940.0] | [18.0, 19.0] | [59, 58] |
p03085 | u703890795 | 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()\nAClst = []\nc = 0\n\nfor i in range(N-1):\n if S[i:i+2]=="AC":\n c += 1\n AClst.append(c)\nAClst.append(c)\n\nfor q in range(Q):\n l, r = map(int, input().split())\n print(AClst[r]-AClst[l])', 'B = input()\n\nif B == "A":\n print("T")\nelif B == "T":\n print("A"... | ['Runtime Error', 'Accepted'] | ['s025897309', 's974826794'] | [3064.0, 2940.0] | [17.0, 17.0] | [231, 113] |
p03085 | u706414019 | 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 = {'A':'C','C':'A','G':'T','T':'G'}\nprint(a[input()])\n", "a = {'A':'T','T':'A','G':'C','C':'G'}\nprint(a[input()])\n"] | ['Wrong Answer', 'Accepted'] | ['s104401113', 's736103100'] | [8852.0, 8960.0] | [20.0, 21.0] | [56, 56] |
p03085 | u706828591 | 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()\ndic = {'A' : 'A',\n 'C' : 'T',\n 'G' : 'C',\n 'T' : 'G'}\nprint(dic[a])", "a = input()\ndic = {'A' : 'T',\n 'C' : 'G',\n 'G' : 'C',\n 'T' : 'A'}\nprint(dic[a])"] | ['Wrong Answer', 'Accepted'] | ['s465348631', 's127819464'] | [2940.0, 2940.0] | [17.0, 17.0] | [97, 97] |
p03085 | u707072292 | 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":\n print("F")\nif a == "F":\n print("A")\nif a == "G":\n print("C")\nif a == "C":\n print("G")', 'a = input()\n\nif a == "A":\n print("T")\nif a == "T":\n print("A")\nif a == "G":\n print("C")\nif a == "C":\n print("G")'] | ['Wrong Answer', 'Accepted'] | ['s828561703', 's333121200'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 116] |
p03085 | u708255304 | 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\n\nfor line in sys.stdin.readlines():\n if line == 'A':\n print('T')\n if line == 'T':\n print('A')\n if line == 'C':\n print('G')\n if line == 'G':\n print('C')\n", "import sys\n\n\nfor line in sys.stdin.readlines():\n line=line.strip()\n if line == 'A':\n ... | ['Wrong Answer', 'Accepted'] | ['s895553667', 's781621526'] | [3060.0, 2940.0] | [19.0, 17.0] | [204, 226] |
p03085 | u712187387 | 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. | ['ATCG\n\nenki = input()\nif enki == "A":\n return "T"\nelif enki == "T":\n return "A"\nelif enki == "C":\n return "G"\nelif enki == "G":\n return "C"', 'enki = input()\nif enki == "A":\n print("T")\nelif enki == "T":\n print("A")\nelif enki == "C":\n print("G")\nelif enki == "G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s018086909', 's282614095'] | [2940.0, 2940.0] | [17.0, 17.0] | [142, 136] |
p03085 | u712868001 | 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=='C';\n print('G')\nelif b=='G';\n print('C')\nelif b=='T';\n print('A')", "b = input()\nA=A\nT=T\nC=C\nG=G\nif b==A;\n print('T')\nelif b==C;\n print('G')\nelif b==G;\n print('C')\nelif b==T;\n print('A')", "b = input()\nA='A'\nT='T'\nC='C'\nG='G'\... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s627515245', 's652148072', 's875673800', 's966169723', 's919961265'] | [2940.0, 2940.0, 2940.0, 2940.0, 3060.0] | [20.0, 17.0, 17.0, 17.0, 17.0] | [121, 129, 129, 113, 129] |
p03085 | u712975113 | 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\nfor i in range(N-1):\n t[i+1]=t[i]+(1 if S[i:i+2]=='AC' else 0)\nfor i in range(Q):\n l,r=map(int,input().split())\n print(t[r-1]-t[l-1])", "N,Q=map(int,input().split())\nS=input()\nl,r=[],[]\nfor i in range(Q):\n l0,r0=map(int,input().split())\n l.appe... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s050465809', 's313062940', 's353531507'] | [3060.0, 3064.0, 2940.0] | [17.0, 17.0, 17.0] | [189, 283, 112] |
p03085 | u723005123 | 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. | ["#!/usr/bin/env python3\n\nimport sys\n\narg = list(input())\n\nif not set(arg) & set('ACGT'):\n print(' ')\n sys.exit(0)\n\nindex_list = []\nindex_list += [i for i, x in enumerate(arg) if x == 'A']\nindex_list += [i for i, x in enumerate(arg) if x == 'C']\nindex_list += [i for i, x in enumerate(arg) if x == 'G']\ni... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s098469144', 's512186401', 's553053792', 's702911712', 's861917700'] | [3064.0, 3064.0, 2940.0, 3060.0, 2940.0] | [18.0, 18.0, 17.0, 17.0, 17.0] | [717, 717, 132, 167, 104] |
p03085 | u723590269 | 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 = str(input())\n\nif (a == \'A\'): \n print(\'T\')\nelif (a == \'T):\n print(\'A\')\nelif (a == \'G\'):\n print(\'C\')\nelif(a ==\'C\'):\n print(\'G\')\nelse: print("none") \n \n \n ', 'a = str(input())\n\nif (a == \'A\'): \n print(\'C\')\nelif (a == \'C\'):\n print(\'A\')\nelif (a == \'... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s112820168', 's722333787', 's282385801'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [178, 179, 169] |
p03085 | u727787724 | 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(C)\nelif x==T:\n print(G)\nelif x==G:\n print(T)\nelse:\n print(A)', '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', "x=input()\nif x=='A':\n print('T')\nelif x=='T':\n print('A')\nelif x=='G':\n print('C')\nelif x=='C':\... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s098490658', 's785399640', 's039212793'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [90, 91, 120] |
p03085 | u728498511 | 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("T")\n\n~ \n~ ... | ['Runtime Error', 'Accepted'] | ['s641682943', 's394823596'] | [2940.0, 2940.0] | [16.0, 17.0] | [601, 121] |
p03085 | u729119068 | 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 'G' if b=='C' else 'C')", "b=input()\nprint('A' if b=='T' else 'T' if b=='A' else 'G' if b=='C' else 'C')"] | ['Runtime Error', 'Accepted'] | ['s916913656', 's440799457'] | [9060.0, 9012.0] | [23.0, 24.0] | [82, 77] |
p03085 | u729133443 | 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('TCGA'[id('')%5])", "print('TCGA'[id('')%5])", "print('TCGA'[id('')%5])", "print('TCG A'[ord(input())%5])"] | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s322956126', 's769498979', 's863803533', 's847991586'] | [2940.0, 2940.0, 2940.0, 8860.0] | [17.0, 17.0, 19.0, 22.0] | [23, 23, 23, 30] |
p03085 | u732870425 | 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()\nli = ["A","T","C","G"]\n\ncnt = 0\ncntli = []\nfor i in range(len(s)):\n if s[i] in li:\n cnt += 1\n else:\n cntli.append(cnt)\n cnt = 0\nelse:\n cntli.append(cnt)\n\nprint(max(cntli))', 'b = input()\nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "C... | ['Wrong Answer', 'Accepted'] | ['s573653318', 's366612573'] | [3060.0, 2940.0] | [19.0, 17.0] | [213, 129] |
p03085 | u733774002 | 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())\nans = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\nprint(ans[b])", "b = input()\nans = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\nprint(ans[b])\n"] | ['Runtime Error', 'Accepted'] | ['s031243364', 's887442255'] | [2940.0, 2940.0] | [17.0, 17.0] | [77, 73] |
p03085 | u736479342 | 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==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'] | ['s031442178', 's109667787'] | [9104.0, 8964.0] | [27.0, 25.0] | [101, 107] |
p03085 | u738898077 | 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', 'b = input()\nif b == "A":\n\tprint("T")\nelif b == "T":\n\tprint("A")\nelif b == "C":\n\tprint("G")\nelif b == "G":\n\tprint("C")'] | ['Runtime Error', 'Accepted'] | ['s969827337', 's912687158'] | [2940.0, 2940.0] | [17.0, 17.0] | [1, 117] |
p03085 | u739721456 | 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 b = 'T'\nelif b == 'T':\n b = 'A'\nelif b == 'C':\n b = 'G'\nelse:\n b = 'C'\nprint(b)\n"] | ['Runtime Error', 'Accepted'] | ['s630046638', 's280465272'] | [2940.0, 9020.0] | [17.0, 19.0] | [101, 118] |
p03085 | u741495664 | 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(b)\nb = {"A" : "T", "G" : "C", "T" : "A", "C" : "G"}\n\nprint(c[b])', 'a = input()\nb = {"A" : "T", "G" : "C", "T" : "A", "C" : "G"}\n\nprint(b[a])'] | ['Runtime Error', 'Accepted'] | ['s258657726', 's213829117'] | [2940.0, 2940.0] | [17.0, 17.0] | [74, 73] |
p03085 | u743272507 | 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", "T":"A", "G":"C", "C","G"}\nprint(d[input()])', 'd = {"A":"T", "T":"A", "G":"C", "C":"G"}\nprint(d[input()])\n'] | ['Runtime Error', 'Accepted'] | ['s049869596', 's703154350'] | [8788.0, 8960.0] | [22.0, 25.0] | [58, 59] |
p03085 | u745554846 | 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 = str(input())\n\nif a == 'A':\n print('T')\nelif a == 'T'\n print('A')\nelif a == 'G':\n print('C')\nelif a == 'C':\n print('G')", "a = input()\n\nif a == 'A':\n print('T')\nelif a == 'T':\n print('A')\nelif a == 'C':\n print('G')\nelse:\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s168891195', 's485693035'] | [2940.0, 2940.0] | [17.0, 18.0] | [134, 121] |
p03085 | u745561510 | 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")\nelif(n == "C"):\n print("T")\nelif(n == "G"):\n print("C")\nelif(n == "T"):\n print("G")', 'n = input()\n\nif(n == "A"):\n print("A")\nelif(n == "C"):\n print("T")\nelif(n == "G"):\n print("C")\nelif(n == "T"):\n print("G")\n', 'n = input()\n\nif(n ==... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s651890739', 's682155631', 's805693103'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [134, 135, 135] |
p03085 | u745906650 | 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('ATCG'['TAGC'.index()])", "print('ATCG'['TAGC'.index(input())])"] | ['Runtime Error', 'Accepted'] | ['s219860295', 's973012673'] | [2940.0, 2940.0] | [17.0, 17.0] | [29, 36] |
p03085 | u747873993 | 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')", "S=input()\ncount=0\nresult=0\nfor i in S:\n if i in 'AGTC':\n count+=1\n else:\n result=max(result,count)\n count=0\nprint(result)", "b=input()\nif b=='A':\n print('T... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s026662826', 's596228258', 's603873624'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [110, 148, 112] |
p03085 | u752898745 | 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();print('A'if b=='C' else 'C' if b=='A' else 'G' if b=='T' else 'T')", "b=input();print('A'if b=='T' else 'T' if b=='A' else 'G' if b=='C' else 'C')"] | ['Wrong Answer', 'Accepted'] | ['s915772405', 's253236707'] | [2940.0, 2940.0] | [17.0, 18.0] | [76, 76] |
p03085 | u753810022 | 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")', 'b = input()\nif b == "A": \n print("T")\nelif b == "T":... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s262455129', 's293503648', 's923669458'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [110, 126, 129] |
p03085 | u755666122 | 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')", "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'] | ['s812017921', 's530008925'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 113] |
p03085 | u756429062 | 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 = (int(i) for i in input().split())\ns = input()\n\nfor i in range(q):\n l,r = (int(i) for i in input().split())\n cnt = s.count('AC',l-1,r)\n print(cnt)", 'dic = {"A":"T","C":"G","T":"A","G":"C"}\nprint(dic[input()])'] | ['Runtime Error', 'Accepted'] | ['s313301336', 's783642931'] | [3056.0, 2940.0] | [17.0, 17.0] | [161, 59] |
p03085 | u759076129 | 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 \nlen = 0\nans = 0\nfor ch in S:\n if ch in 'ACGT':\n len += 1\n ans = max(ans, len)\n else:\n len = 0\nprint(ans)", "b = input().strip()\n\nif b == 'A':\n return 'T'\nelif b == 'T':\n return 'A'\nelif b == 'C':\n return 'G'\nelse:\n return 'C'", "b = input().strip()\n \ni... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s171076824', 's841305924', 's972016536'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [145, 121, 122] |
p03085 | u760961723 | 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\')', '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'] | ['s522129445', 's057338958'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 121] |
p03085 | u761087127 | 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=[int(n) for n in input().split(' ')]\nS=input()\na=''\nfor i in range(Q):\n l,r=[int(n) for n in input().split(' ')]\n a=a+str(S[l-1:r].count('AC'))+'\\n'\nprint(a)\n", "o = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}\nb = input()\nprint(o[b])"] | ['Runtime Error', 'Accepted'] | ['s920814941', 's641973403'] | [2940.0, 2940.0] | [17.0, 17.0] | [164, 68] |
p03085 | u762420987 | 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. | ['vocab = {"A":"T","T":"A","C":"G","G","C"}\nprint(vocab[input()])', 'a = {"A": "T", "T": "A", "C": "G", "G": "C"}\nprint(a[input()])\n'] | ['Runtime Error', 'Accepted'] | ['s917305174', 's309506336'] | [2940.0, 2940.0] | [17.0, 17.0] | [63, 63] |
p03085 | u770009793 | 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. | ['I=input()\n\nif I == "A":\n print("T")\nelif I = "T":\n print("A")\nelif I == "C":\n print("G")\nelse:\n print("C")', 'I=input()\n\nif I == "A":\n print("T")\nelif I == "T":\n print("A")\nelif I == "C":\n print("G")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s870454697', 's832396311'] | [2940.0, 2940.0] | [17.0, 17.0] | [110, 111] |
p03085 | u773265208 | 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')\nelif b == 'C':\n print('T')\nelif b == 'G':\n print('C')\nelse:\n print(G)\n", "b = input()\n\nif b == 'A':\n print('T')\nelif b == 'C':\n print('G')\nelif b == 'G':\n print('C')\nelse:\n print('A')\n"] | ['Runtime Error', 'Accepted'] | ['s154985708', 's393290305'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 114] |
p03085 | u774985302 | 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 = {"A":T,"C":G}\nprint(c[b])', 'b = input()\nc = {"A":"T","C":"G" ,"T":"A","G":"C"}\nprint(c[b])'] | ['Runtime Error', 'Accepted'] | ['s621569428', 's210611887'] | [2940.0, 2940.0] | [17.0, 17.0] | [41, 62] |
p03085 | u776871252 | 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")', '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")', 'b = input()\n \nif b == A:\n print("T")\nif b == T:\n print(... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s626879666', 's631534739', 's839364464', 's882706505', 's818204763'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 18.0, 17.0] | [115, 115, 109, 108, 117] |
p03085 | u777215291 | 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')\nelif 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'] | ['s345981623', 's276834608'] | [3060.0, 2940.0] | [19.0, 17.0] | [117, 121] |
p03085 | u777394984 | 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. | ['agct = ["A":"T","G":"C","T":"A","C":"G"]\nprint(agct[input()])', 'b = input()\naa = {"A":"T","T":"A","G":"C","C","G"}\nprint(aa[b])', 'b = input()\naa = {"A":"T", "T":"A", "G":"C", "C":"G"}\nprint(aa[b])'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s064262164', 's623736440', 's975535515'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [61, 63, 66] |
p03085 | u778700306 | 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. | ['\nb=input()\nif "AT".find(b):\n print("A" if b == \'T\' else "T")\nif "CG".find(b):\n print("C" if b == \'G\' else "G")', '\nb=input()\nif "AT".find(b) != -1:\n print("A" if b == \'T\' else "T")\nif "CG".find(b) != -1:\n print("C" if b == \'G\' else "G")'] | ['Wrong Answer', 'Accepted'] | ['s515913680', 's122672957'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 128] |
p03085 | u778710411 | 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("G")\nelif b == "G":\n print("A")\nelif b == "C":\n print("T")\nelse:\n print("C")', 'if b = A:\n print("G")\nelif b = G:\n print("A")\nelif b = C:\n print("T")\nelse:\n print("C")', 'if b == "A":\n print("G")\nelif b == "G":\n print("A")\nelif b == "C":\n print("T")\nelse... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s342742738', 's463367333', 's573470894', 's656237963'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 18.0] | [112, 91, 100, 112] |
p03085 | u779508975 | 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:\n print('A')", "b=input()\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'] | ['s396685298', 's540938654'] | [8828.0, 8848.0] | [23.0, 27.0] | [114, 113] |
p03085 | u783591056 | 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. | ['data=input()\nif data=="A":\n print("C")\nelif data=="C":\n print("A")\nelif data=="G":\n print("T")\nelif data=="T":\n print("G")', 'data=input()\nif data=="A":\n print("T")\nelif data=="T":\n print("A")\nelif data=="G":\n print("C")\nelif data=="C":\n print("G")'] | ['Wrong Answer', 'Accepted'] | ['s245291297', 's306365451'] | [2940.0, 2940.0] | [17.0, 17.0] | [126, 126] |
p03085 | u785208802 | 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()\na = "ATCG"\nm = [0]\nfor i in range(len(s)):\n if s[i] in a:\n j = i + 1\n niz = 1\n while j < len(s) and s[j] in a:\n niz += 1\n j += 1\n m.append(niz)\nprint(max(m))\n\n# 02:49\n', 's = input()\nif s == "A":\n print("T")\nif s == "C":\n print("... | ['Wrong Answer', 'Accepted'] | ['s522473091', 's625740509'] | [3060.0, 2940.0] | [19.0, 19.0] | [232, 133] |
p03085 | u788734639 | 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()\nans = ''\nif(s=='A'):\n ans = 'T'\nelif(s=='T'):\n ans = 'A'\nelif(s=='C'):\n ans = 'G'\nelse:\n ans= 'C'\n", "s = input()\nans = ''\nif(s=='A'):\n ans = 'T'\nelif(s=='T'):\n ans = 'A'\nelif(s=='C'):\n ans = 'G'\nelse:\n ans= 'C'\nprint(ans)"] | ['Wrong Answer', 'Accepted'] | ['s957255117', 's149555124'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 132] |
p03085 | u790487011 | 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\nstr = input()\n\n\npattern = r"[ATCG]+"\n\nmatched_list = re.findall(pattern, str)\n\nmaxlength = 0\nfor item in matched_list:\n tmplength = len(item)\n if maxlength < tmplength:\n maxlength = tmplength\n\nprint(maxlength)', 'base = input()\n\nif base == "A":\n print("T")\nelif base == "T... | ['Wrong Answer', 'Accepted'] | ['s880968992', 's530225923'] | [3188.0, 2940.0] | [20.0, 17.0] | [233, 145] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.