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

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

elif b =='C':
   print('T')

elif b =='G':
   print('C')

elif b =='T':
   print('G')

b = input()

if b =='A':
   result='A'

elif b =='C':
   result='T'

elif b =='G':
   result='C'

elif b =='T':
   result='G'

print('result')

b = input()

if b =='A':
   result='A'

elif b =='C':
   result='T'

elif b =='G':
   result='C'

elif b =='T':
   result='G'

print(result)

print('塩基の入力')

b=input('>>')

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

elif b =='C':
   print('T')

elif b =='G':
   print('C')

elif b =='T':
   print('G')

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: 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):
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):
# -*- coding: utf-8 -*-
text = str(input())
  
Enki_list =  ["A","C","G","T"]
Tui_list  =  ["A","T","C","G"] 

for i in range(len(Enki_list)):
  if Enki_list[i] == text:
    print(Tui_list[i])
    break

s = str(input())

if s=="A":
  print("T")
elif s=="T":
  print("A")
elif s=="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()
n=len(S)
i=0
count=0
maxcount=0
while(n>0):
    if(S[i]=='A'or S[i]=='T' or S[i]=='G' or S[i]=='C'):
        count=count+1
        if(maxcount<count):
            maxcount=count
    else:
        if(maxcount<count):
            maxcount=count
        count=0
    n=n-1
    i=i+1
print(maxcount)

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

print(b)

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

if b == 'A':
    ans = 'A'
elif b == 'C':
    ans = 'T'
elif b == 'G':
    ans = 'C'
elif b == 'T':
    ans = 'G'

print(ans)


B = input()
ans = ""

for b in B:
    if b == 'A':
        ans += 'A'
    if b == 'C':
        ans += 'T'
    if b == 'G':
        ans += 'C'
    if b == 'T':
        ans += 'G'

print(ans)


b = input()

if b == 'A':
    ans = 'T'
elif b == 'C':
    ans = 'G'
elif b == 'G':
    ans = 'C'
elif b == 'T':
    ans = 'A'

print(ans)


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

big = ["A","T","G","C"]
cou = ["T","A","C","G"]

ans = cou.index(b)
print(ans)

b = input()

big = ["A","T","G","C"]
end = ["T","A","C","G"]

ans = end.index(b)
print(ans)

b = input()

big = ["A","T","G","C"]
cou = ["T","A","C","G"]

ans = cou[big.index(b)]
print(ans)

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

ma = 0
for i in range(len(s)):
    for j in range(0,len(s)-i+1):
        sbstr = s[i:i+j+1]
        print(i,j,sbstr)
        is_good = True
        for c in sbstr:
            if c not in "AGCT":
                is_good = False
                break
        if is_good:
            if (len(sbstr)) > ma :
                ma = len(sbstr)

print(ma)


b = input()

if b == 'A':
    print('T')
if b == 'T':
    print('A')
if b == 'G':
    print('C')
if 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()
l=[]
for i in (list(a)):
  if i=="A" or i=="T" or i=="G" or i=="C":
    l.append(1)
  else:
    l.append(0)
n=""
for i in l:
  n=n+str(i)
m=[0]
for i in range(10):
  if '1'*i in n:
    m.append(i)
print(max(m))

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

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):
e_list = ['A', 'C', 'G', 'T']
b = str(input())
if b == e_list[1]:
    print(e_list[0])
elif b == e_list[0]:
    print(e_list[1])
elif b == e_list[2]:
    print(e_list[3])
elif b == e_list[3]:
    print(e_list[2])

e_list = ['A', 'C', 'G', 'T']
b = str(input())
if b == e_list[0]:
    print(e_list[3])
elif b == e_list[1]:
    print(e_list[2])
elif b == e_list[2]:
    print(e_list[1])
elif b == e_list[3]:
    print(e_list[0])

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


#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))

#a = [input() for _ in range(n)]

s = input()

h = {"A":"T","C":"G","G":"C","T":"A"}

print(h[s])





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

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

if d == "A":
    print("T")
    
else if d == "T":
    print("A")

    
else if d == "C":
    print("G")
    
else:
    print("C")


d = input()

if d == "A":
    print("T")
    
else if d == "T":
    print("A")

else if d == "C":
    print("G")
    
else:
    print("C")


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

b = input().strip()
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):
b=input()
b=input()

if b=='A':
  print('T')
elif b=='T':
  print('A')
elif b=='C':
  print('G')
