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

for i in range(N-1):
  if S[i:i+2]=="AC":
    c += 1
  AClst.append(c)
AClst.append(c)

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

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


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

a = input()
dic = {'A' : 'T',
       'C' : 'G',
       'G' : 'C',
       'T' : 'A'}
print(dic[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):
a = input()

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

a = input()

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


for line in sys.stdin.readlines():
    if line == 'A':
        print('T')
    if line == 'T':
        print('A')
    if line == 'C':
        print('G')
    if line == 'G':
        print('C')


import sys


for line in sys.stdin.readlines():
    line=line.strip()
    if line == 'A':
        print('T')
    if line == 'T':
        print('A')
    if line == 'C':
        print('G')
    if line == '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):
ATCG

enki = input()
if enki == "A":
  return "T"
elif enki == "T":
  return "A"
elif enki == "C":
  return "G"
elif enki == "G":
  return "C"

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

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

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

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

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

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()
t=[0]*N
for i in range(N-1):
    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=input()
l,r=[],[]
for i in range(Q):
    l0,r0=map(int,input().split())
    l.append(l0)
    r.append(r0)
c={}
for i in range(Q):
    for i in range(l[i]-1,r[i]-1):
        if (S[i]=='A') and (S[i+1]=='C'):
            c[i]=1
    print(int(c.count(1)))

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):
#!/usr/bin/env python3

import sys

arg = list(input())

if not set(arg) & set('ACGT'):
  print(' ')
  sys.exit(0)

index_list = []
index_list += [i for i, x in enumerate(arg) if x == 'A']
index_list += [i for i, x in enumerate(arg) if x == 'C']
index_list += [i for i, x in enumerate(arg) if x == 'G']
index_list += [i for i, x in enumerate(arg) if x == 'T']
index_list = sorted(index_list)

index = 0
count = 1
ans_i = 0
anses = []

while ( index + 1 ) <= len(index_list):

  if ( index + 1 ) == len(index_list):
    anses.append(count)
  elif index_list[index] + 1 == index_list[index+1]:
    count = count + 1
  else:
    anses.append(count)
    count, ans_i = 1, ans_i + 1

  index = index + 1

print(max(anses))

#!/usr/bin/env python3

import sys

arg = list(input())

if not set(arg) & set('ACGT'):
  print(' ')
  sys.exit(0)

index_list = []
index_list += [i for i, x in enumerate(arg) if x == 'A']
index_list += [i for i, x in enumerate(arg) if x == 'C']
index_list += [i for i, x in enumerate(arg) if x == 'G']
index_list += [i for i, x in enumerate(arg) if x == 'T']
index_list = sorted(index_list)

index = 0
count = 1
ans_i = 0
anses = []

while ( index + 1 ) <= len(index_list):

  if ( index + 1 ) == len(index_list):
    anses.append(count)
  elif index_list[index] + 1 == index_list[index+1]:
    count = count + 1
  else:
    anses.append(count)
    count, ans_i = 1, ans_i + 1

  index = index + 1

print(max(anses))

S = input()
list_S = [S]
ch = 0
an = 0
for i in S :
  if i in list_S:
    ch += 1
  else :
    an = max(an, ch)
    ch = 0
print(an)

S = input()
 
ans = 0
c = 0
for s in S:
    if s in ['A', 'C', 'G', 'T']:
        c += 1
    else:
        ans = max(ans, c)
        c = 0
ans = max(ans, c)
print(ans)

#!/usr/bin/env python3

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

print(base[input()])

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

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

a = str(input())

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

a = str(input())

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

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

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


Verdicts: Runtime Error

Runtime Error

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

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

~                                                                                                    
~                                                                                                    
~                                                                                                    
~                                                                                                    
~                                                                     

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 'G' if b=='C' else 'C')

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

Verdicts: Runtime Error

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

Submission attempts (in order):
print('TCGA'[id('')%5])

print('TCGA'[id('')%5])

print('TCGA'[id('')%5])

print('TCG A'[ord(input())%5])

Verdicts: 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()
li = ["A","T","C","G"]

cnt = 0
cntli = []
for i in range(len(s)):
    if s[i] in li:
        cnt += 1
    else:
        cntli.append(cnt)
        cnt = 0
