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):
import sys
#input = sys.stdin.readlines

list={"A":"T","T":"A","G":"C","C":"G"}
b = sys.stdin.readlines()
print(list[b])

import sys
input = sys.stdin.readline

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

import sys
lines = sys.stdin.readlines()

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

import sys
input = sys.stdin.readline

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

import sys

list={"A":"T","T":"A","G":"C","C":"G"}
b = sys.stdin.readline()
print(list[b])

import sys
input = sys.stdin.readlines

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

import sys
input = sys.stdin.readline

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

Verdicts: Runtime Error

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):
S=input()

c=m=0
for x in S:
  #print((m,c,x,"ACGT".find(x)))
  if "ACGT".find(x)>=0:
    c+=1
    m = max(m, c)

print(m)


T='ACGT'
print(T[T.find(input())^1])


S=input()

c=m=0
for x in S:
  #print((m,c,x,"ACGT".find(x)))
  if "ACGT".find(x)<0:
    m = max(m, c)
    c = 0
  c+=1
m = max(m, c)

print(m-1)


T='ATCG'
print(T[T.find(input())^1])


Verdicts: Wrong Answer

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):
Helix=input()
if Helix=='A':
    print ("G")
elif Helix=="G":
    print ("A")
elif Helix=="G":
    print ("C")
elif Helix=="C":
    print ("G")

Helix=input()
if Helix=='A':
    print ("T")
elif Helix=="T":
    print ("A")
elif Helix=="G":
    print ("C")
elif Helix=="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):
s = input()
 
ans = [0]
cnt = 0
for i in s:
    if (i == "A" or i == "C" or i == "G" or i == "T"):
        cnt+=1
    else:
        if (cnt > 0):
            ans.append(cnt)
            cnt = 0
ans.append(cnt)
print(max(ans))

s = input()

ans =[0]
cnt = 0

for i in s:
	if (i == "A" or i == "C" or i == "G" or i == "T"):
		cnt+= 1
	else:
		if cnt>0:
			ans.append(cnt)
			cnt=0
ans.append(cnt)
print(max(ans))

s = input()
 
ans = [0]
cnt = 0
for i in s:
    if (i == "A" or i == "C" or i == "G" or i == "T"):
        cnt+=1
    else:
        if (cnt > 0):
            ans.append(cnt)
            cnt = 0
ans.append(cnt)
print(max(ans))

S=input()
N=[0]*len(S)
 
for i in range(len(S)):
  if S[i]=="A" or S[i]=="C" or S[i]=="G" or S[i]=="T":
    N[i]=N[i-1]+1

print(max(N))

a = input()

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

Verdicts: Wrong Answer

Wrong Answer

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):
import functools
import math

values = [290021904, 927964716, 826824516, 817140688]
gcd = functools.reduce(math.gcd, values)
print(gcd)

n = input()

if(n == 'A'):
    print('T')
elif(n == 'T'):
    print('A')
elif(n == 'C'):
    print("G")
elif(n == '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):
a=atr(input())

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

a=str(input())
 
if a=="A":
    print("T")
if a=="T":
    print("A")
if a=="G":
    print("C")
if a=="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):
S = input()
ans = 0
cnt = 0
for i in range(len(S)):
  if S[i] == "A" or S[i] =="G" or S[i] =="C" or S[i] =="T":
    cnt += 1
  else:
    ans = max(ans,cnt)
    cnt = 0

print(max(ans,cnt))


b = input()
if b=="A":
  print("T")
elif b=="T":
  print("A")
elif b=="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):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
b=input()

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



import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
b=input()

if b=="A":
	print("T")
if b=="T":
	print("A")
if b=="G":
	print("C")
if b=="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):
S=list(input())
max_count=0
count=0
for i in range(len(S)):
    for j in range(i,len(S)):
        if S[j]=='A' or S[j]=='C' or S[j]=='T' or S[j]=='G':
            count+=1
            max_count=max(max_count,count)
        else:
            count=0
            break
    count=0
print(max_count)   


S=list(input())
max_count=0
count=0
for i in range(len(S)):
    for j in range(i,len(S)):
        if S[j]=='A' or S[j]=='C' or S[j]=='T' or S[j]=='G':
            count+=1
            max_count=max(max_count,count)
        else:
            count=0
            break
    count=0
print(max_count)   


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

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('T')
if b='T':print('A')
if b='C':print('G')
if b='G':print('C')

b=input()
if b=='A':print('T')
if b=='T':print('A')
if b=='C':print('G')
if 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):
b = input().strip()
if b == "A":
    print("C")