elif b=='G':
  pring('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):
if __name__ == "__main__":
    NQ = input().split(" ")
    N ,Q = int(NQ[0]),int(NQ[1])

    S = input()
    stack =[]
    for x in range(Q):
        lr = input()
        lr = lr.split(" ")
        l ,r = int(lr[0]),int(lr[1])
        target = S[l-1:r]
        num = target.split("AC")
        stack.append(num)
    for x in [len(y)-1 for y in stack]:
        print(x)

if __name__ == "__main__":
    first = {'A','T'}
    second = {'C','G'}

    N = input()

    for x in [first,second]:
        if len(x - {N}) == 1:
            print(list(x-{N})[0])

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):
print(input().replace('A', 'T').replace('T', 'A').replace('C', 'G').replace('G', 'C'))


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):
N, M = list(map(int, input().split()))
S = input()
a = []
for i in range(M):
    a.append(list(map(int, input().split())))
for i in range(M):
  print(S[a[i][0]-1:a[i][1]].count('AC'))

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

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


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


b = input()
print("A" if b == "T" else "T" if b == "A" else
      "C" if b == "G" else "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):
b = input()
b_dic = {"A":"T","T":"A","C":"G","G":"c"}
print(b-dic[b])

b = input()
b_dic = {"A":"T","T":"A","C":"G","G":"C"}
print(b_dic[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 = input()
 
if b == 'A':
    b = 'T'
elif b == 'T':
    b = 'A'
elif b == 'C':
    b = 'G'
else:
    b = 'C'
 
print(b)
b = input ')
if b = a


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


b = input()

if b == 'A':
    b = 'T'
elif b == 'T':
    b = 'A'
elif b == 'C':
    b = 'G'
else:
    b = 'C'

print(b)


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

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


n=input()
if n=='A':
  print('T')
elif n=='T':
  print('A')
elif n=='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):
base = input()

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

base = input()

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

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

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

s = input()

print ("A" if s =="T" else "T" if s =="A" else "C" if s=="G" else "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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

d = {'A': 'C', 'C': 'A', 'G': 'T', 'T': 'G'}
b = readline().decode('utf8').split()
print(b[0])
print(d[b[0]])




import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

d = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
b = readline().decode('utf8').split()
print(d[b[0]])


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')
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):
#ABC122B
S = input()
SC= S.replace('C','A')
SCG = SC.replace('G','A')
SCGT = SCG.replace('T','A')
ans = 0
wk = 0
for i in range(int(len(S))):
    if SCGT[i:i+1] == 'A':
        wk += 1
    else:
        if wk >= ans:
            ans = wk
        wk =0

if wk >= ans:
    ans = wk
print(ans)

#ABC122 A
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()
print(s.translate(str.maketrans({"A":"T","T":"A","C":"G","G":"C"})

s = input()
print(s.translate(str.maketrans({"A":"T","T":"A","C":"G","G":"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=='G':
 	print 'C'
elif 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=input()
if b="A":
    print("T")
elif b="T":
    print("T")
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 b=='A':
  print "T"
if b=='c':
  print "G"
if b=='G':
  print "C"
if b=='T':
  print "A"

b = input()

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

b = int(input())

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

b = int(input())

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

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


b = input()
c = {
  'A': 'T',
  'C': 'G',
  'G': 'C',
  'T': 'A',
}
print(c[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')
}else if b =='T'{
  print('A')
}else if b == 'C'{
  print('C')
}else{
  print('G')
}

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 = list(input())
acgt = ['A','C','G','T']
cnt = 0
ans = 0
for i in range(len(s)):
    if s[i] in acgt:
        cnt+=1
    else:
        ans = max(ans,cnt)
        cnt = 0
print(ans)


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

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

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

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


b = (input())
if b == "A":
    print("T")
elif b == "C":
    print("G")
elif b == "T":
    print("A")
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 = input().split()
Q = int(Q)
S = input()

list1 = []

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

for i in list1:
    print(i)

N, Q = map(int, input().split())
S = 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])  

b = input()

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

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

dict={"A":"T","C":"G","T":"A","G":"C"}
print(dict[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):
b = input()

c = {A:T,T:A,C:G,G:C}

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

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

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


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


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=="G":
  print("C")
else
  print("G")

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):
b = str(inut())

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



b = str(inut())

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



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

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="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):
N,Q=map(int,input().split())
S=input()
ls=[];rs=[]
for i in range(Q):
    l,r=map(int,input().split())
    n=0;a=False
    for k in S[(l-1):(r)]:
        if k!="A" and a==False:
            pass
        elif k=="A":
            a=True
        elif a:
            if k=="C":
                n+=1
            else:
                a=False
    print(n)
    
    

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

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')
elif a == 'C':
  print('T')
elif a == 'G':
  print('C')
elif a == 'T':
  print('G')

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

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

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

mod = 10 ** 9 + 7

dp = [[[[0] * 4 for _ in range(4)] for _ in range(4)] for _ in range(N + 1)]

dp[0][3][3][3] = 1

print(dp)
for i in range(N):
    for j in range(4):
        for k in range(4):
            for m in range(4):
                if dp[i][j][k][m] == 0:
                    continue
                for l in range(4):
                    if l == 2 and j == 1 and k == 0:
                        continue
                    if l == 2 and j == 0 and k == 1:
                        continue
                    if l == 1 and j == 2 and k == 0:
                        continue
                    if l == 2 and j == 1 and m == 0:
                        continue
                    if l == 2 and k == 1 and m == 0:
                        continue
                    dp[i + 1][l][j][k] += dp[i][j][k][m]
                    dp[i + 1][l][j][k] %= mod

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


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):
b = str(input())
atcg = [["A", "T"],["C", "G"]]

for i in atcg:
  if b in i:
    print(i.remove(b)[0])
    break

b = str(input())
atcg = [["A","T"]["C","G"]]

for i in atcg:
  if b in i:
    print(i.pop(b)[0])
    break

print("ATACGC"["ATACGC".find(str(input()))+1])


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("塩基を入力してください")
c={'A':'T','T':'A','C':'G','G':'C'}
print(c[b])


b=input()
c={'A':'T','T':'A','C':'G','G':'C'}
print(c[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):
# coding: utf-8

str = input()

if str =='A' :
    str = 'T'
    break
elif str == 'T' :
    str = 'A'
    break
elif str == 'C':
    str = 'G'
elif str == 'G':
    str = 'C'

print(str)

# coding: utf-8

str = input()

if str =='A' :
    str = 'T'
elif str == 'T' :
    str = 'A'
elif str == 'C':
    str = 'G'
elif str == 'G':
    str = 'C'

print(str)

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()
s = (("A", "T"), ("C", "G"))
d = dict(s)+ dict(i[::-1] for i in s)

print(d[a])

#!/usr/bin/env python
a = input()
s = (("A", "T"), ("C", "G"))
d = dict(s)
d.update(dict(i[::-1] for i in s))

print(d[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()
N = len(S)
ans = 0
for i in range(N):
  for j in range(i,N):
    if all('ATGC'.count(c) == 1 for c in S[i:j+1]):
      ans = max(ans,j-i+1)
      
print(ans)


S = input()
N = len(S)
ans = 0
for i in range(N):
  for j in range(i,N):
    if all('ATGC'.count(c) == 1 for c in S[i:j+1]):
      ans = max(ans,j - i + 1)
print(ans)

b = input()
enki = ['A','T','G','C']

if b == enki[0]:
  print('T')
elif b == enki[1]:
  print('A')
elif b == enki[2]:
  print('C')
else:
  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):
n,q=map(int,input().split())
s=list(input())
value=[0]*n
ans_list=[]
length=[]
     
for i in range(len(s)-1):
  value[i+1]=value[i]+(1 if s[i]=='A' and s[i+1]=='C' else 0)
  
for i in range(q):
  l,r=map(int,input().split())
  print(value[r-1]-value[l-1])

a = input()

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


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):
b=input()
print(b.translate(str.maketrans('A':'x','C':'y','T':'A','G':'C','x':'C','y':'G')))

b=str(input())
print(b.translate(b.maketrans({'A':'x','C':'y','T':'A','G':'C','x':'C','y':'G'})))

b=input()
print(b.translate(b.maketrans({'A':'x'},{'C':'y'},{'T':'A'},{'G':'C'},{'x':'C'},{'y':'G'})))

b=str(input())
print(b.translate(b.maketrans({'A':'x'},{'C':'y'},{'T':'A'},{'G':'C'},{'x':'C'},{'y':'G'})))

b=input()
print(b.translate(b.maketrans('A':'x','C':'y','T':'A','G':'C','x':'C','y':'G')))

b=str(input())
print(b.translate(b.maketrans({'A':'x','C':'y','T':'A','G':'C','x':'T','y':'G'})))

b=str(input())
print(b.translate(b.maketrans({'A':'T','C':'G','T':'A','G':'C'})))

Verdicts: Runtime Error

Wrong Answer

Runtime Error

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

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


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

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

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

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

  


str = input()
str_arr = list(str)
atcg = ['A', 'T', 'C', 'G']

forward = 0
for i in range(len(str_arr)):
  if str_arr[i] in atcg:
  	break
  else:
    forward += 1
 
backward = 0
for i in range(len(str_arr)):
  if str_arr[len(str_arr) - i - 1] in atcg:
  	break
  else:
    backward += 1
    
print(len(str_arr) - forward - backward)

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

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):
a = input()
if a == 'A': print('T')
elif a == 'T':print('A')
else 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')

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()
cnt = 0
max = 0

for i in range(len(str)):
  if str[i] == 'A' or str[i] == 'C' or str[i] == 'G' or str[i] == 'T':
    cnt += 1
  else:
    if max < cnt:
      max = cnt
      cnt = 0

if max < cnt:
   max = cnt
   cnt = 0

print(max)

str = input()

if str = 'A':
  print('T')
else if str ='T':
  print('A')
else if str ='C':
  print('G')
else if str ='G':
  print('C')
else:
  print('error')

str = input()

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

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

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

b = input()

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

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

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