TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
i = input()
if i == 'A':
  print('T')
else if i == 'T':
  print('A')
else if i == 'C':
  print('G')
else if i == 'G':
  print('C')

def func():
	i = input()
	if i == 'A':
    	return 'T'
    else if i == 'T':
    	return 'A'
    else if i == 'C':
    	return 'G'
    else if i == 'G':
    	return 'C'

print(func())
  

i = input()
if i == 'A':
  print('T')
elif i == 'T':
  print('A')
elif i == 'C':
  print('G')
elif i == 'G':
  print('C')

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
dict = {"A":"C", "C":"A", "G":"T", "T":"G"}
print(dict[b])


def how_many_AC(count_summary, str):
  index = str.find('AC')
  if index == -1:
  	return (count_summary, "")
  else:
    return (count_summary+1, str[index+2:])

def how_many_AC_recursive(count1, str1):
  (count2, str2) = how_many_AC(count1, str1)
  if len(str2) <= 1:
    return count2
  else:
    x = how_many_AC_recursive(count2, str2)
    return x

import sys
sys.setrecursionlimit(10000000)
(N, Q) = input().split()
S = input()
for i in range(1, int(Q)+1):
  (l_str, r_str) = input().split()
  l = int(l_str)
  r = int(r_str)
  substr = S[l-1:r]
  out = how_many_AC_recursive(0, substr)
  print(out)



i = input()
dict = {"A":"C", "C":"A", "G":"T", "T":"G"}
o = dict[i]
print(o)

def how_many_AC(count_summary, str):
  index = str.find('AC')
  if index == -1:
  	return (count_summary, "")
  else:
    return (count_summary+1, str[index+2:])

def how_many_AC_recursive(count1, str1):
  (count2, str2) = how_many_AC(count1, str1)
  if len(str2) <= 1:
    return count2
  else:
    x = how_many_AC_recursive(count2, str2)
    return x

import sys
sys.setrecursionlimit(1000000)
(N, Q) = input().split()
S = input()
for i in range(1, int(Q)+1):
  (l_str, r_str) = input().split()
  l = int(l_str)
  r = int(r_str)
  substr = S[l-1:r]
  out = how_many_AC_recursive(0, substr)
  print(out)



i = input()
dict = {"A":"C", "C":"A", "G":"T", "T":"G"}
o = dict[i[b]]
print(o)


b = input()
dict = {"A":"T", "T":"A", "C":"G", "G":"C"}
print(dict[b])


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
ans = input("Please enter either A or T or C or G :")

while ans == "A" or "T" or "C" or "G":

    
    if ans == "A":
        print("T")
        break

    elif ans == "T":
        print("A")
        break

    elif ans == "C":
        print("G")
        break

    elif ans == "G":
        print("C")
        break

    else:
        print("Type it again")

    
    ans = input("Please enter either A or T or C or G :")

base = input()


if base == "A":
	print("T")
	
elif base == "T":
	print("A")
	
elif base == "C":
	print("G")
	
elif base == "G":
	print("C")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
# AGCT -> 0123






# S + 0


# S + 3






import numpy as np

N = int(input())

mod = 10 ** 9 + 7

memo = np.zeros((N + 1, 4, 4, 4))
memo[0][3][3][3] = 1


for c in range(N):
    
    for i in range(4):
        
        for j in range(4):
            
            for k in range(4):
                
                for a in range(4):
                    
                    # 012, 102, 021, 0?12, 01?2
                    if a == 1 and i == 2 and j == 0:
                        continue
                    if a == 2 and i == 1 and j == 0:
                        continue
                    if a == 2 and i == 0 and j == 1:
                        continue
                    if a == 2 and j == 1 and k == 0:
                        continue
                    if a == 2 and i == 1 and k == 0:
                        continue
                    
                    memo[c + 1][a][i][j] += memo[c][i][j][k]
                    memo[c + 1][a][i][j] %= mod


ans = 0

for i in range(4):
    
    for j in range(4):
        
        for k in range(4):
            ans += memo[N][i][j][k]
            ans %= mod
print(int(ans))


b = input()

if b == "A":
    result = "T"