elif b == "C":
    print("A")
elif b == "G":
    print("T")
elif b == "T":
    print("G")


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


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


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):
input("ATCG"["TAGC".find(input())])


print("ATCG"["TAGC".find(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 == 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)            


b = 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

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='ATCG'
a['TAGC'.index(input())]


a='ATCG'
a['ACGT'.index(input())]


a='ATCG'
print(a['TAGC'.index(input())])


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):
# -*- coding: utf-8 -*-
"""
Created on Fri Apr  5 13:45:00 2019

@author: adachi-lab
"""

input_code = input('入力;')

list_1 = []

if input_code == 'A' or input_code == 'T':
    list_1 = ['A','T']
    list_1.remove(str(input_code))
    print(list_1[0])
    
else:
    list_1 = ['C','G']
    list_1.remove(str(input_code))
    print(list_1[0])
    
    


# -*- coding: utf-8 -*-
"""
Created on Fri Apr  5 17:16:14 2019

@author: adachi-lab
"""

input_1 = input()
S = input()
l = []
r = []


N = input_1.split()[0]
Q = input_1.split()[1]

for i in range(int(Q)):
    input_3 = input()
    l.append(int(input_3.split()[0]))
    r.append(int(input_3.split()[1]))

W = [(S[x-1:y]).count('AC') for (x, y) in zip(l, r)]

for i in range(len(W)):
    print(W[i])



# -*- coding: utf-8 -*-
"""
Created on Fri Apr  5 17:16:14 2019

@author: adachi-lab
"""

input_1 = input()
S = input()
l = []
r = []


N = input_1.split()[0]
Q = input_1.split()[1]

for i in range(int(Q)):
    input_3 = input()
    l.append(int(input_3.split()[0]))
    r.append(int(input_3.split()[1]))

W = [(S[x-1:y]).count('AC') for (x, y) in zip(l, r)]

for i in range(len(W)):
    print(W[i])



# -*- coding: utf-8 -*-
"""
Created on Fri Apr  5 13:45:00 2019

@author: adachi-lab
"""

input_code = input('入力;')

list_1 = []

if input_code == 'A' or input_code == 'T':
    list_1 = ['A','T']
    list_1.remove(str(input_code))
    print(list_1[0])
    
else:
    list_1 = ['C','G']
    list_1.remove(str(input_code))
    print(list_1[0])
    
    


# -*- coding: utf-8 -*-
"""
Created on Fri Apr  5 13:45:00 2019

@author: adachi-lab
"""

input_code = input()

list_1 = []

if input_code == 'A' or input_code == 'T':
    list_1 = ['A','T']
    list_1.remove(str(input_code))
    print(list_1[0])
    
else:
    list_1 = ['C','G']
    list_1.remove(str(input_code))
    print(list_1[0])
    
    


Verdicts: Wrong Answer

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):
_, num_query = list(map(int,input().split()))
string = input()
dfor _ in range(num_query):
  left, right = list(map(int,input().split()))
  sub_string = string[left-1:right]
  print(sub_string.count("AC"))

base = input()
if base == "A"
	print("T")
if base == "T"
	print("A")
if base == "C"
	print("G")
if base == "G"
	print("C")

base = input()
if base == "A":
	print("T")
if base == "T":
	print("A")
if base == "C":
	print("G")
if base == "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):
s = input()
s2 = ""
list_ = []
sn = 0
i = len(s)
for i in range(0,i):
 if s[i] == "A" or s[i] == "C" or s[i] == "G" or s[i] == "T":
  s2 += s[i]
 else:
  if not s2 == "":
   list_.append(s2)
   s2 = ""
if len(list_) != 0:
 for i in range(0, len(list_)):
  if len(list_[i]) > sn:
   sn = len(list_[i])
  # print(len(list_[i]),sn)
 print(sn)
else:
 print(sn)

s = input()
s2 = ""
list_ = []
sn = 0
i = len(s)
for i in range(0,i):
 if s[i] == "A" or s[i] == "C" or s[i] == "G" or s[i] == "T":
  s2 += s[i]
 else:
  if not s2 == "":
   list_.append(s2)
   s2 = ""
if len(list_) != 0:
 for i in range(0, len(list_)):
  if len(list_[i]) > sn:
   sn = len(list_[i])
  # print(len(list_[i]),sn)
 print(sn)
else:
 print(0)


