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 |
|---|---|---|---|---|---|---|---|---|---|---|
p03078 | u960653324 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['k = [int(i) for i in input().split()]\nx = [int(i) for i in input().split()]\ny = [int(i) for i in input().split()]\nz = [int(i) for i in input().split()]\n\nx.sort(reverse=True)\nif len(x)>k[3]:\n x = x[0:k[3]+1]\n\ny.sort(reverse=True)\nif len(y)>k[3]:\n y = y[0:k[3]+1]\n\nz.sort(reverse=True)\nif len(z)>k[3]:\n ... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s121845999', 's398821122', 's446671232', 's460322840', 's702255450', 's762496522', 's862538670', 's978563185', 's830148829'] | [211108.0, 2940.0, 204724.0, 223832.0, 204212.0, 212088.0, 2940.0, 3188.0, 8708.0] | [2115.0, 17.0, 1889.0, 2116.0, 1975.0, 2116.0, 17.0, 19.0, 771.0] | [547, 424, 532, 395, 526, 378, 418, 434, 465] |
p03078 | u967835038 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['x,y,z,k=map(int,input().split())\na=list(map(int,input().split()))\nb=list(map(int,input().split()))\nc=list(map(int,input().split()))\nans=[]\na.sort()\nb.sort()\nc.sort()\nfor i in range(min(x,k)):\n for j in range(min(y,k)):\n if i*j>k:\n break\n for l in range(min(z,k)):\n if i*j*l>k:\n br... | ['Runtime Error', 'Accepted'] | ['s601285842', 's438587164'] | [3188.0, 112348.0] | [19.0, 1777.0] | [400, 448] |
p03078 | u970197315 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['waaaaaaaaaaaaaaaaaaaaaannnnnnnnnn', "x,y,z,k=map(int,input().split())\na=sorted(list(map(int,input().split())),reverse=True)\nb=sorted(list(map(int,input().split())),reverse=True)\nc=sorted(list(map(int,input().split())),reverse=True)\n\nab=[i+j for j in b for i in a]\nab.sort(reverse=True)\nabc=[i+j for j in c[:k] f... | ['Runtime Error', 'Accepted'] | ['s619159305', 's152039030'] | [2940.0, 208068.0] | [17.0, 1733.0] | [33, 339] |
p03078 | u978313283 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['def classify(a,b,c,T):\n if T[a][1]!=T[b][1] and T[b][1]!=T[c][1] and T[c][1]!=T[a][1]:\n return 1\n else:\n return 0\nX,Y,Z,K = map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\nC=list(map(int,input().split()))\nT=[]\nfor i in range(X):\n T.append([A... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s014413977', 's518388148', 's233605123'] | [29896.0, 29748.0, 185756.0] | [2105.0, 2105.0, 1994.0] | [822, 821, 429] |
p03078 | u979823197 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['import heapq\nX,Y,Z,K=map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\nC=list(map(int,input().split()))\nA.sort(reverse=True)\nB.sort(reverse=True)\nC.sort(reverse=True)\nQ=[[-A[0]-B[0]-C[0],0,0,0]]\nheapq.heapify(Q)\nans=[A[0]+B[0]+C[0]]\nijk={(0,0,0)}\nwhile len(ans)<=K:... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s969363566', 's974799564', 's999099974'] | [5232.0, 5232.0, 5232.0] | [37.0, 37.0, 36.0] | [712, 698, 697] |
p03078 | u989345508 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['import heapq\nx,y,z,k=map(int,input().split())\na=[int(i) for i in input().split()]\nb=[int(i) for i in input().split()]\nc=sorted([int(i) for i in input().split()],reverse=True)\nab=[]\nfor i in range(x):\n for j in range(y):\n ab.append(a[i]+b[j])\nab.sort(reverse=True)\nab=ab[:k]\nl=len(ab)\nabc=[]\nfor ... | ['Wrong Answer', 'Accepted'] | ['s224452894', 's383992226'] | [161116.0, 184680.0] | [2113.0, 1946.0] | [431, 378] |
p03078 | u994988729 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['23379871545\n22444657051\n22302177772\n22095691512\n21667941469\n21366963278\n21287912315\n21279176669\n21160477018\n21085311041\n21059876163\n21017997739\n20703329561\n20702387965\n20590247696\n20383761436\n20343962175\n20254073196\n20210218542\n20150096547\n', 'x,y,z,K=map(int,input().split())\na=list(map(int,input... | ['Wrong Answer', 'Accepted'] | ['s000988458', 's038709351'] | [3064.0, 8708.0] | [17.0, 118.0] | [240, 471] |
p03078 | u997641430 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['X, Y, Z, K = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nC = list(map(int, input().split()))\nAB = [a + b for a in A for b in B]\nAB.sort()\nAB.reverse()\nprint(AB)\nABC = [ab + c for ab in AB for c in C]\nABC.sort()\nABC.reverse()\nfor k in range(K):\n prin... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s551447134', 's566844134', 's198370758'] | [1511992.0, 166352.0, 167728.0] | [2200.0, 2115.0, 1969.0] | [316, 349, 307] |
p03078 | u998733244 | 2,000 | 1,048,576 | The Patisserie AtCoder sells cakes with number-shaped candles. There are X, Y and Z kinds of cakes with 1-shaped, 2-shaped and 3-shaped candles, respectively. Each cake has an integer value called _deliciousness_ , as follows: * The deliciousness of the cakes with 1-shaped candles are A_1, A_2, ..., A_X. * The del... | ['# -*- coding: utf-8 -*-\nx,y,z,k = map(int, input().split())\n\na = list(map(int,input().split()))\nb = list(map(int,input().split()))\nc = list(map(int,input().split()))\n\nv = []\ncount = 0\n\n\nfor i in range(x):\n for j in range(y):\n v.append(a[i]+b[j])\n\nv = sorted(v, reverse=True)\nc = sorted(c, rev... | ['Runtime Error', 'Accepted'] | ['s644725098', 's392488484'] | [481552.0, 161624.0] | [2133.0, 1918.0] | [481, 394] |
p03085 | u000349418 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b=='A':\n print('C')\nelif b=='C':\n print('A')\nelif b=='T':\n print('G')\nelse:\n print('T')", "b = input()\nif b=='A':\n print('T')\nelif b=='T':\n print('A')\nelif b=='C':\n print('G')\nelse:\n print('C')"] | ['Wrong Answer', 'Accepted'] | ['s193068350', 's090417891'] | [2940.0, 2940.0] | [17.0, 17.0] | [114, 114] |
p03085 | u000557170 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nimport sys\n\ndef parse_input(lines_as_string = None):\n\n lines = []\n if lines_as_string is None:\n lines.append(input())\n tokens = lines[0].split(" ")\n n = int(tokens[0])\n q = int(tokens[1])\n lines.append(input())\n for i in range(q):\n... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s149876003', 's940995760', 's451997589'] | [3064.0, 3064.0, 3060.0] | [18.0, 20.0, 17.0] | [1347, 679, 532] |
p03085 | u001687078 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\n\nn, q = map(int, input().split())\ns = input()\nfor _ in range(q):\n first, last = map(int, input().split())\n print(s[first-1:last].count("AC"))', "print('ATCG'['TAGC'.find(input())])"] | ['Runtime Error', 'Accepted'] | ['s753788272', 's305696414'] | [2940.0, 2940.0] | [16.0, 17.0] | [181, 35] |
p03085 | u003501233 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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={"A":"T","T":"A","C":"G","G":"C"}\na=input()\nprint(a[s])\n', 'a=input()\ns={"A":"T","T":"A","C":"G","G":"C"}\nprint(a[s])\n', 'a=input()\ns={"A":"T","T":"A","C":"G","G":"C"}\nprint(s[a])\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s830945940', 's838921662', 's243381285'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [58, 58, 58] |
p03085 | u007785897 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 - Double Helix\nb = input()\ndict_ = {"A":"A", "C":"T", "G":"C", "T":"G"}\nprint(dict_[b])', '# A - Double Helix\nb = input()\ndict_ = {"A":"T", "C":"G", "G":"C", "T":"A"}\nprint(dict_[b])'] | ['Wrong Answer', 'Accepted'] | ['s383028382', 's844942540'] | [2940.0, 2940.0] | [18.0, 17.0] | [91, 91] |
p03085 | u014139588 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nif b = "A":\n b = "T"\nelif b = "T":\n b = "A"\nelif b = "C":\n b = "G"\nelif b = "G":\n b = "C"\nprint(b)', 'b = input()\nif b == "A":\n b = "T"\nelif b == "T":\n b = "A"\nelif b == "C":\n b = "G"\nelif b == "G":\n b = "C"\nprint(b)'] | ['Runtime Error', 'Accepted'] | ['s035151006', 's239794876'] | [8896.0, 8928.0] | [26.0, 23.0] | [114, 118] |
p03085 | u017415492 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")\nelif b=="T":\n print("G")', 'b=input()\n\nif b=="A":\n print("T")\nelif b=="C":\n print("G")\nelif b=="G":\n print("C")\nelif b=="T":\n print("A")'] | ['Wrong Answer', 'Accepted'] | ['s058075770', 's649893171'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 112] |
p03085 | u017810624 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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(s[3-'AGCT'.index(input())])", "s='ACGT';print(s[3-s.index(input())])"] | ['Runtime Error', 'Accepted'] | ['s362624405', 's227522934'] | [2940.0, 2940.0] | [18.0, 17.0] | [33, 37] |
p03085 | u019566983 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['l = (("A","T"),("G","C"))\ni = inpit()\nif i in l[0]:\n if i == l[0][0]:\n print(l[0][1])\n else: print(l[0][0])\nelse:\n if i == l[1][0]:\n print(l[1][1])\n else: print(l[1][0])', '# coding: utf-8\n\nl = (("A","T"),("G","C"))\ni = input()\nif i in l[0]:\n if i == l[0][0]:\n print(l[0][1])\n el... | ['Runtime Error', 'Accepted'] | ['s276275596', 's984353062'] | [3060.0, 2940.0] | [18.0, 17.0] | [179, 213] |
p03085 | u019578976 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s=input()\nif s="A":\n print("T")\nelif s="T":\n print("A")\nelif s="C":\n print("G")\nelse:\n print("C")', 's=input()\nif s=="A":\n print("T")\nelif s=="T":\n print("A")\nelif s=="C":\n print("G")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s498102653', 's917477407'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 112] |
p03085 | u020962106 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["l = {'A':'C','C':'A','G':'T','T':'G'}\nprint(l[input()])", "l = {'A':'T','T':'A','G':'C','C':'G'}\nprint(l[input()])"] | ['Wrong Answer', 'Accepted'] | ['s067372115', 's160156292'] | [2940.0, 2940.0] | [18.0, 17.0] | [55, 55] |
p03085 | u021019433 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["p = 'ACGT'\ns = input()\nl = len(s)\nr = 0\ni = -1\nwhile i < l:\n j = next((i for i in range(i + 1, l) if s[i] in p), l)\n i = next((i for i in range(j + 1, l) if s[i] not in p), l)\n r = max(r, i - j)\nprint(r)\n", "s='ATACGC'\nprint(s[s.find(input())+1])"] | ['Wrong Answer', 'Accepted'] | ['s760537709', 's251056412'] | [3188.0, 2940.0] | [19.0, 17.0] | [204, 38] |
p03085 | u025363805 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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("A")\nelif b == "C":\n print("T")\nelif b == "G":\n print("C")\nelif b == "T":\n print("G")\n', '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")\n'] | ['Wrong Answer', 'Accepted'] | ['s206202997', 's252147153'] | [8912.0, 8852.0] | [24.0, 27.0] | [154, 130] |
p03085 | u025879810 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 pdb\nimport builtins\nimport sys\nimport numpy as np\nclass Test:\n def __init__(self):\n pass\n\nclass CustomUtils:\n def __init__(self):\n pass\n def to_int(self, inputs, sp=\' \'):\n if sp == \'\':\n return [int(d) for d in list(inputs)]\n else:\n #... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s558469612', 's698503395', 's592355092'] | [22808.0, 3064.0, 3064.0] | [330.0, 18.0, 17.0] | [1535, 1316, 860] |
p03085 | u027675217 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['enki_dict={"A":"T","C":"G"}\nb = input()\nans = enki_dict["b"]\nprint(ans)\n', 'enki_dict={"A":"T","C":"G","T":"A","G":"C"}\nb = input()\nans = enki_dict[b]\nprint(ans)\n'] | ['Runtime Error', 'Accepted'] | ['s541865036', 's223978451'] | [2940.0, 2940.0] | [17.0, 18.0] | [72, 86] |
p03085 | u029000441 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 math\nimport collections\nimport sys\n \ninput = sys.stdin.readline\ndef I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LI(): return list(map(int, input().split()))\ndef LI2(): return [int(input()) for i in range(n)]\ndef MXI(): return [[LI()]for i in range(n)]\n \nb=input()\nif b=="... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s083877491', 's669630999', 's981349139', 's158085575'] | [3316.0, 3316.0, 3316.0, 3316.0] | [20.0, 20.0, 20.0, 21.0] | [408, 407, 404, 844] |
p03085 | u038676814 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['moji = input()\nif moji == "A" :\n print("A")\nif moji == "C" :\n print("T")\nif moji == "G" :\n print("C")\nif moji == "T" :\n print("G")', 'moji = input()\nif moji == "A" :\n print("T")\nif moji == "C" :\n print("G")\nif moji == "G" :\n print("C")\nif moji == "T" :\n print("A")'] | ['Wrong Answer', 'Accepted'] | ['s415519389', 's176648752'] | [2940.0, 2940.0] | [17.0, 17.0] | [142, 142] |
p03085 | u038956510 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["letter = input()\n\ndict = {'A': 'A', 'C':'T', 'G':'C', 'T':'G'}\nif letter in dict:\n print(dict[letter])", "letter = input()\ndict = {'A': 'A', 'C':'T', 'G':'C', 'T':'G'}\nfor letter in dict:\n print(dict[letter])", "letter = input()\n\ndict = {'A': 'T', 'C':'G', 'T':'A', 'G':'C'}\nif letter in dict:\n print(dic... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s694919329', 's928861631', 's833862262'] | [3064.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [103, 103, 103] |
p03085 | u042802884 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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':c='T'\nif b='T':c='A'\nif b='C':c='G'\nif b='G':c='C'\nprint(c)", "b=input()\nif b=='A':c='T'\nif b=='T':c='A'\nif b=='C':c='G'\nif b=='G':c='C'\nprint(c)"] | ['Runtime Error', 'Accepted'] | ['s308871948', 's024001786'] | [2940.0, 2940.0] | [17.0, 17.0] | [78, 82] |
p03085 | u045408189 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')\n"] | ['Runtime Error', 'Accepted'] | ['s582698110', 's399215342'] | [2940.0, 2940.0] | [17.0, 17.0] | [101, 105] |
p03085 | u051496905 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 == "... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s000657717', 's466612657', 's494865760', 's936821498'] | [2940.0, 2940.0, 3060.0, 2940.0] | [17.0, 18.0, 19.0, 18.0] | [125, 117, 121, 129] |
p03085 | u052838115 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')"] | ['Wrong Answer', 'Accepted'] | ['s364191212', 's874464974'] | [8900.0, 8904.0] | [25.0, 24.0] | [117, 119] |
p03085 | u057415180 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nfor i in range(len(b)):\n if b[i] == 'A':\n b[i] = 'T'\n elif b[i] == 'T':\n b[i] = 'A'\n elif b[i] == 'G':\n b[i] = 'C'\n else:\n b[i] = 'G'\nprint(b)", "# b = input()\n# if b == 'A':\n# print('T')\n# elif b == 'T':\n# print('A')\n# elif b == 'G':\n# print('C')\n# else:\n# ... | ['Runtime Error', 'Accepted'] | ['s095620268', 's536779337'] | [3060.0, 3060.0] | [19.0, 17.0] | [170, 337] |
p03085 | u057964173 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 resolve():\n s=input()\n num=0\n for i in range(len(s)):\n for j in range(len(s)+1):\n s1=s[i:j]\n if 'B' not in s1 and 'D' not in s1 and 'E' not in s1 and 'F' not in s1\\\n and 'H' not in s1 and 'I' not in s1 and 'J' not in s1 and 'K' not in s1 and 'L' not... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s244636404', 's968395295', 's287506710'] | [3064.0, 3064.0, 2940.0] | [17.0, 18.0, 17.0] | [648, 647, 175] |
p03085 | u058861899 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=="C":\n print("G")\nelif s=="G":\n print("C")\nelif s=="A":\n print("T"):\nelse:\n print("A")', 's=input()\n\nif s=="A":\n print("T")\nelif s=="T":\n print("A")\nelif s=="C":\n print("G")\nelse:\n print("C")\n '] | ['Runtime Error', 'Accepted'] | ['s189248506', 's610211883'] | [2940.0, 2940.0] | [18.0, 17.0] | [105, 118] |
p03085 | u059262067 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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("ACGT"["CATG".find(input())])', 'print(["ACGT"]["CATG".find(input())])', 'print("ACGT"["TGCA".find(input())])'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s251243744', 's593518337', 's283443520'] | [2940.0, 2940.0, 2940.0] | [16.0, 17.0, 17.0] | [35, 37, 35] |
p03085 | u061975638 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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'] | ['s047742579', 's731321449'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 113] |
p03085 | u062706707 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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(int, input().split())\n\nif b == "A":\n print("T")\nelif b == "T":\n print("A") \nelif b == "C":\n print("G") \nelse:\n print("C") \n \n ', 'b, = map(str, input().split())\n\nif b == "A":\n print("T")\nelif b == "T":\n print("A") \nelif b == "C":\n print("G") \nelse:\n pr... | ['Wrong Answer', 'Accepted'] | ['s261278480', 's785406290'] | [2940.0, 2940.0] | [17.0, 17.0] | [156, 152] |
p03085 | u063703408 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ni = ['A','C','G','T']\no = ['C','A','T','G']\nprint(o[i.index(b)])", "b = input()\ni = ['A','C','G','T']\no = ['T','G','C','A']\nprint(o[i.index(b)])"] | ['Wrong Answer', 'Accepted'] | ['s697329664', 's804280809'] | [2940.0, 2940.0] | [17.0, 17.0] | [76, 76] |
p03085 | u070449185 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N, Q = map(int, input().split())\nS = input()\nl = [0] * Q\nr = [0] * Q\nfor i in range(Q):\n l[i], r[i] = map(int, input().split())\ncounter = [0] * N\n\nfor i in range(N-1):\n if S[i:i+2] == 'AC':\n counter[i+1] += counter[i] + 1\n else:\n counter[i+1] += counter[i]\n\nfor i in range(Q):\n ... | ['Runtime Error', 'Accepted'] | ['s626319414', 's244430025'] | [3064.0, 2940.0] | [17.0, 18.0] | [344, 202] |
p03085 | u075303794 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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' or b == 'G':\n if b == 'A':\n print('G')\n else:\n print('A')\nelse:\n if b == 'C':\n print('G')\n else:\n print('C')", "b = input()\nif b == 'A' or b == 'T':\n if b == 'A':\n print('T')\n else:\n print('A')\nelse:\n if b == 'C':\n print('G')\n else:\n print('C... | ['Wrong Answer', 'Accepted'] | ['s168663895', 's024253812'] | [2940.0, 2940.0] | [17.0, 17.0] | [148, 148] |
p03085 | u076363290 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["b = input()\nif b == 'A':\n print('C')\nelif b == 'C':\n print('A')\nelif b == 'G':\n print('T')\nelif b == 'T':\n print('G')", "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')"] | ['Wrong Answer', 'Accepted'] | ['s238119286', 's238310325'] | [9020.0, 8672.0] | [26.0, 31.0] | [129, 129] |
p03085 | u076917070 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\n\ndef main():\n b = input().strip()\n if b == "A":\n print("C")\n elif b == "C":\n print("A")\n elif b == "G":\n print("T")\n else:\n print("G")\n\nif __name__ == \'__main__\':\n main()\n', 'import sys\ninput=sys.stdin.readline\n\ndef... | ['Wrong Answer', 'Accepted'] | ['s791896738', 's988763602'] | [2940.0, 2940.0] | [17.0, 18.0] | [253, 253] |
p03085 | u076996519 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["l = ['A', 'C', 'T', 'G']\nb = input()\nfor i in range(3):\n if l[i] == b:\n print(l[(i+2)/4])\n break", "n,q=map(int,input().split())\ns=input()\n\nfor _ in range(q):\n\tl,r=map(int,input().split())\n\t# list_=[s[l-1:r]]\n\t# print(s[l-1:r])\n\tans=0\n\tfor i in range(l-1,r-1):\n\t\tif s[i] == 'A' an... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s786558525', 's939511146', 's256230980'] | [2940.0, 3188.0, 2940.0] | [17.0, 19.0, 17.0] | [113, 222, 113] |
p03085 | u077075933 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\': print("T")\nelif b==\'C\': print("G")\nelse print(b)\n', 'b = input()\nif b==\'A\': print("T")\nelif b==\'T\': print("A")\nelif b==\'C\': print("G")\nelif b==\'G\': print("C")'] | ['Runtime Error', 'Accepted'] | ['s251480337', 's805493320'] | [2940.0, 2940.0] | [17.0, 17.0] | [72, 105] |
p03085 | u077291787 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["# ABC122A - Double Helix\n# a-t, c-g\ndata = {'a': 't', 't': 'a', 'c': 'g', 'g': 'c'}\n\nprint(data[input()])", '# ABC122A - Double Helix\n# a-t, c-g\ndata = {"A": "T", "T": "A", "C": "G", "G": "C"}\n\nprint(data[input()])'] | ['Runtime Error', 'Accepted'] | ['s848564216', 's785208468'] | [2940.0, 2940.0] | [17.0, 17.0] | [105, 105] |
p03085 | u077498363 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['dic = { "A": "G",\n "G": "A", \n "T": "C",\n "C": "T" }\nprint(dic[input()])', 'dic = { "A": "T",\n "T": "A",\n "G": "C",\n "C": "G" }\nprint(dic[input()])'] | ['Wrong Answer', 'Accepted'] | ['s068705122', 's354373062'] | [2940.0, 2940.0] | [17.0, 17.0] | [93, 92] |
p03085 | u078944864 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["str = list(input())\n\ntmp = ''\nans = ''\nfor s in str:\n if (s in ['A', 'T', 'G', 'C']):\n tmp += s\n if (len(tmp) > len(ans)):\n ans = tmp\n else:\n tmp = ''\n\nprint(ans)", "a = input()\nif a == 'A':\n print('T')\nelif a == 'T':\n print('A')\nelif a == 'G':\n print('C')\nelif a == 'C':\n print... | ['Wrong Answer', 'Accepted'] | ['s659000037', 's573123173'] | [3060.0, 2940.0] | [20.0, 17.0] | [178, 121] |
p03085 | u079022116 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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":"T","T":"A","C":"G","G":"C"}\nprint(b[input()])', 'a={"A":"T","T":"A","C":"G","G":"C"}\nprint(a[input()])\n'] | ['Runtime Error', 'Accepted'] | ['s499560790', 's481132669'] | [2940.0, 2940.0] | [17.0, 17.0] | [53, 54] |
p03085 | u082861480 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ndic_ = str.maketrans({'T':'1','A':'1','C':'1','G':'1'})\ns = s.translate(dic_)\ncount = 0\nresult = 0\npre_i = ''\n\nfor i in s:\n if pre_i == '1' and i == '1':\n count += 1\n \n elif pre_i =='1':\n if count > result:\n result = count\n count = 0\n pre_i = ''\n \n elif i == '1':\n... | ['Wrong Answer', 'Accepted'] | ['s362516077', 's873132878'] | [3188.0, 2940.0] | [19.0, 17.0] | [380, 67] |
p03085 | u085334230 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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'}\na = input()\nprint(dict(a))", "dict = {'A':'T','C':'G','T':'A', 'G':'C'}\na = input()\nprint(dict[a])\n"] | ['Runtime Error', 'Accepted'] | ['s470039087', 's393502938'] | [2940.0, 2940.0] | [18.0, 18.0] | [68, 69] |
p03085 | u089142196 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=int(input())\n\n if b=="A":\n return "T"\n elif b=="C":\n return "G"\n elif b="G":\n return "C"\n elif b=="T":\n return "A"\n\nmain()\n', 'def main():\n b=input()\n\n if b=="A":\n print("T")\n elif b=="C":\n print("G")\n elif b=="G":\n print("C")\n elif b=="T":\n prin... | ['Runtime Error', 'Accepted'] | ['s509630179', 's140767911'] | [2940.0, 2940.0] | [17.0, 17.0] | [155, 151] |
p03085 | u090032260 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\n\nif b=="A":\n print("T")\nif b=="C":\n print("G")\nif b=-G:\n print("C")\nif b==T:\n print("A")', 'b=input()\n\nif b=="A":\n print("T")\nif b=="C":\n print("G")\nif b=="G":\n print("C")\nif b=="T":\n print("A")'] | ['Runtime Error', 'Accepted'] | ['s949816234', 's794685021'] | [2940.0, 2940.0] | [17.0, 17.0] | [110, 114] |
p03085 | u093033848 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 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'] | ['s077443198', 's977283736'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 122] |
p03085 | u093562214 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["n, q = input().split()\nQ = int(q)\ns = input()\nS = list(s)\n\narray = []\ncount = 0\nff = False\nfor i in range(len(S)):\n if len(S) < i+1:\n break\n if S[i] == 'A':\n flag = True\n elif flag == True and S[i] == 'C':\n count += 1\n array.append(-1)\n array.append(count)\n... | ['Runtime Error', 'Accepted'] | ['s894861346', 's180874586'] | [3064.0, 2940.0] | [17.0, 17.0] | [1257, 131] |
p03085 | u094191970 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s=input()\nprint('T' if s=='A' else 'G' of s=='C' else 'A' if s=='T' else 'C')", "s=input()\nprint('T' if s=='A' else 'G' if s=='C' else 'A' if s=='T' else 'C')"] | ['Runtime Error', 'Accepted'] | ['s438189261', 's413905361'] | [2940.0, 2940.0] | [17.0, 17.0] | [77, 77] |
p03085 | u094731123 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nif b =="A"\n print("T")\nelif b =="T"\n print("A")\nelif b =="G"\n print("C")\nelif b =="C"\n print("G")', 'b=input()\nif b =="A":\n print("T")\nelif b =="T":\n print("A")\nelif b =="G":\n print("C")\nelif b =="C":\n print("G")\n'] | ['Runtime Error', 'Accepted'] | ['s465234200', 's014306851'] | [2940.0, 2940.0] | [17.0, 17.0] | [111, 116] |
p03085 | u098923136 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 prtnt('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')\nelse:\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s458751650', 's373576200'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 112] |
p03085 | u103902792 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ndict = {'A':'T','T':'A','G':'C','C':'G'}\nprint(dict(s))", "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'] | ['s726868517', 's709827472'] | [2940.0, 2940.0] | [17.0, 17.0] | [67, 110] |
p03085 | u111225950 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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']\nmax_length = 0\n\nlength = 0\nfor target in s:\n\tif target in acgt:\n\t\tlength += 1\n\t\tif max_length < length:\n\t\t\tmax_length = length\n\telse:\n\t\tlength = 0\n\nprint(max_length)", "b = input()\n\nif b == 'A':\n\tprint('T')\nelif b == 'T':\n\tprint('A')\nelif b == 'C... | ['Wrong Answer', 'Accepted'] | ['s202861538', 's683396276'] | [2940.0, 2940.0] | [17.0, 19.0] | [205, 109] |
p03085 | u111652094 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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"""\nCreated on Mon Apr 1 22:23:40 2019\n\n@author: Owner\n"""\na = []\nb = list(input())\n\nfor item in b:\n if item == "A":\n item_mod = item.replace("A","T")\n if item == "G":\n item_mod = item.replace("G","C")\n if item == "T":\n item_mod = item.replace("T",... | ['Wrong Answer', 'Accepted'] | ['s211437927', 's167541048'] | [3060.0, 3060.0] | [17.0, 17.0] | [400, 402] |
p03085 | u112318601 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\ne_dict={\n 'A':'T',\n 'T':'A',\n 'G':'C',\n 'C':'G'\n}\n\nprint(e_dict[b])\n ", "b=input()\n\ne_dict={\n 'A':'T',\n 'T':'A',\n 'G':'C',\n 'C':'G'\n}\n\nprint(e_dict[b])\n \n"] | ['Runtime Error', 'Accepted'] | ['s986396802', 's738495869'] | [2940.0, 2940.0] | [17.0, 17.0] | [89, 85] |
p03085 | u117193815 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\tprint('T')\nif b=='T':\n\tprint('A')\nif b=='C':\n\tprint('G'):\nif b=='G':\n\tprint('C')", "b=input()\nif b=='A':\n\tprint('T')\nif b=='T':\n\tprint('A')\nif b=='C':\n\tprint('G')\nif b=='G':\n\tprint('C')"] | ['Runtime Error', 'Accepted'] | ['s477031058', 's457109450'] | [2940.0, 2940.0] | [17.0, 17.0] | [102, 101] |
p03085 | u118518526 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')\nelif n == 'T':\n print('A')\nelif n == 'G':\n print('C')\nelse:\n print('G')", "n = input()\n \nif n == 'A':\n print('T')\nelif n == 'T':\n print('A')\nelif n == 'G':\n print('C')\nelse:\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s464759584', 's179805703'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 115] |
p03085 | u121732701 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 "A"==b\n print("T")\nelif "C"==b\n print("G")\nelif "T"==b\n print("A")\nelse:\n print("C")', 'b = input()\n\nif b == "A"\n print("T")\nelif b == "C"\n print("G")\nelif b == "T"\n print("A")\nelse:\n print("C")\n ', 'b = input()\n \nif b=="A":\n print("T")\nelif b=="... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s000137739', 's759169567', 's277531250'] | [2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0] | [114, 123, 117] |
p03085 | u125433590 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["s = input()\nif s == 'A':\n print 'T'\nelif s=='T':\n print 'A'\nelif s=='G':\n print 'C'\nelif s=='C':\n print 'G'", "s = str(input())\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'] | ['s832092958', 's815468470'] | [2940.0, 2940.0] | [17.0, 17.0] | [119, 129] |
p03085 | u126227204 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = [0] * Q\nr = [0] * Q\nfor x in range(Q):\n l[x], r[x] = list(map(int, input().split()))\n\nisAC = [0] * len(S)\nfor x in range(len(S) - 1):\n if S[x] == "A" and S[x + 1] == "C":\n isAC[x] = 1\n\nfor x in range(Q):\n ans = 0\n cut_isAC = isAC[... | ['Runtime Error', 'Accepted'] | ['s724644593', 's128821353'] | [3064.0, 2940.0] | [18.0, 18.0] | [400, 69] |
p03085 | u131406572 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['if b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="C":\n print("G")\nelif b=="G":\n print("C")', 'b=input()\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="C":\n print("G")\nelif b=="G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s963462081', 's335920335'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 119] |
p03085 | u143318682 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 -*-\nb = input()\nA = ['A', 'C', 'G', 'T']\nB = ['A', 'T', 'C', 'G']\nfor i in range(4):\n if b == A[i]:\n print(B[i])", "# -*- coding: utf-8 -*-\nb = input()\nA = ['A', 'C', 'G', 'T']\nB = ['T', 'G', 'C', 'A']\nfor i in range(4):\n if b == A[i]:\n print(B[i])"] | ['Wrong Answer', 'Accepted'] | ['s330140682', 's667625922'] | [2940.0, 2940.0] | [18.0, 17.0] | [142, 142] |
p03085 | u145600939 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ne = 'ACGT'\nprint(e[e.index(b)])", "b = input()\ne = 'ACGT'\nprint(e[3-e.index(b)])\n"] | ['Wrong Answer', 'Accepted'] | ['s010504346', 's568022562'] | [2940.0, 2940.0] | [17.0, 17.0] | [43, 46] |
p03085 | u147118285 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N,Q=map(int,input().split())\nS=input()\nl=list(S)\nn=[0]*(N-1)\nfor i in range(N-1):\n if l[i]=='A':\n if l[i+1]=='C':\n n[i]=1\nfor i in range(Q):\n l,r=map(int,input().split())\n print(sum(n[l-1:r-1]))", "N,Q=map(int,input().split())\nS=input()\nout=''\nfor i in range(Q):\n l,r=map(in... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s304934537', 's449294566', 's397363549'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0] | [221, 153, 56] |
p03085 | u151163404 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 print("C")', 'b = 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")\n'] | ['Runtime Error', 'Accepted'] | ['s023430736', 's270266410'] | [2940.0, 2940.0] | [17.0, 17.0] | [119, 131] |
p03085 | u156383602 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=="C":\n print("G")\nelse:\n print("C")', 's=input()\nif s=="A":\n print("T")\nif s=="T":\n print("A")\nif s=="C":\n print("G")\nif s=="G":\n print("C")'] | ['Wrong Answer', 'Accepted'] | ['s010895281', 's828258718'] | [2940.0, 2940.0] | [17.0, 17.0] | [108, 113] |
p03085 | u157379742 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 int_raw():\n return int(input())\n\ndef ss_raw():\n return input().split()\n\ndef ints_raw():\n return list(map(int, ss_raw()))\n\nN = int_raw()\nmemo = [{} for x in range(N+1)]\n\ndna = ["A","C","G","T"]\n\ndef chk(last4):\n for i in range(len(last4)):\n l = list(last4)\n if i > 0:\n ... | ['Runtime Error', 'Accepted'] | ['s655395453', 's199836899'] | [3064.0, 2940.0] | [17.0, 17.0] | [787, 232] |
p03085 | u159335277 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = 'ACGT'\nb = 'ATCG'\nx = input()\nfor i in range(0, 4):\n if x[0] == a[i]:\n print(b[i])", "a = 'ATCG'\nb = 'TAGC'\nx = input()\nfor i in range(0, 4):\n if x[0] == a[i]:\n print(b[i])"] | ['Wrong Answer', 'Accepted'] | ['s147250696', 's762174854'] | [2940.0, 2940.0] | [17.0, 17.0] | [90, 90] |
p03085 | u159808230 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\nif s == "A":\n print("T")\nelif: s == "T":\n print("A")\nelif s == "C":\n print("G")\nelse:\n print("C")\n', 's = input()\nif s == "A":\n print("T")\nelif s == "T":\n print("A")\nelif s == "C":\n print("G")\nelse:\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s662685347', 's101732647'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 121] |
p03085 | u163320134 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ndic={A:'T',T:'A',C:'G',G:'C'}\nprint(dic[s])", "s=input()\ndic={'A':'T','T':'A','C':'G','G':'C'}\nprint(dic[s])"] | ['Runtime Error', 'Accepted'] | ['s640666329', 's729072291'] | [2940.0, 2940.0] | [17.0, 17.0] | [53, 61] |
p03085 | u164261323 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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())\nprint("T" if a == "A" else "A" if a == "T" else "G" if a == "C" else "C")', 'a = input()\nprint("T" if a == "A" else "A" if a == "T" else "G" if a == "C" else "C")'] | ['Runtime Error', 'Accepted'] | ['s109353630', 's215360104'] | [3064.0, 2940.0] | [18.0, 17.0] | [90, 85] |
p03085 | u164573681 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 _ in range(Q)]\n\nt = [0] * (N+1)\nfor i in range(N):\n t[i+1] = t[i] + (1 if S[i: i+2] == 'AC' else 0)\nans = [t[LR[i][1] - 1] - t[LR[i][0] - 1] for i in range(Q)] \n\nprint(*ans, sep='\\n')", "b = input()\n\ndic = {'A':'T... | ['Runtime Error', 'Accepted'] | ['s378395672', 's104113606'] | [3064.0, 2940.0] | [18.0, 17.0] | [276, 71] |
p03085 | u165233868 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["l1 = ['A','T']\nl2 = ['C','G']\nb = str(input())\nprint(b)\nans = ''\nif b in l1:\n l1.remove(b)\n ans = l1[0]\nif b in l2:\n l2.remove(b)\n ans = l2[0]\nprint(ans)", "l1 = ['A','T']\nl2 = ['C','G']\nb = str(input())\nprint(b)\nans = ''\nif b in l1:\n l1.remove(b)\n ans = t1[0]\nif b in l2:\n l2.... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s090603370', 's782835986', 's074745044'] | [2940.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [165, 165, 156] |
p03085 | u166621202 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")\nelse b == T:\n print("A")', 'b = input()\nif b == "A":\n print("T")\nelif b == "C":\n print("G")\nelif b == "G":\n print("C")\nelse b == "T":\n print("A")\n', 'b = input()\n\nif b == "A":\n print("T")\nelif b == "C":\... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s220438353', 's340762747', 's320461386'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [113, 122, 114] |
p03085 | u168416324 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")\nif x=="T":\n print("A")\nif x=="G":\n print("C")\nelse:\n print("G")\n', 'x=input()\nif x="A":\n print("T")\nif x="T":\n print("A")\nif x="G":\n print("C")\nelse:\n print("G")', 'x=input()\nif x=="A":\n print("T")\nif x=="T":\n print("A")\nif x=="G":\n print("C")\nif x==... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s735625201', 's803844491', 's566280121'] | [8668.0, 8724.0, 8920.0] | [22.0, 22.0, 23.0] | [101, 97, 106] |
p03085 | u169834179 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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','T','C','G']\n\nind = base.index(input())\nif(ind%2 == 0):\n printf(base[ind+1])\nelse:\n printf(base[ind-1])", "base = ['A','T','C','G']\n \nind = base.index(input())\nif(ind%2 == 0):\n print(base[ind+1])\nelse:\n print(base[ind-1])"] | ['Runtime Error', 'Accepted'] | ['s912951468', 's638743899'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 116] |
p03085 | u175590965 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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:\n print("A")\nelif b == A:\n print("T")\nelif b == G:\n print("C")\nelse:\n print("G")', 'b = input()\nif b == "T":\n print("A")\nelif b == "A":\n print("T")\nelif b == "G":\n print("C")\nelse:\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s079297779', 's339168528'] | [2940.0, 2940.0] | [17.0, 17.0] | [106, 112] |
p03085 | u177411511 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nstdin = sys.stdin\n\nni = lambda: int(ns())\nna = lambda: list(map(int, stdin.readline().split()))\nns = lambda: stdin.readline().rstrip() # ignore trailing spaces\n\nli = ["A","T","G","C"]\nmax = 0\nct = 0\ns = input()\nfor ch in s:\n if ch in li:\n ct += 1\n if max < ct:\n ... | ['Wrong Answer', 'Accepted'] | ['s916929249', 's762789830'] | [3060.0, 3060.0] | [17.0, 17.0] | [347, 304] |
p03085 | u178192749 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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.replace('A','a').replace('T','t').replace('C','c').replace('G','g')\nprint(b.replace('a','T').replace('t','A').replace('c','G').replace('g','C'))", "b = input()\nprint(b.replace('A','a').replace('T','t').replace('C','c').replace('G','g').replace('a','T').replace('t','A').replace('c','G').replace('g','C... | ['Wrong Answer', 'Accepted'] | ['s818973967', 's878215646'] | [2940.0, 2940.0] | [17.0, 17.0] | [158, 156] |
p03085 | u178392375 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\n\nprint(b)\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', '\nb = 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'] | ['Wrong Answer', 'Accepted'] | ['s774127461', 's193076207'] | [2940.0, 2940.0] | [17.0, 17.0] | [142, 131] |
p03085 | u179285430 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")\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'] | ['s819436010', 's239466159'] | [2940.0, 2940.0] | [18.0, 17.0] | [106, 113] |
p03085 | u180528413 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nN, S = map(int, input().split(\' \'))\npattern = "AC+"\nT = input()\nfor _ in range(S):\n first,final = map(int, input().split(\' \'))\n print(first, final)\n result = re.findall(pattern, T[first -1:final])\n print(result)\n print(len(result))', 'import re\n\nN, S = map(int, input().split(... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s313012347', 's923587916', 's194284680'] | [3188.0, 3188.0, 2940.0] | [21.0, 19.0, 17.0] | [257, 207, 72] |
p03085 | u181215519 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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() )\nelist = [ "A", "C", "G", "T" ]\nprint( elist[ 2 - elist.index( b ) ] )', 'b = str( input() )\nelist = [ "A", "C", "G", "T" ]\nprint( elist[ 3 - elist.index( b ) ] )'] | ['Wrong Answer', 'Accepted'] | ['s438932439', 's798405646'] | [2940.0, 2940.0] | [17.0, 17.0] | [88, 88] |
p03085 | u182004566 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 get_answer(s):\n count = 0\n for i, c in enumerate(s):\n if i == len(s) - 1:\n return count\n if c == "A" and s[i + 1] == "C":\n count += 1\n\n return count\n\nn, q = map(int, input().split())\ns = str(input())\nquestions = []\nfor i in range(q):\n a, b = map(int, i... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s431791346', 's748925091', 's332743606'] | [3064.0, 3064.0, 2940.0] | [17.0, 17.0, 17.0] | [440, 440, 93] |
p03085 | u183200783 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\na = ['A', 'C', 'G', 'T']\nfor i in range(len(a)):\n if a[i] == b:\n print(a[i])\n break\n", "b = input()\n\na = ['A', 'C', 'G', 'T']\nfor i in range(len()):\n if a[i] == b:\n print(a[i])\n break", "b = input()\n\na = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}\n\nprint(a[b])"] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s291669164', 's633898331', 's114024804'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [104, 102, 66] |
p03085 | u185966380 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nN,Q = map(int,sys.stdin.readline().rstrip().split())\nS = sys.stdin.readline().rstrip()\nfor _ in range(Q):\n l,r = map(int,sys.stdin.readline().rstrip().split())\n print(S[l-1:r].count("AC"))\n del l\n del r', 'star = {"A":"T",\n "T":"A",\n "C":"G",\n "G":"C"}\nprint(star[input(... | ['Runtime Error', 'Accepted'] | ['s596019240', 's017444589'] | [2940.0, 2940.0] | [17.0, 18.0] | [218, 88] |
p03085 | u191086108 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["dic = {}\ndic['A'] = T\ndic['T'] = A\ndic['C'] = G\ndic['G'] = C\n\ndef a(b):\n\treturn dic[b]\n\na=input('请输入字母：')\nprint(a(a))", "dic = {}\ndic['A'] = 'T'\ndic['T'] = 'A'\ndic['C'] = 'G'\ndic['G'] = 'C'\n\ndef a(b):\n\treturn dic[b]\n\na=input()\nprint(a(a))\n", "dic = {}\ndic['A'] = 'T'\ndic['T'] = 'A'\ndic['C'] =... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s577046616', 's671636428', 's673054742', 's820715418', 's376612125'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0] | [129, 118, 117, 109, 120] |
p03085 | u197577508 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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==G:\n print('C')\nelif b==T:\n print('A')\nelse:\n print('G')\n \n ", "b = input()\n\nif b=='A':\n print('T')\nelif b=='G':\n print('C')\nelif b=='T':\n print('A')\nelse:\n print('G')\n \n \n"] | ['Runtime Error', 'Accepted'] | ['s798977044', 's393826595'] | [3060.0, 2940.0] | [20.0, 17.0] | [119, 126] |
p03085 | u201856486 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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# import math\n# import itertools\n# import numpy as np\n# import collections\n\n"""Template"""\n\n\nclass IP:\n \n\n def __init__(self):\n self.input = sys.stdin.readline\n\n def I(self):\n \n return int(self.input())\n\n def S(self):\n \n return self.inpu... | ['Wrong Answer', 'Accepted'] | ['s384595567', 's813046079'] | [3192.0, 2940.0] | [18.0, 17.0] | [4791, 114] |
p03085 | u202634017 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = 0\ntmp = 0\nfor i in range(len(s)):\n if s[i] == "A" or s[i] == "T" or s[i] == "G" or s[i] == "C" :\n tmp += 1\n elif tmp > ans :\n ans = tmp\n tmp = 0\n\nprint(ans)', 'a = input()\nif a == "A" : print("T")\nif a == "T" : print("A")\nif a == "G" : print("C")\nif a == "C" ... | ['Wrong Answer', 'Accepted'] | ['s944793922', 's922695584'] | [2940.0, 2940.0] | [17.0, 17.0] | [201, 112] |
p03085 | u204208382 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")', 'b=input()\n \nif b=="A":\n print("T")\nelif b=="T":... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s568340905', 's992011649', 's740829762'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [121, 117, 121] |
p03085 | u204260373 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=int(input())\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="G":\n print("C")\nelif 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("G")\n'] | ['Runtime Error', 'Accepted'] | ['s151048090', 's203248899'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 112] |
p03085 | u204842730 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nx = input()\n\nif x == 'A':\n\tprint('T')\nelif x == 'T'\n\tprint('A')\nelif x == 'G'\n\tprint('C')\nelif x == 'C'\n\tprint('G')", "# coding: utf-8\n\nx = input()\n\nif x == 'A':\n\tprint('T')\nelif x == 'T':\n\tprint('A')\nelif x == 'G':\n\tprint('C')\nelif x == 'C':\n\tprint('G')"] | ['Runtime Error', 'Accepted'] | ['s836146222', 's871009335'] | [2940.0, 2940.0] | [17.0, 17.0] | [132, 135] |
p03085 | u206460435 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nimport numpy as np\n\nreadInt = lambda: int(sys.stdin.readline())\nreadIntN = lambda: [int(v) for v in sys.stdin.readline().split(" ")]\n\n\nn = readInt()\nM = 10 ** 9 + 7\n\n\ndp = np.zeros((n + 1, 256), dtype=np.uint32)\ndp[0, 255] = 1\n\n\nfor i in range(n):\n for j4 in [0, 64, 128, 192]:\n ... | ['Runtime Error', 'Accepted'] | ['s998660127', 's277182893'] | [12428.0, 2940.0] | [150.0, 17.0] | [959, 101] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.