elif b == "C":
    result = "G"
elif b == "G":
    result = "C"
elif b == "T":
    result = "A"

print(result)



Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
str = input()

if str == "A":
    print("G")
elif str == "G":
    print("A")
elif str == "T":
    print("C")
else:
    print("T")


str = input()

if str == "A":
    print("T")
elif str == "T":
    print("A")
elif str == "G":
    print("C")
else:
    print("G")


Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = input()
if a = A :
	print('T')
elif a = T :
	print('A')
elif a = C :
	print('G')
else:
	print('C')

a = input()
if a is 'A' :
	print('T')
elif a is 'T' :
	print('A')
elif a is 'C' :
	print('G')
else:
	print('C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
dic = {"A" : "T", "T" : "A", "C" : "G", "G" : "C"}
print(dict[input()])

dic = {"A" : "T", "T" : "A", "C" : "G", "G" : "C"}
print(dic[input()])

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if b == "A":
    print("T")
elif b == "T"
    print("A")
elif b == "G"
    print("C")
else:
    print("G")

b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "G":
    print("C")
else:
    print("G")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
in = input()

if in == "T":
  return "A"
if in == "A":
  return "T"
if in == "C":
  return "G"
if in == "G":
  return "C"


if __name__ == '__main__':
  V = input()
  
  if V == "T":
  	print("A")
  
  if V == "A":
    print("T")
  
  if V == "C":
    print("G")
  
  if V == "G":
    print("C")


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if b = 'A':
  print('T')
elif b = 'T':
  print('A')
elif b = 'C':
  print('G')
else:
  print('C')

b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
else:
  print('C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if s == "A":
  print("T")
elif s == "C":
  print("G")
elif s == "G":
  print("C")
else:
  print("A")

s = input()
if s == "A":
  print("T")
elif s == "C":
  print("G")
elif s == "G":
  print("C")
else:
  print("A")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if b = 'A':
    print('T')
elif b = 'C':
    print('G')
elif b = 'G':
    print('C')
else:
    print('A')

b=input()
print('T' if b=='A' else 'A' if b=='T' else 'G' if b=='C' else 'C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
N,Q = map(int,input().split())
S = input()
count_l=[]
for i in range(Q):
    a,b = map(int,input().split())
    flag=False
    counting=0
    if b==N:
        l=S[a-1:]
    else:
        l=S[a-1:b]
    #print(l)
    counting = l.count("AC")
    """for ii in l:
        #print(ii)
        if ii=="A":
            flag=True
        elif ii=="C" and flag==True:
            counting+=1
            flag=False"""
    count_l.append(counting)
for i in count_l:
    print(i)


N,Q = map(int,input().split())
S = input()
c_l=[]
for i in range(Q):
    a,b = map(int,input().split())
    if b==N:
        l=S[a-1:]
    else:
        l=S[a-1:b]
    c = l.count("AC")
    c_l.append(c)
for i in c_l:
    print(i)


b = input()
if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="G":
    print("C")
elif b=="C":
    print("G")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = int(input())
print("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")

b = input()
print("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
s = input()
if s == 'A':
	print('T')
else if s == 'T':
	print('A')
else if s == 'G':
	print('C')
else if s == 'C':
	print('G')

s = input()
if s == 'A':
	print('T')
elif s == 'T':
    print('A')
elif s == 'G':
	print('C')
elif s == 'C':
	print('G')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = int(input())

if b == "A":
	print("T")
elif b == "C":
	print("G")
elif b == "G":
	print("C")
else:
	print("A")


b = input()

if b == "A":
	print("T")
elif b == "C":
	print("G")
elif b == "G":
	print("C")
else:
	print("A")


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()

if b == A:
    print("T")
elif b == T:
    print("C")
elif b == C:
    print("G")
elif b == G:
    print("C")


b = input()

if b==A:
    print("T")
elif b==T:
    print("C")
elif b==C:
    print("G")
elif b==G:
    print("C")

S = input()
ACGT = ["A","C","G","T"]

ans = 0 
ans_lis = [0]

for i in range(len(S)):
    if S[i] in ACGT:
        ans = ans + 1 
        if i == (len(S)-1):
            ans_lis.append(ans)
    else:
        ans_lis.append(ans)
        ans = 0 

print(max(ans_lis))

b = input()

if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
elif b == "G":
    print("C")


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
print("A" if b==T else "T" if b==A else "G" if b==C else "C")

b = input()
print("A" if b=="T" else "T" if b=="A" else "G" if b=="C" else "C")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
if S == 'A':
  print('T')
if S == 'T':
  print('A')
if S == 'G':
  print('C')
else:
  print('G')
     

S = input()
if S == 'A':
  print('T')
if S == 'T':
  print('A')
if S == 'G':
  print('C')
if S == 'C':
  print('G')

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b=input()

if b=="A":
    print("C")
elif b=="C":
    print("A")
elif b=="G":
    print("T")
elif b=="T":
    print("G")

b=input()

if b=="A":
    print("T")
elif b=="T":
    print("A")
elif b=="G":
    print("C")
elif b=="C":
    print("G")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = input()
print("A" if a = "T" else "T" if a ="A" else "G" if a ="C" else "C")

a = input()
print("A" if a =="T" else "T" if a =="A" else "G" if a =="C" else "C")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
# coding: utf-8
# Your code here!
N,Q = map(int,input().split())
S = input()
p = set()
for n,i in enumerate(S[:-1]):
    if i == "A" and S[n+1]=="C":
        p.add(n)
#print(p)
for i in range(Q):
    a,b = map(int,input().split())
    #tmp = {}
    
    # print(tmp)
    # print(len(tmp&p))
    count=0
    for j in p:
        #print("j",j)
        if a <= j+1 and j+1 < b:
            count+=1
        elif j > b:
            break
    print(count)


a = input()
if a == "A":
    print("T")
elif a == "T":
    print("A")
elif a == "G":
    print("C")
else:
    print("G")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
code = input()
if code = 'A':
	print('T')
elif code = 'T':
	print('A')
elif code = 'G':
	print('C')
elif code = 'C':
	print('G')


code = input()
if code = 'A':
	print('T')
elif code = 'T':
    print('A')
elif code = 'G':
    print('C')
elif code = 'C':
    print('G')


code = str(input())
if code = 'A':
	print('T')
elif code = 'T':
    print('A')
elif code = 'G':
    print('C')
elif code = 'C':
    print('G')

code = input()
if code == 'A':
	print('T')
elif code == 'T':
    print('A')
elif code == 'G':
    print('C')
elif code == 'C':
    print('G')


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
array = [A,T,G,C]
b = input()
if b == array[0]:
  print (array[1])
elif b == array[1]:
  print (array[0])
elif b == array[2]:
  print (array[3])
else:
  print (array[2])

b = input()
if b == "T":
  print "A"
elif b == "A":
  print "T"
elif b == "G":
  print "C"
else:
  print "G"

b = input()
if b == T:
  print A
elif b == A:
  print T
elif b == G:
  print C
else:
  print G

array = ["A","T","G","C"]
b = input()
if b == array[0]:
  print (array[1])
elif b == array[1]:
  print (array[0])
elif b == array[2]:
  print (array[3])
else:
  print (array[2])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
import re
N, Q = input().split()
N = int(N)
Q = int(Q)
S=str(input())

for i in range(Q):
  l, r = input().split()
  l = int(l)
  r = int(r)
  print(S.count("AC", l-1, r))

b=str(input())
if b=="A": print("T")
elif b=="T": print("A")
elif b=="C": print("G")
else: print("C")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
import sys
input = sys.stdin.readline
b=input()

if b=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='C':
  print('G')
elif b=='G':
  print('C')


b=input()

if b=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='C':
  print('G')
elif b=='G':
  print('C')


Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()

bases = ['A', 'C', 'G', 'T']

for idx, base in enumerate(bases):
  if base == b:
    print(bases[int(~bin(idx))])

b = input()

bases = ('A', 'C', 'G', 'T')

for idx, base in enumerate(bases):
  if base == b:
    print(bases[int(~bin(idx))])
    break


b = input()

bases = ('A', 'C', 'G', 'T')

for idx, base in enumerate(bases):
  if base == b:
    print(bases[int(~(idx))])
    break

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
ltrs = "ACGT"
curr_max = 0
curr_len = 0
for ltr in S:
    if ltr in ltrs:
        curr_len += 1
    else:
        curr_max = max(curr_max, curr_len)
        curr_len = 0
print(max(curr_len, curr_max))

b = input()
stars = {"A": "T", "T": "A", "C": "G", "G": "C"}
print("{}".format(stars[b]))


Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if b=='A':
    print ('T')
elif b = 'T':
    print ('A')
elif b = ('C'):
    print ('G')
else:
    print ('C')

b = input()
if b=='A':
    print ('T')
elif b == 'T':
    print ('A')
elif b == ('C'):
    print ('G')
else:
    print ('C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
longest_acgt = 0

def is_acgt(string):
    a_count = string.count("A")
    c_count = string.count("C")
    g_count = string.count("G")
    t_count = string.count("T")
    acgt_count = a_count + c_count + g_count + t_count
    string_count = len(string)
    if acgt_count == string_count:
        return True
    else:
        return False

for i in range(0, 11):
    

    
    for j in range(i + 1, 11):
        # print(str(i) + " " + str(j))
        # print(S[i:j])
        result = is_acgt(S[i:j])
        if result and len(S[i:j]) > longest_acgt:
            longest_acgt = len(S[i:j])
            pass
print(longest_acgt)



b = input()
if b =="A":
    print("T")
elif b =="T":
    print("A")
elif b =="C":
    print("G")
else:
    print("C")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
l = []
for i in S:
    l.append(i)

c = 0
cnt = []
for j in range(len(l)):
    if l[j] == 'A' or l[j] == 'T' or l[j] == 'C' or l[j] == 'G':
        c+=1
        cnt.append(c)
    else:
        cnt.append(c)
        c = 0

#print(cnt)
print(max(cnt))

b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
acid = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
c = input()
print(acid(c))

acid = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
c = input()
print(acid[c])

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a=input()
if a=A:
  print(T)
elif a=T:
  print(A)
elif a=C:
  print(G)
else:
  print(C)

a=input()
if a == A:
  print(T)
elif a == T:
  print(A)
elif a == C:
  print(G)
else:
  print(C)


a=input()
if a==A:
  print(T)
elif a==T:
  print(A)
elif a==C:
  print(G)
else:
  print(C)


a=input()
if a=A:
  print(T)
elif a=T:
  print(A)
elif a=C:
  print(G)
elif a=G:
  print(C)

a=input()
if a=="A":
  print(T)
elif a!="A":
  print(A)
elif a=="C":
  print(G)
else:
  print(C)


b = input()
if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "G":
    print("C")
elif b == "T":
    print("A")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
print('A' if b == 'T' else 'T' if b == 'A' else 'C' if b == 'G' else 'G' if b == 'C')

b = input()
print('A' if b == 'T' else 'T' if b == 'A' else 'C' if b == 'G' else 'G')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b=str(input())
if b="A":
  print("T")
elif b="C":
  print("G")
elif b="G":
  print("C")
else:
  print("A")
  

b=str(input())
if b=="A":
  print("T")
elif b=="C":
  print("G")
elif b=="G":
  print("C")
else:
  print("A")
  

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
n, q = map(int, input().split())
s = input()
a = [list(map(int, input().split())) for i in range(q)]

cum=[0]*n
for i in range(1, n):
    cum[i] = cum[i - 1]
    if s[i-1:i+1] == 'AC':
        cum[i]+=1
    print(cum)

for i in range(q):
    print(cum[a[i][1]-1]-cum[a[i][0]-1])

dic = {
    'A': 'T',
    'T': 'A',
    'C': 'G',
    'G': 'C'
}

n=input()
print(dic[n])

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
 
i = 0
max = 0
for s in S:
  if s == "A" or s=="C" or s=="G" or s=="T":
    i += 1
    if i >= max:
      max = i
  else:
    i = 0
    
print(max)

b = input()
if b == "A":
  print("T")
elif b == "T":
  print("A")
elif b == "C":
  print("G")
else:
  print("C")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a=input()
if a="A":
  print("T")
elif a="T":
  print("A")
elif a="G":
  print("C")
else:
  print("G")

a=input()
if a=="A":
	print("T")
elif a=="T":
    print("A")
elif a=="G":
	print("C")
else:
	print("G")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
def func():
    b = input()

    if b == 'A':
        print('G')
    if b == 'G':
        print('A')
    if b == 'G':
        print('T')
    if b == 'T':
        print('G')


if __name__ == '__main__':
    func()


def func():
    b = input()

    if b == 'A':
        print('T')
    if b == 'T':
        print('A')
    if b == 'C':
        print('G')
    if b == 'G':
        print('C')


if __name__ == '__main__':
    func()


Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b=input()
l=['A','C','G','T']
for i in range(4):
  if b==l[i]:
    print(l[4-i])

b=input()
l=['A','C','G','T']
for i in range(4):
  if b==l[i]:
    print(l[3-i])


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = str(input())
if b == "A":
  pritn("T")
elif b == "T":
  print("A")
elif b == "c":
  print("G")
else:
  print("C")

b = str(input())
if (b == "A"):
  print("T")
elif (b == "T"):
  print("A")
elif (b == "c"):
  print("G")
elif (b == "G")
  print("C")

b = str(input())
if b == "A":
  pritn("T")
elif b == "T":
  print("A")
elif b == "c":
  print("G")
else:
  print("C")

b = str(input())
if (b == "A"):
  print("T")
elif (b == "T"):
  print("A")
elif (b == "C"):
  print("G")
elif (b == "G"):
  print("C")

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = input()
if a == 'A':
  print('A')
if a == 'C':
  print('T')
if a == 'G':
  print('C')
if a == 'T':
  print('G')

a = input()
if a == 'A':
  print('T')
elif a == 'C':
  print('G')
elif a == 'G':
  print('C')
elif a == 'T':
  print('A')



Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
inverse = ['A': 'T', 'T': 'A', 'G': 'C', 'C': 'G']
print(inverse[input()])


base = 'ATAGCG'
print(base[base.index(input())+1])


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
N, Q = map(int, input().split())
S = input()
AC = [0] * N

for i in range(1, len(S)):
    if S[i-1] == 'A' and S[i] == 'C':
        AC[i] = AC[i-1] + 1
    else:
        AC[i] = AC[i-1]


for i in range(Q):
    start, end = map(lambda x:int(x)-1, input().split())
    print(AC[end] - AC[start])

b = input()

if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
else:
  print('C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = int(input()) 

if a == 'A' or a =='T':
  if a == 'A':
    print('T')
  else:
    print('A')
else:
  if a == 'G':
    print('C')
  else:
    print('G')

a = input()

if a == 'A' or a =='T':
  if a == 'A':
    print('T')
  else:
    print('A')
else:
  if a == 'G':
    print('C')
  else:
    print('G')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S=input()
flag=0
count=0
begin=0
max_begin=0
max_count=0
for i in range(len(S)):
    if flag==0:
        
        if S[i]=="A" or S[i]=="T" or S[i]=="C" or S[i]=="G":
            begin=i
            count+=1
            flag=1
            
    else:
        if S[i]=="A" or S[i]=="T" or S[i]=="C" or S[i]=="G":
            count+=1
            
        else:
            if max_count<count:
                max_count=count
                max_begin=begin
            flag=0
            count=0
if max_count<count:
    max_count=count
print(max_count)  

b=input()
if b=="A":
  print("T")
elif b=="T":
  print("A")
elif b=="C":
  print("G")
else:
  print("C")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
import re
len(max(re.sub(r'[^ACGT]', ' ', input()).split()))

a = input()
print({'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}[a])

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = int(input())
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

b = input()
if b == "A":
    print("T")
elif b == "T":
    print("A")
elif b == "C":
    print("G")
else:
    print("C")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
N, Q = map(int, input().split())
S = input()
output = []
for i in range(Q):
	l, r = map(int, input().split())
	Slr = S[l - 1:r]
	output.append(Slr.count('AC'))
for i in output:
	print(i)


N, Q = map(int, input().split())
S = input()
output = []
for i in range(Q):
	l, r = map(int, input().split())
	Slr = S[l - 1:r]
	output.append(Slr[l - 1:r].count('AC'))
for i in output:
	print(i)


N, Q = map(int, input().split())
S = input()
output = []
for i in range(Q):
	l, r = map(int, input().split())
	Slr = S[l - 1:r]
	output.append(Slr[l - 1:r].count('AC'))
for i in output:
	print(i)


b = input()
if b == 'A':
	print('T')
if b == 'C':
	print('G')
if b == 'T':
	print('A')
if b == 'G':
	print('C')


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
s=input()
if s="A":
  print("T")
if s="T":
  print("A")

if s="G":
  print("C")
if s="C":
  print("G")

s=input()
if s=="A":
  print("T")
if s=="T":
  print("A")

if s=="G":
  print("C")
if s=="C":
  print("G")

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b=input()
if b==A:
  print(T)
elif b==T:
  print(A)
elif b==G:
  print(C)
else:
  print(G)
  

b=input()
if b==A:
  print(T)
elif b==T:
  print(A)
elif b==G:
  print(C)
else b==C:
  print(G)
  

b=input()
if b==A:
  print(T)
elif b==T:
  print(A)
elif b==G:
  print(C)
elif b==C:
  print(G)
  

b=input()
a={"A":"T","T":"A","G":"C","C":"G"}
print(a[b])

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
N,Q=map(int,input().split())
S=input()
li=[]
t=0
for i in range(1,N):
  if S[i-1:i+1]=="AC":
      t+=1
  li.append(t)
for _ in range(Q):
  l,r=map(int,input().split())
  print(li[r-1]-li[l-1])


dna={"A":"T", "T":"A", "C":"G", "G":"C"}
print(dna[input()])

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
n = input()
if n="A":
  print("T")
elif n="T":
  print("A")
elif n="G":
  print("C")
else:
  print("G")

n = int(input())
if n="A":
  print("T")
elif n="T":
  print("A")
elif n="G":
  print("C")
else:
  print("G")

n = input()
if n=="A":
  print("T")
elif n=="T":
  print("A")
elif n=="G":
  print("C")
else:
  print("G")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = str(input())
dic = {'A':'C', 'C':'A', 'G':'T', 'T':'G'}
bz = dic[b]
print(bz)

b = str(input())
dic = {'A':'T', 'C':'G', 'G':'C', 'T':'A'}
bz = dic[b]
print(bz)

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
a = ["A, T"]
c = ["C", "G"]
if b is a[0]:
  print(a[1])
if b is a[1]:
  print(a[0])
if b is c[0]:
  print(c[1])
if b is c[1]:
  print(c[0])

b = input()
a = ["A", T"]
c = ["C", "G"]
if b is a[0]:
  print(a[1])
if b is a[1]:
  print(a[0])
if b is c[0]:
  print(c[1])
if b is c[1]:
  print(c[0])

print("TAGC"["ATCG".index(input())])

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
import re
N, Q = (int(i) for i in input().split(' ')) 
S = input()
for i in range(Q):
    l_i, r_i = (int(j) for j in input().split())
    matches = re.findall('AC', S[l_i-1:r_i])
    print(len(matches))

ACGT = {'A':'T', 'C':'G', 'T':'A', 'G':'C'}
input_ACGT = input()
print(ACGT[input_ACGT])

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()

def twin(base):
  if base == 'A':
    a = 'C'
  elif base == 'C':
    a = 'A'
  elif base == 'G':
    a = 'T'
  else:
    a = 'G'
  print(a)
  
twin(b)

b = 'A'
if b == 'A':
  	print('C')
elif b == 'C':
  	print('A')
elif b == 'G':
	print('T')
else:
  	print('G')

b = input()

def twin(base):
  if base == 'A':
    a = 'T'
  elif base == 'T':
    a = 'A'
  elif base == 'G':
    a = 'C'
  else:
    a = 'G'
  print(a)
  
twin(b)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()

if(b=="A"):
    print("C")
elif(b=="C"):
    print("A")
elif(b=="G"):
    print("T")
else:
    print("G")

b = input()

if(b=="A"):
    print("T")
elif(b=="C"):
    print("G")
elif(b=="G"):
    print("C")
else:
    print("A")

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
n,q = map(int,input().split())
s = input()
lr = [list(map(int,input().split())) for i in range(q)]

aclist = [0]
acsum = 0

for i in range(1,n):
    if s[i-1] == "A" and s[i] == "C":
        acsum += 1
    aclist.append(acsum)

for i in range(q):
    ans = aclist [lr[i][0]-1] - aclist [lr[i][0]-2]
    if aclist [lr[i][0]-1] - aclist [lr[i][0]-2] != 0:
        ans -= 1
    print(ans)


n,q = map(int,input().split())
s = input()
lr = [list(map(int,input().split())) for i in range(q)]

aclist = [0]
acsum = 0

for i in range(1,n):
    if s[i-1] == "A" and s[i] == "C":
        acsum += 1
    aclist.append(acsum)

for i in range(q):
    ans = aclist [lr[i][1]-1] - aclist [lr[i][0]-2]
    if aclist [lr[i][0]-1] - aclist [lr[i][0]-2] != 0:
        ans -= 1
    print(ans)

b = input()

if b == "A":
    ans = "T"
elif b == "T":
    ans = "A"
elif b == "C":
    ans = "G"
else:
    ans = "C"

print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
s=input()

if s='A':
  print('T')
elif s='T':
  print('A')
elif s='G':
  print('C')
else:
  print('G')
        

s=input()
 
if s=='A':
  print('T')
elif s=='T':
  print('A')
elif s=='G':
  print('C')
else:
  print('G')
        

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())

if e - a <= k:
    print('Yay!')
else:
    print(':(')


b = str(input())
if b == 'A':
    print('T')
elif b == 'C':
    print('G')
elif b == 'G':
    print('C')
else:
    print('A')


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
import sys

s = sys.stdin.readline()
if s == 'A':
    print('T')
elif s == 'G':
    print('C')
elif s == 'C':
    print('G')
else:
    print('A')


import sys

s = sys.stdin.readline()
if 'A' in s:
    print('T')
elif 'G' in s:
    print('C')
elif 'C' in s:
    print('G')
else:
    print('A')


Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
S = input()
n = 0
atgc = [0] * len(S)

for i in S:
    if ('A' in i) or ('C' in i) or ('G' in i) or ('T' in i):
        atgc[n] += 1
    else:
        n += 1
        
ans = max(atgc)
print(ans)

b= input()

if b=='A':
  b='T'
elif b=='T':
  b='A'
elif b=='G':
  b='C':
elif b=='C':
  b='G'
print(b)

print({'A':'T','T':'A','G':'C','C':'G'}[input()])


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
X = input()

if (X == “A”):
    print(“T”)
elif (X ==“T”):
    print(“A”)
elif (X == “G”):
    print(“C”)
else:
    print(“G”)


X = input()

if (X == A):
    print(“T”)
elif (X ==T):
    print(“A”)
elif (X == G):
    print(“C”)
else:
    print(“G”)

X = input()

if (X == "A"):
    print("T")
elif (X =="T"):
    print("A")
elif (X == "G"):
    print("C")
else:
    print("G")


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
elif b == 'G':
  print('C'):
  

b = input()
if b == 'A':
  print('T')
elif b == 'T':
  print('A')
elif b == 'C':
  print('G')
elif b == 'G':
  print('C')

Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
base = ["A","C","T","G"]
b = input()
n =  int(base.index(b))
print(base[3-n])

base = ["A","C","G","T"]
b = input()
n =  int(base.index(b))
print(base[3-n])

Verdicts: Wrong Answer

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `C`, `G` or `T`. Write a program that prints the letter representing the base that bonds with the base b.

Submission attempts (in order):
a = ["A", "C", "G", "T"]
b=input()
print(a[:-1-a.index(b)])

a = ["A", "C", "G", "T"]
b=input()
print(a[-1-a.index(b)])

Verdicts: Wrong Answer

Accepted