b = input()
list_ = ["A","T","G","C"]
if list_.index(b) % 2 == 0:
 print(list_[list_.index(b) + 1])
else:
 print(list_[list_.index(b) - 1])

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):
input1 = input().split()
N = input1[0]
Q = input1[1]
S = input()

flag = 0
count = 0
result = []

for q in range(int(Q)):
	
	input3 = input().split()
	
	l = int(input3[0])
	r = int(input3[1])+1
	
	for s in (range(l,r)):
		
		#print(s)
		if S[s-1] == 'A':
			flag += 1
			
		elif ((S[s-1] == 'C') and (flag == 1)):
			count += 1
			flag = 0
			
		else:
			flag = 0
			
	result.append(count)
	
	count = 0
	flag = 0
	
for i in result:
	print(i)

input = input()

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

print(a[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):
1 b = input()
2 c = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}
3 print(c[b])

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

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()
l =[map(int,input().split()) for i in range(Q)]

for i,x in l:
    s1 = S[i-1:x]
    print(s1.count('AC'))

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

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 = T:
	print("A")
if b = C:
	print("G")
elif b = G:
	print("C")

b = input()

if b == A :
	print("T")
elif b == T :
	print("A")
if 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")

b = input()

if b = A :
	print("T")
elif b = T :
	print("A")
if b = C :
	print("G")
elif b = G :
	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

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()
m = [list(map(int,input().split())) for i in range(q)]
count = [0]*(N+1)
 
for i in range(n):
    if S[i:i+2] == 'AC':
        comu[i+1] = comu[i] + 1
    else:
        comu[i+1] = comu[i]
 
for l,r in list:
    print(count[r-1]-count[l-1])

n,q = map(int(input().split()))
s = input()
m = list(map(int,input().split for i in range(q)))
count = [0]*(N+1)

for i in range(N):
    if S[i:i+2] == 'AC':
        comu[i+1] = comu[i] + 1
    else:
        comu[i+1] = comu[i]

for l,r in list:
    print(count[r-1]-count[l-1])


s = input()
p = s.replace('A','B')
q = p.replace('T','A')
r = q.replace('B','T')
w = r.replace('G','W')
x = w.replace('C','G')
y = x.replace('W','C')
print(y)
~


n,q = map(int(input().split()))
s = input()
m = list(map(int,input().split for i in range(q)))
count = [0]*(N+1)

for i in range(n):
    if S[i:i+2] == 'AC':
        comu[i+1] = comu[i] + 1
    else:
        comu[i+1] = comu[i]

for l,r in list:
    print(count[r-1]-count[l-1])
~


s = input()
p = s.replace('A','B')
q = p.replace('T','A')
r = q.replace('B','T')
w = r.replace('G','W')
x = w.replace('C','G')
y = x.replace('W','C')
print(y)

Verdicts: 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()
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()
if s='A':
  print('T')
elif s='T':
  print('A')
elif s='C':
  print('G')
else:
  print('C')

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

s=input()
if s=='A':
  print('T')
elif s=='T':
  print('A')
elif s=='C':
  print('G')
else:
  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):
b = input()
if b == "A":
  print("C")
if b == "C":
  print("A")
if b == "T":
  print("G")
if b == "G":
  print("T")

s = list(input())
count = 0
m = 0
for i in range(len(s)):
  if s[i] == "A" or s[i] == "T" or s[i] == "C" or s[i] ==  "G":
    count += 1
  else:
    if m < count:
      m = count
      count == 0
    else:
      count = 0
print(m)

s = list(input())
count = 0
m = 0
for i in range(len(s)):
  if s[i] == "A" or s[i] == "T" or s[i] == "C" or s[i] ==  "G":
    count += 1
  else:
    if m >count:
      m = count
      count == 0
    else:
      count = 0
print(m)

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

Verdicts: Wrong Answer

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(T)
if b==T:
    print(A)
if b==G:
    print(C)
if b==C:
    print(G)


b=input()
if b=='A':
    print('T')
if b=='T':
    print('A')
if b=='G':
    print('C')
if b=='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):
N = int(input())
memo = [{} for _ in range(N + 1)]

def ok(last4):
  for i in range(4):
    s = list(last4)
    if i >= 1:
      s[i - 1]. s[i] = s[i], s[i - 1]
    if "".join(s).count("AGC") >= 1:
      return False
    return True