else:
    cntli.append(cnt)

print(max(cntli))

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

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

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

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

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

print(c[b])

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

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

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

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

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

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

n = input()

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


n = input()

if(n == "A"):
    print("T")
elif(n == "C"):
    print("G")
elif(n == "G"):
    print("C")
elif(n == "T"):
    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):
print('ATCG'['TAGC'.index()])

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

Verdicts: Runtime Error

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

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

S=input()
count=0
result=0
for i in S:
    if i in 'AGTC':
        count+=1
    else:
        result=max(result,count)
        count=0
print(result)

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

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

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

Verdicts: Runtime Error

Runtime Error

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):
n,q = (int(i) for i in input().split())
s = input()

for i in range(q):
    l,r = (int(i) for i in input().split())
    cnt =  s.count('AC',l-1,r)
    print(cnt)

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

Verdicts: Runtime Error

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

Submission attempts (in order):
S = input()
 
len = 0
ans = 0
for ch in S:
    if ch in 'ACGT':
        len += 1
        ans = max(ans, len)
    else:
        len = 0
print(ans)

b = input().strip()

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

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

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 = '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):
N,Q=[int(n) for n in input().split(' ')]
S=input()
a=''
for i in range(Q):
  l,r=[int(n) for n in input().split(' ')]
  a=a+str(S[l-1:r].count('AC'))+'\n'
print(a)


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

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

I=input()

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


b = input()

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


Verdicts: Runtime Error

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

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

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

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

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

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

Runtime Error

Runtime Error

Runtime Error

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

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

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

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

