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 | u399721252 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 == "G":\n print("C")\nelse:\n print("G")', '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")'] | ['Runtime Error', 'Accepted'] | ['s711050259', 's232551129'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 113] |
p03085 | u399973890 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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('G')\nelif b == 'G':\n print('C')\nelif b == 'C':\n print('T')\nelse:\n print('A')\n", "b = input()\nif b == 'T':\n print('A')\nelif b == 'G':\n print('C')\nelif b == 'C':\n print('G')\nelse:\n print('T')\n"] | ['Wrong Answer', 'Accepted'] | ['s818631881', 's684590082'] | [2940.0, 2940.0] | [17.0, 17.0] | [121, 121] |
p03085 | u400603400 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=="C":\n print("G")\nelif b=="G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s968315383', 's466268448'] | [2940.0, 2940.0] | [18.0, 17.0] | [105, 113] |
p03085 | u401731473 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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(inut())\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 \n\n", "b = str(inut())\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 \n\n", "b = input()\nc = {'A': '... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s029606479', 's389252662', 's871413039'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [131, 131, 68] |
p03085 | u404678206 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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:\n print("G")\n '] | ['Runtime Error', 'Accepted'] | ['s835703890', 's493317661'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 112] |
p03085 | u407535999 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nls=[];rs=[]\nfor i in range(Q):\n l,r=map(int,input().split())\n n=0;a=False\n for k in S[(l-1):(r)]:\n if k!="A" and a==False:\n pass\n elif k=="A":\n a=True\n elif a:\n if k=="C":\n n+=1\n ... | ['Runtime Error', 'Accepted'] | ['s971801539', 's119079569'] | [3060.0, 2940.0] | [17.0, 19.0] | [359, 119] |
p03085 | u416397108 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')\nelif a == 'C':\n print('T')\nelif a == 'G':\n print('C')\nelif a == 'T':\n print('G')", "a = input()\nif a == 'A':\n\tprint('A')\nelif a == 'C':\n\tprint('T')\nelif a == 'G'\n\tprint('C')\nelif a == 'T':\n \tprint('G')", "a = int(input())\nif a == 'A':\n\tprint('A')\nelif ... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s037918051', 's311696964', 's498658299', 's073167496'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [121, 118, 123, 121] |
p03085 | u427344224 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['N = int(input())\n\nmod = 10 ** 9 + 7\n\ndp = [[[[0] * 4 for _ in range(4)] for _ in range(4)] for _ in range(N + 1)]\n\ndp[0][3][3][3] = 1\n\nprint(dp)\nfor i in range(N):\n for j in range(4):\n for k in range(4):\n for m in range(4):\n if dp[i][j][k][m] == 0:\n ... | ['Runtime Error', 'Accepted'] | ['s375118119', 's218590409'] | [3064.0, 2940.0] | [17.0, 16.0] | [1038, 122] |
p03085 | u430414424 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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())\natcg = [["A", "T"],["C", "G"]]\n\nfor i in atcg:\n if b in i:\n print(i.remove(b)[0])\n break', 'b = str(input())\natcg = [["A","T"]["C","G"]]\n\nfor i in atcg:\n if b in i:\n print(i.pop(b)[0])\n break', 'print("ATACGC"["ATACGC".find(str(input()))+1])\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s307588465', 's416293300', 's668195753'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [112, 106, 47] |
p03085 | u430543459 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\',\'T\':\'A\',\'C\':\'G\',\'G\':\'C\'}\nprint(c[b])\n', "b=input()\nc={'A':'T','T':'A','C':'G','G':'C'}\nprint(c[b])\n"] | ['Wrong Answer', 'Accepted'] | ['s550599046', 's476966273'] | [2940.0, 2940.0] | [17.0, 18.0] | [93, 58] |
p03085 | u430911663 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nstr = input()\n\nif str =='A' :\n str = 'T'\n break\nelif str == 'T' :\n str = 'A'\n break\nelif str == 'C':\n str = 'G'\nelif str == 'G':\n str = 'C'\n\nprint(str)", "# coding: utf-8\n\nstr = input()\n\nif str =='A' :\n str = 'T'\nelif str == 'T' :\n str = 'A'\nelif str == ... | ['Runtime Error', 'Accepted'] | ['s283698492', 's462603032'] | [2940.0, 2940.0] | [17.0, 17.0] | [186, 166] |
p03085 | u433786109 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ns = (("A", "T"), ("C", "G"))\nd = dict(s)+ dict(i[::-1] for i in s)\n\nprint(d[a])', '#!/usr/bin/env python\na = input()\ns = (("A", "T"), ("C", "G"))\nd = dict(s)\nd.update(dict(i[::-1] for i in s))\n\nprint(d[a])\n'] | ['Runtime Error', 'Accepted'] | ['s555570525', 's603375851'] | [2940.0, 2940.0] | [17.0, 17.0] | [91, 123] |
p03085 | u434872492 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S = input()\nN = len(S)\nans = 0\nfor i in range(N):\n for j in range(i,N):\n if all('ATGC'.count(c) == 1 for c in S[i:j+1]):\n ans = max(ans,j-i+1)\n \nprint(ans)\n", "S = input()\nN = len(S)\nans = 0\nfor i in range(N):\n for j in range(i,N):\n if all('ATGC'.count(c) == 1 for c in S[i:j+1]):\n ... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s406178093', 's550907400', 's023049856'] | [2940.0, 3060.0, 2940.0] | [17.0, 17.0, 17.0] | [170, 166, 156] |
p03085 | u436982376 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=list(input())\nvalue=[0]*n\nans_list=[]\nlength=[]\n \nfor i in range(len(s)-1):\n value[i+1]=value[i]+(1 if s[i]=='A' and s[i+1]=='C' else 0)\n \nfor i in range(q):\n l,r=map(int,input().split())\n print(value[r-1]-value[l-1])", "a = input()\n\nif a == 'A':\n print('T')\nel... | ['Runtime Error', 'Accepted'] | ['s581631986', 's622785419'] | [3064.0, 8964.0] | [17.0, 24.0] | [256, 131] |
p03085 | u439392790 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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", "b=input()\nif b=='A':\n print('T')\nelif b=='T':\n print('A')\nelif b=='C'... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s558438628', 's931084397', 's513241252'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [109, 104, 113] |
p03085 | u440129511 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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(b.translate(str.maketrans('A':'x','C':'y','T':'A','G':'C','x':'C','y':'G')))", "b=str(input())\nprint(b.translate(b.maketrans({'A':'x','C':'y','T':'A','G':'C','x':'C','y':'G'})))", "b=input()\nprint(b.translate(b.maketrans({'A':'x'},{'C':'y'},{'T':'A'},{'G':'C'},{'x':'C'},{'y':'G'})))", "b=str(input(... | ['Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s102584312', 's173446192', 's477258486', 's511581111', 's910094548', 's934955091', 's739637770'] | [2940.0, 2940.0, 3060.0, 3060.0, 2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0, 17.0, 17.0, 17.0, 17.0] | [92, 97, 102, 107, 90, 97, 81] |
p03085 | u440608859 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=="T":\n print("A")\n elif b=="G":\n print("C")', 'b=input()\nif b=="A":\n print("T")\nelif b=="C":\n print("G")\nelif b=="T":\n print("A")\nelif b=="G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s465585156', 's845265642'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 111] |
p03085 | u441246928 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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' )\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 \n"] | ['Runtime Error', 'Accepted'] | ['s253063920', 's908478031'] | [2940.0, 2940.0] | [17.0, 17.0] | [138, 151] |
p03085 | u443657910 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["c=input()\nif c='A':\n print('T')\nelif c='T':\n print('A')\nelif c='G':\n print('C')\nelse:\n print('G')", "c=input()\nif c=='A':\n print('T')\nelif c=='T':\n print('A')\nelif c=='G':\n print('C')\nelse:\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s202739923', 's339613017'] | [2940.0, 2940.0] | [17.0, 17.0] | [101, 104] |
p03085 | u448655578 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['v = input()\nif v = "A":\n print("T")\nelif v = "T":\n print("A")\nelif v = "C":\n print("G")\nelif v = "G":\n print("C")', 'v = input()\nif v == "A":\n print("T")\nelif v == "T":\n print("A")\nelif v == "C":\n print("G")\nelif v == "G":\n print("C")\n'] | ['Runtime Error', 'Accepted'] | ['s045094802', 's162391996'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 122] |
p03085 | u450846605 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["str = input()\n\nif (str == 'A'):\n print('T')\nelse if (str == 'T'):\n print('A')\nelse if (str == 'C'):\n print('G')\nelse:\n print('C')\n\n \n", "str = input()\nstr_arr = list(str)\natcg = ['A', 'T', 'C', 'G']\n\nforward = 0\nfor i in range(len(str_arr)):\n if str_arr[i] in atcg:\n \tbreak\n else:\n for... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s518264580', 's691406617', 's122800610'] | [2940.0, 3060.0, 2940.0] | [17.0, 17.0, 18.0] | [138, 333, 122] |
p03085 | u451017206 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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': print('T')\nelif a == 'T':print('A')\nelse a == 'C': print('G')\nelse:print('C')", "a = input()\nif a == 'A': print('T')\nelif a == 'T':print('A')\nelif a == 'C': print('G')\nelse:print('C')"] | ['Runtime Error', 'Accepted'] | ['s713644015', 's702137593'] | [2940.0, 2940.0] | [17.0, 17.0] | [102, 102] |
p03085 | u452844010 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["str = input()\ncnt = 0\nmax = 0\n\nfor i in range(len(str)):\n if str[i] == 'A' or str[i] == 'C' or str[i] == 'G' or str[i] == 'T':\n cnt += 1\n else:\n if max < cnt:\n max = cnt\n cnt = 0\n\nif max < cnt:\n max = cnt\n cnt = 0\n\nprint(max)", "str = input()\n\nif str = 'A':\n print('T')\nelse ... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s284402419', 's329170485', 's199321538'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [247, 157, 152] |
p03085 | u453815934 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['c = input()\nprint("A" if c == "T" else "T" if c == "A" else "C" if c == "G" else "G" if c == "G")', 'c = input()\nprint("A" if c == "T" else "T" if c == "A" else "C" if c == "G" else "G")\n'] | ['Runtime Error', 'Accepted'] | ['s287410158', 's803558237'] | [2940.0, 2940.0] | [17.0, 17.0] | [97, 86] |
p03085 | u454735747 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 "A" == "b":\n print("T")\nelif "T" == "b":\n print("A")\nelif "C" == "b":\n print("G")\nelse:\n print("C")', 'b = input()\n\nif "A" == "b":\n print("T")\nelif "T" == "b":\n print("A")\nelif "C" == "b":\n print("G")\nelse:\n print("C")', "b = input()\nif b == 'A':\n print('T')\nelif b == 'T':\n pr... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s038615055', 's151008653', 's033900063'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [108, 121, 120] |
p03085 | u456033454 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = {'A':'A','C':'T','G':'C','T':'G'}\nprint(Enki[input()])", "Enki = {'A':'T','T':'A','C':'G','G':'C'}\nprint(Enki[input()])"] | ['Wrong Answer', 'Accepted'] | ['s952092527', 's795275644'] | [2940.0, 2940.0] | [17.0, 17.0] | [61, 61] |
p03085 | u456879806 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\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'] | ['s643716093', 's159407589'] | [9024.0, 8968.0] | [25.0, 24.0] | [117, 130] |
p03085 | u457460736 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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#input = sys.stdin.readlines\n\nlist={"A":"T","T":"A","G":"C","C":"G"}\nb = sys.stdin.readlines()\nprint(list[b])', 'import sys\ninput = sys.stdin.readline\n\nlist={"A":"T","T":"A","G":"C","C":"G"}\nb = input()\nprint(list[b])', 'import sys\nlines = sys.stdin.readlines()\n\nlist={"A":"T","T":"A","G":"C","... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s010014379', 's151455515', 's523471795', 's527635336', 's774636286', 's910759171', 's383971836'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 18.0, 19.0] | [120, 104, 105, 104, 90, 105, 112] |
p03085 | u463655976 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nc=m=0\nfor x in S:\n #print((m,c,x,"ACGT".find(x)))\n if "ACGT".find(x)>=0:\n c+=1\n m = max(m, c)\n\nprint(m)\n', "T='ACGT'\nprint(T[T.find(input())^1])\n", 'S=input()\n\nc=m=0\nfor x in S:\n #print((m,c,x,"ACGT".find(x)))\n if "ACGT".find(x)<0:\n m = max(m, c)\n c = 0\n c+=1\nm = max(m... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s234959010', 's439086240', 's783915602', 's870624082'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0, 17.0] | [123, 37, 146, 37] |
p03085 | u464689569 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['Helix=input()\nif Helix==\'A\':\n print ("G")\nelif Helix=="G":\n print ("A")\nelif Helix=="G":\n print ("C")\nelif Helix=="C":\n print ("G")', 'Helix=input()\nif Helix==\'A\':\n print ("T")\nelif Helix=="T":\n print ("A")\nelif Helix=="G":\n print ("C")\nelif Helix=="C":\n print ("G")'] | ['Wrong Answer', 'Accepted'] | ['s639927621', 's553126730'] | [2940.0, 2940.0] | [17.0, 17.0] | [143, 143] |
p03085 | u464912173 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['s = input()\n \nans = [0]\ncnt = 0\nfor i in s:\n if (i == "A" or i == "C" or i == "G" or i == "T"):\n cnt+=1\n else:\n if (cnt > 0):\n ans.append(cnt)\n cnt = 0\nans.append(cnt)\nprint(max(ans))', 's = input()\n\nans =[0]\ncnt = 0\n\nfor i in s:\n\tif (i == "A" or i == "C" o... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s163699209', 's552895829', 's818248995', 's824469884', 's008128844'] | [3060.0, 2940.0, 3060.0, 2940.0, 2940.0] | [17.0, 17.0, 19.0, 18.0, 17.0] | [225, 183, 225, 136, 86] |
p03085 | u465422274 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 functools\nimport math\n\nvalues = [290021904, 927964716, 826824516, 817140688]\ngcd = functools.reduce(math.gcd, values)\nprint(gcd)', 'n = input()\n\nif(n == \'A\'):\n print(\'T\')\nelif(n == \'T\'):\n print(\'A\')\nelif(n == \'C\'):\n print("G")\nelif(n == \'G\'):\n print(\'C\')'] | ['Runtime Error', 'Accepted'] | ['s792766800', 's702125314'] | [3572.0, 2940.0] | [22.0, 17.0] | [135, 134] |
p03085 | u466143662 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=atr(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")', 'a=str(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")'] | ['Runtime Error', 'Accepted'] | ['s525205638', 's032492278'] | [2940.0, 2940.0] | [17.0, 17.0] | [119, 120] |
p03085 | u466331465 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\ncnt = 0\nfor i in range(len(S)):\n if S[i] == "A" or S[i] =="G" or S[i] =="C" or S[i] =="T":\n cnt += 1\n else:\n ans = max(ans,cnt)\n cnt = 0\n\nprint(max(ans,cnt))\n', 'b = input()\nif b=="A":\n print("T")\nelif b=="T":\n print("A")\nelif b=="G":\n print("C")\nelse :\n print("G"... | ['Wrong Answer', 'Accepted'] | ['s345965809', 's283727105'] | [2940.0, 2940.0] | [17.0, 17.0] | [189, 107] |
p03085 | u474925961 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nif sys.platform ==\'ios\':\n sys.stdin=open(\'input_file.txt\')\n \nb=input()\n\nif b==A:\n\tprint("T")\nif b==T:\n\tprint("A")\nif b==G:\n\tprint("C")\nif b==C:\n\tprint("G")\n\n', 'import sys\n\nif sys.platform ==\'ios\':\n sys.stdin=open(\'input_file.txt\')\n \nb=input()\n\nif b=="A":\n\t... | ['Runtime Error', 'Accepted'] | ['s751048664', 's604282915'] | [2940.0, 2940.0] | [17.0, 18.0] | [175, 183] |
p03085 | u475598608 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S=list(input())\nmax_count=0\ncount=0\nfor i in range(len(S)):\n for j in range(i,len(S)):\n if S[j]=='A' or S[j]=='C' or S[j]=='T' or S[j]=='G':\n count+=1\n max_count=max(max_count,count)\n else:\n count=0\n break\n count=0\nprint(max_count) ", "\nS=... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s018429155', 's499501031', 's753141260'] | [3060.0, 2940.0, 3060.0] | [19.0, 17.0, 19.0] | [298, 318, 117] |
p03085 | u477977638 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')\nif b='T':print('A')\nif b='C':print('G')\nif b='G':print('C')", "b=input()\nif b=='A':print('T')\nif b=='T':print('A')\nif b=='C':print('G')\nif b=='G':print('C')\n"] | ['Runtime Error', 'Accepted'] | ['s907631560', 's354237296'] | [2940.0, 2940.0] | [17.0, 17.0] | [89, 94] |
p03085 | u480138356 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input().strip()\nif b == "A":\n print("C")\nelif b == "C":\n print("A")\nelif b == "G":\n print("T")\nelif b == "T":\n print("G")\n', 'b = input().strip()\nif b == "A":\n print("c")\nelif b == "C":\n print("A")\nelif b == "G":\n print("T")\nelif b == "T":\n print("G")\n', 'b = input().stri... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s220008559', 's670448003', 's395646857'] | [2940.0, 2940.0, 2940.0] | [17.0, 18.0, 18.0] | [138, 138, 138] |
p03085 | u480200603 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['input("ATCG"["TAGC".find(input())])\n', 'print("ATCG"["TAGC".find(input())])\n'] | ['Runtime Error', 'Accepted'] | ['s332767566', 's601220037'] | [2940.0, 2940.0] | [18.0, 17.0] | [36, 36] |
p03085 | u481026841 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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)\n\n ', 'b = 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 = input('')\nif b = 'A':\n print('T')\nelif b = 'C':\n p... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s254154368', 's405554523', 's822066618', 's311182687'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [111, 116, 120, 123] |
p03085 | u484229314 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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='ATCG'\na['TAGC'.index(input())]\n", "a='ATCG'\na['ACGT'.index(input())]\n", "a='ATCG'\nprint(a['TAGC'.index(input())])\n"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s556018947', 's969810819', 's081716112'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [34, 34, 41] |
p03085 | u485301559 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 Fri Apr 5 13:45:00 2019\n\n@author: adachi-lab\n"""\n\ninput_code = input(\'入力;\')\n\nlist_1 = []\n\nif input_code == \'A\' or input_code == \'T\':\n list_1 = [\'A\',\'T\']\n list_1.remove(str(input_code))\n print(list_1[0])\n \nelse:\n list_1 = [\'C\',\'G\']\n... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s022640494', 's130355841', 's507776331', 's625313424', 's397298205'] | [2940.0, 3064.0, 3064.0, 2940.0, 3060.0] | [18.0, 17.0, 17.0, 18.0, 18.0] | [356, 401, 401, 356, 347] |
p03085 | u494379309 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['_, num_query = list(map(int,input().split()))\nstring = input()\ndfor _ in range(num_query):\n left, right = list(map(int,input().split()))\n sub_string = string[left-1:right]\n print(sub_string.count("AC"))', 'base = input()\nif base == "A"\n\tprint("T")\nif base == "T"\n\tprint("A")\nif base == "C"\n\tprint("G")... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s289697079', 's991677163', 's684818419'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [205, 122, 126] |
p03085 | u497326082 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ns2 = ""\nlist_ = []\nsn = 0\ni = len(s)\nfor i in range(0,i):\n if s[i] == "A" or s[i] == "C" or s[i] == "G" or s[i] == "T":\n s2 += s[i]\n else:\n if not s2 == "":\n list_.append(s2)\n s2 = ""\nif len(list_) != 0:\n for i in range(0, len(list_)):\n if len(list_[i]) > sn:\n sn = len(list_[i])\n ... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s270338882', 's705200648', 's171555518'] | [3064.0, 3064.0, 2940.0] | [17.0, 17.0, 20.0] | [356, 356, 139] |
p03085 | u498575211 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["input1 = input().split()\nN = input1[0]\nQ = input1[1]\nS = input()\n\nflag = 0\ncount = 0\nresult = []\n\nfor q in range(int(Q)):\n\t\n\tinput3 = input().split()\n\t\n\tl = int(input3[0])\n\tr = int(input3[1])+1\n\t\n\tfor s in (range(l,r)):\n\t\t\n\t\t#print(s)\n\t\tif S[s-1] == 'A':\n\t\t\tflag += 1\n\t\t\t\n\t\te... | ['Runtime Error', 'Accepted'] | ['s342891113', 's766984690'] | [3064.0, 2940.0] | [18.0, 17.0] | [441, 72] |
p03085 | u499138699 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["1 b = input()\n2 c = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\n3 print(c[b])", "b = input()\nc = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\nprint(c[b])"] | ['Runtime Error', 'Accepted'] | ['s444421086', 's233538445'] | [8948.0, 8972.0] | [28.0, 23.0] | [74, 68] |
p03085 | u502028059 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 =[map(int,input().split()) for i in range(Q)]\n\nfor i,x in l:\n s1 = S[i-1:x]\n print(s1.count('AC'))", "B = input()\nif B == 'A':\n ans = 'T'\nelif B == 'T':\n ans = 'A'\nelif B == 'C':\n ans = 'G'\nelif B == 'G':\n ans = 'C'\nprint(ans)"] | ['Runtime Error', 'Accepted'] | ['s247682768', 's861718728'] | [2940.0, 2940.0] | [17.0, 18.0] | [149, 136] |
p03085 | u505893372 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = str(input())\n\nif b = A:\n\tprint("T")\nelif b = T:\n\tprint("A")\nif b = C:\n\tprint("G")\nelif b = G:\n\tprint("C")', 'b = input()\n\nif b == A :\n\tprint("T")\nelif b == T :\n\tprint("A")\nif b == C :\n\tprint("G")\nelif b == G :\n\tprint("C")', 'b = input()\n\nif b == A :\n\tprint("T")\nelif b == T :\n\tprin... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s288775917', 's364598896', 's464605590', 's553065067', 's803888825'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0, 17.0, 17.0] | [109, 112, 114, 108, 127] |
p03085 | u513900925 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nm = [list(map(int,input().split())) for i in range(q)]\ncount = [0]*(N+1)\n \nfor i in range(n):\n if S[i:i+2] == 'AC':\n comu[i+1] = comu[i] + 1\n else:\n comu[i+1] = comu[i]\n \nfor l,r in list:\n print(count[r-1]-count[l-1])", "n,q = map(int(input... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s208249846', 's577594739', 's709015649', 's987254620', 's538493361'] | [3064.0, 3064.0, 2940.0, 3060.0, 2940.0] | [17.0, 18.0, 17.0, 17.0, 17.0] | [283, 279, 161, 281, 158] |
p03085 | u515364861 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')\n elif b == 'T':\n print('A')\n elif b == 'C':\n print('G')\n else:\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'] | ['s749878030', 's389739542'] | [2940.0, 2940.0] | [17.0, 17.0] | [164, 118] |
p03085 | u516554284 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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')", "s=input()\nif s=='A':\n print('T')\nelif s=='T':\n print('A')\nelif s=='C':\n print('G')\... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s004262194', 's354836535', 's501758683'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [101, 101, 105] |
p03085 | u516613126 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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")\nif b == "C":\n print("A")\nif b == "T":\n print("G")\nif b == "G":\n print("T")', 's = list(input())\ncount = 0\nm = 0\nfor i in range(len(s)):\n if s[i] == "A" or s[i] == "T" or s[i] == "C" or s[i] == "G":\n count += 1\n else:\n if m < count:\n m = count\n ... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s439612270', 's781761214', 's837592670', 's373109869'] | [2940.0, 2940.0, 2940.0, 2940.0] | [18.0, 18.0, 18.0, 17.0] | [115, 230, 229, 55] |
p03085 | u524534026 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nif b==A:\n print(T)\nif b==T:\n print(A)\nif b==G:\n print(C)\nif b==C:\n print(G)\n', "b=input()\nif b=='A':\n print('T')\nif b=='T':\n print('A')\nif b=='G':\n print('C')\nif b=='C':\n print('G')\n"] | ['Runtime Error', 'Accepted'] | ['s645246507', 's151707235'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 114] |
p03085 | u525227429 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['N = int(input())\nmemo = [{} for _ in range(N + 1)]\n\ndef ok(last4):\n for i in range(4):\n s = list(last4)\n if i >= 1:\n s[i - 1]. s[i] = s[i], s[i - 1]\n if "".join(s).count("AGC") >= 1:\n return False\n return True\n\ndef dfs(last3, n):\n if last3 in memo[n]:\n return memo[n][last3]\n ... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s141030337', 's428315265', 's213836771'] | [3064.0, 3060.0, 2940.0] | [17.0, 19.0, 17.0] | [491, 265, 112] |
p03085 | u526818929 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = str(input())\n\nif b == A:\n print("T")\nif b == T:\n print("A")\nif b == C:\n print("G")\nif b == G:\n print("C")', 'b = str(input())\n\nif b == "A":\n print("T")\nif b == "T":\n print("A")\nif b == "C":\n print("G")\nif b == "G":\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s096876767', 's650593334'] | [8876.0, 8844.0] | [21.0, 30.0] | [121, 129] |
p03085 | u527261492 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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','C','G','T']\nb=['A','T','C','G']\ni=a.index(b)\nprint(b[i])", "b=input()\na=['A','C','G','T']\nc=['A','T','C','G']\ni=a.index(b)\nprint(c[i])\n", "b=input()\na=['A','C','G','T']\nc=['T','G','C','A']\ni=a.index(b)\nprint(c[i])\n"] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s217861633', 's731965559', 's051680542'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [74, 75, 75] |
p03085 | u538774896 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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, os\nimport collections\n\ndef solve(input_stream):\n table = {\n "A": "T",\n "T": "A",\n "C": "G",\n "G": "C"\n }\n ans = ""\n for i in input_stream.readline():\n ans += table[i]\n return [ans]\n\nif __name__ == "__main__":\n outputs = solve(sys.stdin)\n for line in outputs:\n ... | ['Runtime Error', 'Accepted'] | ['s801413944', 's422441659'] | [3316.0, 3316.0] | [21.0, 22.0] | [314, 322] |
p03085 | u539806549 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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())\nb = "A"\nc = "C"\nd = "G"\ne = "T"\n\nif a == e:\n print("G")\nif a == d:\n print("T")\nif a == b:\n print("C")\nif a == c:\n print("A")', 'a = str(input())\nb = "A"\nc = "C"\nd = "G"\ne = "T"\n\nif a == e:\n print("G")\nif a == d:\n print("T")\nif a == b:\n print("C")\nif a == c:\n print("A... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s056692870', 's372847248', 's316149745'] | [2940.0, 2940.0, 3060.0] | [18.0, 17.0, 17.0] | [145, 145, 145] |
p03085 | u541921833 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input().strip()\nd = {"A": "C", "G": "T", "C": "A", "T": "G"}\nprint(d[b])', "a, loop = input().split()\nstring = input()\n\nfor i in range(int(loop)):\n j, k = input().split()\n print(string[int(j)-1:int(k)].count('AC'))", "b = input()\nd = {'A': 'C', 'G': 'T', 'C': 'A', 'T': 'G'}\nprint(d[b])", "d = {'A': 'C'... | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s133447593', 's234374904', 's683348436', 's875627956', 's972273817'] | [2940.0, 3060.0, 2940.0, 2940.0, 2940.0] | [17.0, 20.0, 17.0, 17.0, 17.0] | [76, 140, 68, 56, 76] |
p03085 | u542932305 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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)\n", "b = input()\nif b == 'A':\n print('T')\nelif b == 'T':\n print('A')\nelif b == 'C':\n print('G')\nelse:\n print('C')\n"] | ['Runtime Error', 'Accepted'] | ['s226430636', 's338594964'] | [2940.0, 2940.0] | [19.0, 18.0] | [113, 121] |
p03085 | u543954314 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['n = int(input())\nmod = 10**9+7\na = [1]*16\nno = [0,0]\nfor _ in range(n-2):\n b = [0]*16\n b[0] = a[0] + a[4] + a[8] + a[12]\n b[1] = a[0] + a[4] + a[12]\n b[2] = a[0] + a[4] + a[8] + a[12]\n b[3] = a[0] + a[4] + a[8] + a[12]\n b[4] = a[1] + a[5] + a[9] + a[13]\n b[5] = a[1] + a[5] + a[9] + a[13]\n b[6] = a... | ['Runtime Error', 'Accepted'] | ['s672439184', 's653359096'] | [3188.0, 2940.0] | [17.0, 17.0] | [766, 54] |
p03085 | u545203108 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['z =input()\n\nif z == "A":\n print("T")\nelse if z == "T":\n print("A")\nelse if z == "G":\n print("C")\nelse if z == "G":\n print("G")\n', 'z =input()\n\nif z == "A":\n print("T")\nelif z == "T":\n print("A")\nelif z == "G":\n print("C")\nelif z == "C":\n print("G")\n'] | ['Runtime Error', 'Accepted'] | ['s474167244', 's124499938'] | [2940.0, 2940.0] | [17.0, 18.0] | [139, 130] |
p03085 | u552290152 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 return{"T"}\nelif b="T":\n return{"A"}\nelif b="G":\n return{"C"}\nelse:\n return{"G"}', 'def change(x):\n if x == "A":\n return("T")\n elif x == "T":\n return("A")\n elif x == "C":\n return("G")\n elif x == "G":\n return("C")\n \nb = input()\nprint(change(b))\n'] | ['Runtime Error', 'Accepted'] | ['s907935897', 's135128835'] | [2940.0, 2940.0] | [17.0, 17.0] | [95, 177] |
p03085 | u552357043 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = "T":\n print("A")\nelif b = "C":\n print("G")\nelif b = "G":\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")\n\n'] | ['Runtime Error', 'Accepted'] | ['s020932867', 's380109114'] | [2940.0, 2940.0] | [18.0, 17.0] | [130, 136] |
p03085 | u554200903 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = list(input())\n\nfor i in range(q):\n count = 0\n l, r = map(int, input().split())\n for j in range(l-1,r):\n if s[j] == 'A':\n if j+1 < r:\n if s[j+1] == 'C':\n count += 1\n j += 1\n print(count)", "n... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s123271258', 's730245008', 's251342551'] | [3060.0, 3060.0, 2940.0] | [17.0, 17.0, 17.0] | [301, 301, 122] |
p03085 | u554954744 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\ncnt=0\nfor s in S:\n if s in "A":\n cnt+=1\n elif s in "C":\n cnt+=1\n elif s in "G":\n cnt+=1\n elif s in "T":\n cnt+=1 \n else:\n cnt=0\n ans=max(ans,cnt)\nprint(ans)', 'b=input()\nif b==\'A\':\n print(\'T\')\nelif b==\'C\':\n print("G")... | ['Wrong Answer', 'Accepted'] | ['s443712624', 's046721897'] | [2940.0, 2940.0] | [17.0, 17.0] | [226, 119] |
p03085 | u556225812 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["N,Q=map(int,input().split()) \nS=str(input())\nt = [0] * (N + 1)\nfor i in range(N):\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 = list(input())\na_lst = []\nfor i in range(n-1):\... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s184028740', 's466560386', 's979132880', 's464844744'] | [3060.0, 3060.0, 3060.0, 2940.0] | [17.0, 18.0, 18.0, 17.0] | [221, 313, 315, 112] |
p03085 | u556326496 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['words = list(input())\nbinary_list = []\nfor word in words:\n if word == "A" or word == "T" or word == "C" or word == "G":\n binary_list.append(1)\n else:\n binary_list.append(0)\nmax_counter = 0\nfor first in range(len(binary_list)):\n counter = 0\n multi = 1\n if binary_list[first] == 1:\n ... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s209804859', 's340951354', 's557285200'] | [3060.0, 2940.0, 3064.0] | [17.0, 17.0, 17.0] | [646, 125, 125] |
p03085 | u556589653 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\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'] | ['s218671232', 's169157909'] | [2940.0, 2940.0] | [17.0, 18.0] | [103, 106] |
p03085 | u556672233 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ncandidate = 0\n\n\ndef length(s, i, j):\n for c in s[i:j]:\n if c not in 'ACGT':\n return 0\n return len(s[i:j])\n\n\nfor i in range(len(s)):\n for j in range(len(s)):\n candidate = max(candidate, length(s, i, j))\n\nprint(candidate)\n", "b = input()\ndic = {\n 'A': '... | ['Wrong Answer', 'Accepted'] | ['s962954321', 's898383264'] | [2940.0, 2940.0] | [17.0, 17.0] | [266, 91] |
p03085 | u556849401 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["d = {'A' : 'C', 'C': 'A', 'G':'T', 'T':'G'}\ng = input().strip()\nprint(d[g])", '# -*- coding: utf-8 -*-\n"""\nCreated on Mon May 13 15:09:45 2019\n\n@author: avina\n"""\n\nd = {\'A\' : \'T\', \'C\': \'G\', \'G\':\'C\', \'T\':\'A\'}\ng = input().strip()\nprint(d[g])'] | ['Wrong Answer', 'Accepted'] | ['s350027046', 's716131273'] | [2940.0, 2940.0] | [17.0, 19.0] | [75, 160] |
p03085 | u558182684 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=='T':\n print('C')\nelse:\n print('T')", "b = input()\nif b == 'A':\n print('T')\nelif b=='G':\n print('C')\nelif b=='T':\n print('A')\nelse:\n print('G')\n"] | ['Wrong Answer', 'Accepted'] | ['s714497576', 's832226516'] | [2940.0, 2940.0] | [19.0, 17.0] | [116, 117] |
p03085 | u560889512 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["map={'A':'T','C':'G','G':'C','T':'A'}\ninp=input()\nreturn map[inp]", "map={'A':'T','C':'G','G':'C','T':'A'}\ninp=input()\nprint(map[inp])"] | ['Runtime Error', 'Accepted'] | ['s660453302', 's044998790'] | [2940.0, 2940.0] | [16.0, 17.0] | [65, 65] |
p03085 | u560988566 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\n\ndef nCm(n,m):\n return math.factorial(n) / (math.factorial(m)*(math.facorial(n-m)))\n\nn = int(input())\nkinds = 4**n\na = 7 + 10**9\nanswer = 0\nq = 0\nr = 0\n\np = 3 * nCm(n-2, 1)\nif n > 6:\n q = 3 * nCm(n-4, 2)\nif n > 9: \n r = nCm(n-6, 3)\n\nanswer = (kinds - p + q -r) % a\n\nprint(in... | ['Runtime Error', 'Accepted'] | ['s680840531', 's725908580'] | [3064.0, 2940.0] | [18.0, 17.0] | [308, 121] |
p03085 | u562015767 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['n = int(input())\n\nif n == "A":\n print("T")\nelif n == "T":\n print("A")\nelif n == "C":\n print("G")\nelse:\n print("C")', 'n = str(input())\n\nif n == "A":\n print("T")\nelif n == "T":\n print("A")\nelif n == "C":\n print("G")\nelse:\n print("C")'] | ['Runtime Error', 'Accepted'] | ['s719715257', 's315201357'] | [8924.0, 8976.0] | [24.0, 27.0] | [126, 126] |
p03085 | u563379250 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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=str(input())\nif x=="A":\n print("T")\n else if x=="T":\n print("A")\n else if x=="C":\n print("G")\n else if x=="G":\n print("C")', 'x=str(input())\n if x=="A":\n print("T")\n elif x=="T":\n print("A")\n elif x=="C":\n print("G")\n elif x=="G":\n print("C")\n', 'x=input()\n if x=="A"... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s470732008', 's587371919', 's843592355', 's574934202'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [138, 133, 121, 106] |
p03085 | u564906058 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nif b == "A":\n print("C")\nelif b == "C":\n print("A")\nelif b == "G":\n print("T")\nelse:\n print("G")', '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 '] | ['Wrong Answer', 'Accepted'] | ['s787128876', 's233577981'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 115] |
p03085 | u565901164 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["S = input()\ncount = 0\nlist = []\n\nfor c in S:\n if c == 'A' or c == 'C' or c == 'G' or c == 'T':\n count+=1\n else:\n list.append(count)\n count = 0\n\nif len(list)==0:\n print('0')\nelse:\n print(max(list))", "S = input()\ncount = 0\nlist = []\n\nfor c in S:\n if c == 'A' or c == 'C' or c == 'G'... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s383519093', 's485425932', 's531790298', 's582063550', 's808475384', 's779393315'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 19.0] | [213, 209, 211, 212, 434, 117] |
p03085 | u566483072 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nd = {"A":"T","T":"A","G":"C","C":"G"}\nprint(s["{}".format(s)])', 's,d=input(),{"A":"T","T":"A","G":"C","C":"G"};print(d[s])'] | ['Runtime Error', 'Accepted'] | ['s644760460', 's449034878'] | [2940.0, 2940.0] | [17.0, 17.0] | [74, 57] |
p03085 | u571199625 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ["char = input()\nif chara == 'A':\n print('T')\nelif chara == 'T':\n print('A')\nelif chara == 'C':\n print('G')\nelif chara == 'G':\n print('C')", "chara = input()\nif chara == 'A':\n print('T')\nelif chara == 'T':\n print('A')\nelif chara == 'C':\n print('G')\nelif chara == 'G':\n print('C')"] | ['Runtime Error', 'Accepted'] | ['s296312596', 's662791592'] | [2940.0, 2940.0] | [17.0, 17.0] | [140, 141] |
p03085 | u575101291 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['x=input\nif x==A:\n print("T")\nelif x==T:\n print("A")\nelif x==G:\n print("C")\nelse:\n print("G")', 'x=input\nif x=="A":\n print("T")\nelif x=="T":\n print("A")\nelif x=="G":\n print("C")\nelse:\n print("G")', 'x=input()\nif x=="A":\n print("T")\nelif x=="T":\n print("A")\nelif x=="G":\n print("C")\nels... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s328228261', 's729384770', 's363665939'] | [2940.0, 2940.0, 2940.0] | [17.0, 19.0, 17.0] | [96, 102, 104] |
p03085 | u577138895 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 = str(input())\n\nif S = 'A':\n print('T')\nelif S = 'G':\n print('C')\nelif S = 'T':\n print('A')\nelse:\n print('G')", "S = str(input())\n \nif S == 'A':\n print('T')\nelif S == 'G':\n print('C')\nelif S == 'T':\n print('A')\nelse:\n print('G')"] | ['Runtime Error', 'Accepted'] | ['s097725863', 's897469836'] | [2940.0, 3064.0] | [17.0, 17.0] | [115, 119] |
p03085 | u578057075 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['c=0\nmaxc=0\ns=input()\nfor i in range(len(s)):\n if s[i] == "A" or "C" or "G" or "T" :\n c+=1\n if c>maxc :\n c+=1\n maxc=c\n else:\n c=0\nprint(maxc)\n', 'x=input()\nif x=="A" :\n print("T")\nelif x=="C" :\n print("G")\nelif x=="G" :\n print("C")\nelse:\n ... | ['Wrong Answer', 'Accepted'] | ['s187004094', 's606116850'] | [2940.0, 2940.0] | [17.0, 17.0] | [190, 115] |
p03085 | u580004585 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\ndata= sys.stdin.readline().upper()\n\nif data == "A":\n print("T")\nelif data == "T":\n print("A")\nelif data == "G":\n print("C")\nelse:\n print("G")\n', 'data = input().upper()\n\nif data == "A":\n print("T")\nelif data == "T":\n print("A")\nelif data == "G":\n print("C")\nelse:\n print("G")'] | ['Wrong Answer', 'Accepted'] | ['s921134114', 's109719476'] | [2940.0, 2940.0] | [17.0, 17.0] | [158, 133] |
p03085 | u580199868 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 "A" = b:\n print("T")\nelif b = "T":\n print("A")\nelif b = "G":\n print("C")\nelif b = "C":\n print("G")', 'b=input()\nif "A" == b:\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelif b == "C":\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s502067597', 's981105962'] | [2940.0, 2940.0] | [17.0, 17.0] | [115, 119] |
p03085 | u580697892 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\nS = list(input())\nenki = ["A", "T", "G", "C"]\na = []\nans = ""\nfor i in range(len(S)):\n if S[i] == enki[0] or S[i] == enki[1] or S[i] == enki[2] or S[i] == enki[3]:\n ans += S[i]\n else:\n ans = ""\n a.append(ans)\nprint(len(max(a)))', '#coding: utf-8\nb = input()\nif b == "... | ['Wrong Answer', 'Accepted'] | ['s586800248', 's127150236'] | [3064.0, 2940.0] | [17.0, 17.0] | [265, 145] |
p03085 | u580873239 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b=input()\nif b=="A":\n print("C")\nelif b=="C":\n print("A")\nelif b=="G":\n print("T")\nelse:\n print("G")', 'b=input()\nif b=="A":\n print("T")\nif b==("T"):\n print("A")\nif b==("C"):\n print("G")\nif b==("G"):\n print("C")'] | ['Wrong Answer', 'Accepted'] | ['s506842726', 's472212699'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 111] |
p03085 | u581511366 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nif i == 'A':\n print('T')\nelse if i == 'T':\n print('A')\nelse if i == 'C':\n print('G')\nelse if i == 'G':\n print('C')", "def func():\n\ti = input()\n\tif i == 'A':\n \treturn 'T'\n else if i == 'T':\n \treturn 'A'\n else if i == 'C':\n \treturn 'G'\n else if i == 'G':\n \tret... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s123898395', 's248860247', 's268122270'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [130, 186, 121] |
p03085 | u581671844 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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":"C", "C":"A", "G":"T", "T":"G"}\nprint(dict[b])\n', 'def how_many_AC(count_summary, str):\n index = str.find(\'AC\')\n if index == -1:\n \treturn (count_summary, "")\n else:\n return (count_summary+1, str[index+2:])\n\ndef how_many_AC_recursive(count1, str1):\n (count2, str2) = how_many_AC(count1,... | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s227660811', 's456858888', 's737521506', 's805254561', 's869284105', 's279029470'] | [2940.0, 3064.0, 2940.0, 3064.0, 2940.0, 2940.0] | [17.0, 25.0, 17.0, 18.0, 17.0, 17.0] | [59, 607, 76, 606, 80, 71] |
p03085 | u585498238 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['ans = input("Please enter either A or T or C or G :")\n\nwhile ans == "A" or "T" or "C" or "G":\n\n \n if ans == "A":\n print("T")\n break\n\n elif ans == "T":\n print("A")\n break\n\n elif ans == "C":\n print("G")\n break\n\n elif ans == "G":\n print("C... | ['Wrong Answer', 'Accepted'] | ['s982541310', 's975544822'] | [2940.0, 2940.0] | [17.0, 17.0] | [422, 140] |
p03085 | u588081069 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 -> 0123\n\n\n\n\n\n\n# S + 0\n\n\n# S + 3\n\n\n\n\n\n\nimport numpy as np\n\nN = int(input())\n\nmod = 10 ** 9 + 7\n\nmemo = np.zeros((N + 1, 4, 4, 4))\nmemo[0][3][3][3] = 1\n\n\nfor c in range(N):\n \n for i in range(4):\n \n for j in range(4):\n \n for k in range(4):... | ['Runtime Error', 'Accepted'] | ['s548667554', 's557079393'] | [12392.0, 2940.0] | [149.0, 17.0] | [2051, 155] |
p03085 | u589047182 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['str = input()\n\nif str == "A":\n print("G")\nelif str == "G":\n print("A")\nelif str == "T":\n print("C")\nelse:\n print("T")\n', 'str = input()\n\nif str == "A":\n print("T")\nelif str == "T":\n print("A")\nelif str == "G":\n print("C")\nelse:\n print("G")\n'] | ['Wrong Answer', 'Accepted'] | ['s978395042', 's648939216'] | [2940.0, 2940.0] | [17.0, 17.0] | [130, 130] |
p03085 | u589891243 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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\tprint('T')\nelif a = T :\n\tprint('A')\nelif a = C :\n\tprint('G')\nelse:\n\tprint('C')", "a = input()\nif a is 'A' :\n\tprint('T')\nelif a is 'T' :\n\tprint('A')\nelif a is 'C' :\n\tprint('G')\nelse:\n\tprint('C')"] | ['Runtime Error', 'Accepted'] | ['s145744640', 's701421146'] | [2940.0, 2940.0] | [17.0, 17.0] | [102, 111] |
p03085 | u591764610 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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" : "T", "T" : "A", "C" : "G", "G" : "C"}\nprint(dict[input()])', 'dic = {"A" : "T", "T" : "A", "C" : "G", "G" : "C"}\nprint(dic[input()])'] | ['Runtime Error', 'Accepted'] | ['s463445597', 's354485205'] | [2940.0, 2940.0] | [17.0, 17.0] | [71, 70] |
p03085 | u595289165 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['b = input()\nif b == "A":\n print("T")\nelif b == "T"\n print("A")\nelif b == "G"\n print("C")\nelse:\n print("G")', 'b = input()\nif b == "A":\n print("T")\nelif b == "T":\n print("A")\nelif b == "G":\n print("C")\nelse:\n print("G")'] | ['Runtime Error', 'Accepted'] | ['s475673954', 's385591681'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 120] |
p03085 | u596681540 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b. | ['in = input()\n\nif in == "T":\n return "A"\nif in == "A":\n return "T"\nif in == "C":\n return "G"\nif in == "G":\n return "C"\n', 'if __name__ == \'__main__\':\n V = input()\n \n if V == "T":\n \tprint("A")\n \n if V == "A":\n print("T")\n \n if V == "C":\n print("G")\n \n if V == "G":\n print... | ['Runtime Error', 'Accepted'] | ['s034757352', 's658282550'] | [2940.0, 2940.0] | [17.0, 17.0] | [122, 172] |
p03085 | u597017430 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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'] | ['s565888670', 's256035024'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 112] |
p03085 | u597455618 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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 s == "A":\n print("T")\nelif s == "C":\n print("G")\nelif s == "G":\n print("C")\nelse:\n print("A")', 's = input()\nif s == "A":\n print("T")\nelif s == "C":\n print("G")\nelif s == "G":\n print("C")\nelse:\n print("A")'] | ['Runtime Error', 'Accepted'] | ['s174657505', 's887221303'] | [2940.0, 2940.0] | [17.0, 17.0] | [112, 112] |
p03085 | u598229387 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\nprint('T' if b=='A' else 'A' if b=='T' else 'G' if b=='C' else 'C')"] | ['Runtime Error', 'Accepted'] | ['s242283378', 's012626995'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 77] |
p03085 | u598720217 | 2,000 | 1,048,576 | On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`. You are given a letter b as 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()\ncount_l=[]\nfor i in range(Q):\n a,b = map(int,input().split())\n flag=False\n counting=0\n if b==N:\n l=S[a-1:]\n else:\n l=S[a-1:b]\n #print(l)\n counting = l.count("AC")\n """for ii in l:\n #print(ii)\n if ii=="A":\n ... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s282319658', 's903936631', 's169740029'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [469, 231, 121] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.