def dfs(last3, n):
  if last3 in memo[n]:
    return memo[n][last3]
  if n == N:
    return 1
  ret = 0
  for c in "AGCT":
    if ok(last3 + c):
      ret += dfs(last3[1:] + c, n + 1) % (10 ** 9 + 7)
  memo[n][last3] = ret
  return ret

print(dfs("TTT", 0))

N, Q = map(int, input().split())
S = input()

AC_list = []
cnt = 0
for i in range(N):
  if i != 0 and S[i - 1] == "A" and S[i] == "C":
    cnt += 1
  AC_list.append(cnt)

for _ in range(Q):
  l, r = map(int, input().split())
  print(AC_list[r - 1] - AC_list[l - 1])

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

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())

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

b = str(input())

if b == "A":
    print("T")
if b == "T":
    print("A")
if b == "C":
    print("G")
if 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):
b=input()
a=['A','C','G','T']
b=['A','T','C','G']
i=a.index(b)
print(b[i])

b=input()
a=['A','C','G','T']
c=['A','T','C','G']
i=a.index(b)
print(c[i])


b=input()
a=['A','C','G','T']
c=['T','G','C','A']
i=a.index(b)
print(c[i])


Verdicts: 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):
import sys, os
import collections

def solve(input_stream):
  table = {
    "A": "T",
    "T": "A",
    "C": "G",
    "G": "C"
  }
  ans = ""
  for i in input_stream.readline():
    ans += table[i]
  return [ans]

if __name__ == "__main__":
    outputs = solve(sys.stdin)
    for line in outputs:
      print(line)

import sys, os
import collections

def solve(input_stream):
  table = {
    "A": "T",
    "T": "A",
    "C": "G",
    "G": "C"
  }
  ans = ""
  for i in input_stream.readline().strip():
    ans += table[i]
  return [ans]

if __name__ == "__main__":
    outputs = solve(sys.stdin)
    for line in outputs:
      print(line)

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 = str(input())
b = "A"
c = "C"
d = "G"
e = "T"

if a == e:
  print("G")
if a == d:
  print("T")
if a == b:
  print("C")
if a == c:
  print("A")

a = str(input())
b = "A"
c = "C"
d = "G"
e = "T"

if a == e:
  print("G")
if a == d:
  print("T")
if a == b:
  print("C")
if a == c:
  print("A")

a = str(input())
b = "A"
c = "C"
d = "G"
e = "T"

if a == c:
  print("G")
if a == b:
  print("T")
if a == d:
  print("C")
if a == e:
  print("A")

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().strip()
d = {"A": "C", "G": "T", "C": "A", "T": "G"}
print(d[b])

a, loop = input().split()
string = input()

for i in range(int(loop)):
  j, k = input().split()
  print(string[int(j)-1:int(k)].count('AC'))

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

d = {'A': 'C', 'G': 'T', 'C': 'A', 'T': 'G'}
print(d[b])

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

Verdicts: Wrong Answer

Runtime Error

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):
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):
n = int(input())
mod = 10**9+7
a = [1]*16
no = [0,0]
for _ in range(n-2):
  b = [0]*16
  b[0] = a[0] + a[4] + a[8] + a[12]
  b[1] = a[0] + a[4] + a[12]
  b[2] = a[0] + a[4] + a[8] + a[12]
  b[3] = a[0] + a[4] + a[8] + a[12]
  b[4] = a[1] + a[5] + a[9] + a[13]
  b[5] = a[1] + a[5] + a[9] + a[13]
  b[6] = a[5] + a[9] + a[13]
  b[7] = a[1] + a[5] + a[9] + a[13]
  b[8] = a[2] + a[6] + a[9] + a[14]
  b[9] = a[6] + a[9] + a[14] - no[0] - no[1]
  b[10] = a[2] + a[6] + a[9] + a[14]
  b[11] = a[2] + a[6] + a[9] + a[14]
  b[12] = a[3] + a[7] + a[10] + a[15]
  b[13] = a[3] + a[7] + a[10] + a[15] - no[1]
  b[14] = a[3] + a[7] + a[10] + a[15]
  b[15] = a[3] + a[7] + a[10] + a[15]
  no[0] = a[2]
  no[1] = a[3]
  a = b
  for i in range(16):
    a[i] %= mod
print(sum(a))


print(input().translate(str.maketrans("ATGC","TACG")))

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):
z =input()

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


z =input()

if z == "A":
    print("T")
elif z == "T":
    print("A")
elif z == "G":
    print("C")
elif z == "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):
if b="A":
  return{"T"}