b = input()
aa = {"A":"T", "T":"A", "G":"C", "C":"G"}
print(aa[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 "AT".find(b):
    print("A" if b == 'T' else "T")
if "CG".find(b):
    print("C" if b == 'G' else "G")


b=input()
if "AT".find(b) != -1:
    print("A" if b == 'T' else "T")
if "CG".find(b) != -1:
    print("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):
b = input()
if b == "A":
  print("G")
elif b == "G":
  print("A")
elif b == "C":
  print("T")
else:
  print("C")

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

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

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

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

data=input()
if data=="A":
  print("T")
elif data=="T":
  print("A")
elif data=="G":
  print("C")
elif data=="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()
a = "ATCG"
m = [0]
for i in range(len(s)):
    if s[i] in a:
        j = i + 1
        niz = 1
        while j < len(s) and s[j] in a:
            niz += 1
            j += 1
        m.append(niz)
print(max(m))

# 02:49


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

# 00:56


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


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

Verdicts: Wrong Answer

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

Submission attempts (in order):
import re

str = input()


pattern = r"[ATCG]+"

matched_list = re.findall(pattern, str)

maxlength = 0
for item in matched_list:
    tmplength = len(item)
    if maxlength < tmplength:
        maxlength = tmplength

print(maxlength)

base = input()

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

Verdicts: Wrong Answer

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

Submission attempts (in order):
ref=imput()

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

ref=input()

if (ref=="A"):
  print("T")
elif (ref=="T"):
  print("A")
elif (ref=="G"):
  print("C")
elif (ref=="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()
num = []
lists = ["A","c","G","T"]
count = 0

for i in range(len(s)):
    if s[i] in lists:
        count +=1
    else:
        num.append(count)
        count = 0
else:
    num.append(count)
print(max(num))
 
  

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

b = input()

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


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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
def main():
    s = input()
    s = s.replace("A", "T").replace("T", "A").replace("G", "C").replace("C", "G")
    print(s)


if __name__ == '__main__':
    main()

b = input()

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


Verdicts: Wrong Answer

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

Submission attempts (in order):
import re
N, Q = map(int, input().split())
S = input()
l = []
r = []
for i in range(Q):
    li, ri = map(int, input().split())
    l += [li]
    r += [ri]

for ind in range(Q):
    substr = S[max(0, l[ind]-1) : min(r[ind], N)]
    #print(substr.count("AC"))
    print(len(re.findall("AC", S)))

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

b = input()
d = dict()
d['A'] = 'T'
d['T'] = 'A'
d['C'] = 'G'
d['G'] = 'C'

print(d[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':
  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 = map(str, input())

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

b = map(str, 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')
elif(b == 'G'):
    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=raw_input()

if b in {'A','T'}:
    if b == 'A':
        print('T')
    else:
        print('A')
elif b in {'G','C'}:
    if b == 'G':
        print('C')
    elif b=='C':
        print('G')

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


b=raw_input()
#b=str(b_in)
if b=="A":
  print("T")
elif b=="G":
  print("C")
elif b=="T":
  print("A")
elif b=="C":
  print("G")

b=input()

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

print(ans)

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

Submission attempts (in order):

a = input()

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


a = input()

if a == 'A':
    print('T')
elif a == 'T':
    print('A')
elif a == '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 numpy as np
import sys
readline = sys.stdin.readline
read = sys.stdin.read

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


import numpy as np
import sys
readline = sys.stdin.readline
read = sys.stdin.read

b = readline().rstrip()
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):
N,Q=map(int,input().split())
S=input()
word_list=list(S)
for i in range(Q):
  count=0
  flag =0
  l,r=map(int,input().split())
  box=word_list[l-1:r]
  for i in box:
    if i == 'A':
      flag =1
    elif i!= 'C':
      flag=0
    if flag == 0 and i=='C':
      flag = 0
    if flag == 1 and i =='C':
      count += 1
      flag = 0
  print(count)

word=input()
if word == 'A':
  print('T')
elif word == 'T':
  print('A')
elif word == '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()
ans,pair = ['A','C','G','T'],['C','A','T','G']
for i,j in zip(ans,pair):
    if j == b:
        print(i)

b = input()
ans,pair = ['A','C','G','T'],['T','G','C','A']
for i,j in zip(ans,pair):
    if j == b:
        print(i)

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


b=input()

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

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 -*-
NQ = input().split(" ")
S = str(input())
N = int(NQ[0])
Q = int(NQ[1])
result_list = []
l = 0
r = 0
lr = ""
for i in range(0, Q):
  lr = input().split(" ")
  l = int(lr[0])
  r = int(lr[1])
  subStr_S = str(S[l-1:r]).replace("G", "").replace("T", "")
  result_list.append(subStr_S.count("AC"))

[print(result) for result in result_list]

# -*- coding: utf-8 -*-
input_val = str(input())

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

b = int(stdin.readline().rstrip()))

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


from sys import stdin

b = stdin.readline().rstrip()

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

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

a = input()

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

Verdicts: Wrong Answer

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

Submission attempts (in order):
b = input()
a = ''
for i in range(4):
    if b[i] == 'A':
        a += 'T'
    elif b[i] == 'T':
        a += 'A'
    elif b[i] == 'C':
        a += 'G'
    elif b[i] == 'G':
        a += 'C'
print(a)


b = input()
a = ''
for i in range(len(b)):
    if b[i] == 'A':
        a += 'T'
    elif b[i] == 'T':
        a += 'A'
    elif b[i] == 'C':
        a += 'G'
    elif b[i] == 'G':
        a += 'C'
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):
Dict = {'A':'T','C':'G','T':'A','G':'C'}
tmp = input()
print(Dict(tmp))

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

Verdicts: Runtime Error

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

Submission attempts (in order):
import sys

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


import sys

input = sys.stdin.readline
b = input()
if b[0] == 'A':
    print('T')
elif b[0] == 'T':
    print('A')
elif b[0] == '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 = input()

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

else:
  pass


n = input()

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



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

Runtime Error

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

Submission attempts (in order):
def main():
    k = input()
    if k == "A":
        print("C")
    if k == "C":
        print("A")
    if k == "T":
        print("G")
    if k == "G":
        print("T")


if __name__ == "__main__":
    main()


def main():
    k = input()
    if k == "A":
        print("T")
    if k == "T":
        print("A")
    if k == "C":
        print("G")
    if k == "G":
        print("C")


if __name__ == "__main__":
    main()


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

arg = input()

if arg=='A': arg='T'
if arg=='T': arg='A'
if arg=='C': arg='G'
if arg=='G': arg='C'

print(arg)

import sys

arg = input()

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

print(arg)

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 = input().split()
S = input()
for i in range(int(Q)):
    l, r = (int(x) for x in input().split())
    sub_S = S[l-1:r]
    count = 0
    print('hoge')

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

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


Verdicts: Wrong Answer

Accepted