elif b="T":
  return{"A"}
elif b="G":
  return{"C"}
else:
  return{"G"}

def change(x):
  if x == "A":
    return("T")
  elif x == "T":
    return("A")
  elif x == "C":
    return("G")
  elif x == "G":
    return("C")
  
b = input()
print(change(b))


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 = "T":
    print("A")
elif b = "C":
    print("G")
elif b = "G":
    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

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 = list(input())

for i in range(q):
    count = 0
    l, r = map(int, input().split())
    for j in range(l-1,r):
        if s[j] == 'A':
            if j+1 < r:
                if s[j+1] == 'C':
                    count += 1
                j += 1
    print(count)

n, q = map(int, input().split())
s = list(input())

for i in range(q):
    count = 0
    l, r = map(int, input().split())
    for j in range(l-1,r):
        if s[j] == 'A':
            if j+1 < r:
                if s[j+1] == 'C':
                    count += 1
                j += 1
    print(count)


b = input()
if b == 'A':
    print('T')
elif b == 'T':
    print('A')
elif b == 'C':
    print('G')
else:
    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):
S=input()
ans=0
cnt=0
for s in S:
    if s in "A":
        cnt+=1
    elif s in "C":
        cnt+=1
    elif s in "G":
        cnt+=1
    elif s in "T":
        cnt+=1   
    else:
        cnt=0
    ans=max(ans,cnt)
print(ans)

b=input()
if b=='A':
    print('T')
elif b=='C':
    print("G")
elif b=='G':
    print("C")
elif b=='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):
N,Q=map(int,input().split()) 
S=str(input())
t = [0] * (N + 1)
for i in range(N):
    t[i + 1] = t[i] + (1 if S[i : i + 2] == 'AC' else 0)
for i in range(Q):
    l, r = map(int, input().split())
    print(t[r-1] - t[l-1])

n, q = map(int, input().split())
s = list(input())
a_lst = []
for i in range(n-1):
    if s[i] == 'A':
        if s[i+1] == 'C':
            a_lst.append(i)
for i in range(q):
    cnt = 0
    l, r = map(int, input().split())
    for i in range(l-1, r-1):
        if i in a_lst:
            cnt += 1
    print(cnt)

n, q = map(int, input().split())
s = list(input())
a_lst = []
for i in range(n):
    if s[i] == 'A':
        a_lst.append(i)
for i in range(q):
    cnt = 0
    l, r = map(int, input().split())
    for i in range(l-1, r-1):
        if i in a_lst:
            if s[i+1] == 'C':
                cnt += 1
    print(cnt)

s = input()
if s == 'A':
  print('T')
elif s == 'T':
  print('A')
elif s == 'C':
  print('G')
else:
  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):
words = list(input())
binary_list = []
for word in words:
  if word == "A" or word == "T" or word == "C" or word == "G":
      binary_list.append(1)
  else:
      binary_list.append(0)
max_counter = 0
for first in range(len(binary_list)):
    counter = 0
    multi = 1
    if binary_list[first] == 1:
        while(multi):
            multi *= binary_list[first]
            if multi == 0:
                break
            counter += 1
            if counter >= max_counter:
                max_counter = counter
            if first == len(binary_list) - 1:
                break
            else:
                first += 1
print(max_counter)


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

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


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):
b = 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):
s = input()
candidate = 0


def length(s, i, j):
    for c in s[i:j]:
        if c not in 'ACGT':
            return 0
    return len(s[i:j])


for i in range(len(s)):
    for j in range(len(s)):
        candidate = max(candidate, length(s, i, j))

print(candidate)


b = input()
dic = {
    'A': 'T',
    'C': 'G',
    'T': 'A',
    'G': 'C'
}
print(dic[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):
d = {'A' : 'C', 'C': 'A', 'G':'T', 'T':'G'}
g = input().strip()
print(d[g])

# -*- coding: utf-8 -*-
"""
Created on Mon May 13 15:09:45 2019

@author: avina
"""

d = {'A' : 'T', 'C': 'G', 'G':'C', 'T':'A'}
g = input().strip()
print(d[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('G')
elif b=='G':
    print('A')
elif b=='T':
    print('C')
else:
    print('T')

b = input()
if b == 'A':
    print('T')
elif b=='G':
    print('C')
elif b=='T':
    print('A')
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):
map={'A':'T','C':'G','G':'C','T':'A'}
inp=input()
return map[inp]

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

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 math

def nCm(n,m):
    return math.factorial(n) / (math.factorial(m)*(math.facorial(n-m)))

n = int(input())
kinds = 4**n
a = 7 + 10**9
answer = 0
q = 0
r = 0

p = 3 * nCm(n-2, 1)
if n > 6:
    q = 3 * nCm(n-4, 2)
if n > 9:    
    r = nCm(n-6, 3)

answer = (kinds - p + q -r) % a

print(int(answer))

a = input()

if a == "A":
    print("T")
elif a == "C":
    print("G")
elif a == "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 = int(input())

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

n = str(input())

if n == "A":
    print("T")
elif n == "T":
    print("A")
elif n == "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):
x=str(input())
if x=="A":
   print("T")
  else if x=="T":
    print("A")
  else if x=="C":
    print("G")
  else if x=="G":
    print("C")

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


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


x=input()

if x=="A":
  print("T")
elif x=="T":
  print("A")
elif x=="C":
  print("G")
else:
  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):
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 == "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()
count = 0
list = []

for c in S:
  if c == 'A' or c == 'C' or c == 'G' or c == 'T':
    count+=1
  else:
    list.append(count)
    count = 0

if len(list)==0:
    print('0')
else:
    print(max(list))

S = input()
count = 0
list = []

for c in S:
  if c == 'A' or c == 'C' or c == 'G' or c == 'T':
    count+=1
  else:
    list.append(count)
    count = 0

if not list:
    print('0')
else:
    print(max(list))

S = input()
count = 0
list = []

for c in S:
  if c == 'A' or c == 'C' or c == 'G' or c == 'T':
    count+=1
  else:
    list.append(count)
    count = 0

if len(list)==0:
    print(0)
else:
    print(max(list))

S = input()
count = 0
list = []

for c in S:
  if c == 'A' or c == 'C' or c == 'G' or c == 'T':
    count+=1
  else:
    list.append(count)
    count = 0

if not list:
    print(0)
else:
    print(max(list))
    

first_line = input()
N, Q = first_line.split(' ')
N = int(N) #length of the input sentence
Q = int(Q) #num of the questions

S = input() #input sentence

numbers_of_AC = []

question_atributes = []
for _ in range(Q):
    start, end = (input().split(' '))
    start = int(start)
    end = int(end)
    
    for c in S:
		if c == 'A':
			count+=1
		else:
			numbers_of_AC.append(count)
    		count = 0
	numbers_of_AC.append(count)

    

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

Wrong Answer

Wrong Answer

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):
s = input()
d = {"A":"T","T":"A","G":"C","C":"G"}
print(s["{}".format(s)])

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

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):
char = input()
if chara == 'A':
  print('T')
elif chara == 'T':
  print('A')
elif chara == 'C':
  print('G')
elif chara == 'G':
  print('C')

chara = input()
if chara == 'A':
  print('T')
elif chara == 'T':
  print('A')
elif chara == 'C':
  print('G')
elif chara == '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):
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

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 = str(input())

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

S = str(input())
 
if S == 'A':
  print('T')
elif S == 'G':
  print('C')
elif S == 'T':
  print('A')
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):
c=0
maxc=0
s=input()
for i in range(len(s)):
    if s[i] == "A" or "C" or "G" or "T" :
        c+=1
        if c>maxc :
            c+=1
            maxc=c
    else:
        c=0
print(maxc)


x=input()
if x=="A" :
    print("T")
elif x=="C" :
    print("G")
elif x=="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):
import sys

data= sys.stdin.readline().upper()

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


data = input().upper()

if data == "A":
  print("T")
elif data == "T":
  print("A")
elif data == "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):
b=input()
if "A" = b:
  print("T")
elif b = "T":
  print("A")
elif b = "G":
  print("C")
elif b = "C":
  print("G")

b=input()
if "A" == b:
  print("T")
elif b == "T":
  print("A")
elif b == "G":
  print("C")
elif b == "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):
#coding: utf-8
S = list(input())
enki = ["A", "T", "G", "C"]
a = []
ans = ""
for i in range(len(S)):
    if S[i] == enki[0] or S[i] == enki[1] or S[i] == enki[2] or S[i] == enki[3]:
        ans += S[i]
    else:
        ans = ""
    a.append(ans)
print(len(max(a)))

#coding: utf-8
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()
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")
if b==("T"):
  print("A")
if b==("C"):
  print("G")
if b==("G"):
  print("C")

Verdicts: Wrong Answer

Accepted