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()
data = []
for i in range(q):data.append(list(map(int, input().split())))
for i in data:print(len(s[i[0]-1:i[1]].split('AC'))-1)

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):
from sys import (stdin, stout)

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

for line in stdin:
  stdout.write(CORR_TAB[line.strip()] + '\n')

from sys import (stdin, stdout)

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

for line in stdin:
  stdout.write(CORR_TAB[line.strip()] + '\n')

Verdicts: Runtime Error

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

Submission attempts (in order):
b=str(input())
l=[]
for i in range(len(s)):
  if s[i]=='A':
    l.append('T')
  if s[i]=='T':
    l.append('A')
  if s[i]=='G':
    l.append('C')
  if l[i]=='C':
    l.append('G')
print(''.join(l))


s=str(input())
l=[]
for i in range(len(s)):
  if s[i]=='A':
    l.append('T')
  if s[i]=='T':
    l.append('A')
  if s[i]=='G':
    l.append('C')
  if s[i]=='C':
    l.append('G')
print(''.join(l))


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(S)
# print(len(S))
list = []
for i in range(len(S)):
    if(S[i] == "A" or S[i] == "C" or S[i] == "G" or S[i] == "T"):
        list.append(i)
# print(list)
NUM = []
for j in range(len(list)):
    num = 1
    for k in range(j,len(list)-1):
        # print("k:",k)
        # print("list[j+1]:",list[j+1], "list[j]:", list[j])
        # print("list[k+1]:",list[k+1], "list[k]:", list[k])
        if(list[k+1] - list[k] == 1):
        # if(list[j+1] - list[j] == 1):
            num += 1
            # print("k1:",k)
        else:
            NUM.append(num)
            # print("NUM1:", NUM)
            break
    else:
        NUM.append(num)
        # print("NUM2:", NUM)

# print("NUM3:",NUM)
if(len(NUM) == 0):
    print(0)
else:
    print(max(NUM))



b = str(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):
N=input()
a=ACGT
j=0
for i in range(4):
  if a[i]==N:
  	j=i  
print(a[3-j])

N=input()
a="ACGT"
j=0
for i in range(4):
  if a[i]==N:
  	j=i  
print(a[3-j])

Verdicts: Runtime Error

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

Submission attempts (in order):
a=input()
if a=="A":
    print("T")
else if a=="T":
    print("A")
else if a=="C":
    print("G")
else if 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):
File Edit Options Buffers Tools Python Help                                                                                                                                              
# -*- coding: utf-8 -*-                                                                                                                                                                  

import sys

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


import sys

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


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 = list(map(int,input().split()))
S = input()
L = []
R = []
for i in range(Q):
    a = list(map(int,input().split()))
    L.append(a[0])
    R.append(a[1])

S_count = []
count = 0
A_flag = False

for i in range(len(S)):
    if A_flag == True:
        if S[i] == "C" :
            count += 1
        A_flag = False
    else:
        if S[i] == "A" :
            A_flag = True
        else:
            A_flag = False
    S_count.append(count)

for i in range(Q):
    print(S_count[R[i] - 1] - S_count[L[i] - 1])

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):
seq = input()
seq_list = []
for char in seq :
    if char == "A":
        char2 = "T"
    elif char == "T":
        char2 = "A"
    elif char == "G":
        char2 = "C"
    elif char == "C":
        char2 = "G"
    seq_list.append(char2)
return("".join(seq_list))

def main():
  seq = input()
  seq_list = []
  for char in seq :
      if char == "A":
          char2 = "T"
      elif char == "T":
          char2 = "A"
      elif char == "G":
          char2 = "C"
      elif char == "C":
          char2 = "G"
      seq_list.append(char2)
  return("".join(seq_list))

N, Q= input().split(" ")
S = input()
index_list_all = []
for i in range(int(Q)):
    lQ, rQ = input().split(" ")
    index_list_all.append([int(lQ), int(rQ)])

for index_list in index_list_all:
    print(len(S[index_list[0] - 1: index_list[1]].split("AC")) - 1)

def main():    
    seq = input()
    seq = list(seq)
    for char in seq :
        if char == "A":
            char2 = "T"
        elif char == "T":
            char2 = "A"
        elif char == "G":
            char2 = "C"
        elif char == "C":
            char2 = "G"
    return(char2)

seq = input()
seq_list = []
for char in seq :
    if char == "A":
        char2 = "T"
    elif char == "T":
        char2 = "A"
    elif char == "G":
        char2 = "C"
    elif char == "C":
        char2 = "G"
    seq_list.append(char2)
return("".join(seq_list))

def main():
  seq = input()
  for char in seq :
      if char == "A":
          char2 = "T"
      elif char == "T":
          char2 = "A"
      elif char == "G":
          char2 = "C"
      elif char == "C":
          char2 = "G"
  return(char2)

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

Runtime Error

Wrong Answer

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

Submission attempts (in order):
S = input()
L=len(S)
longest=0
for i in range(L):
  for j in range(i+1):
    DUP=S[j:i]
    DUP=DUP.replace("A","#")
    DUP=DUP.replace("T","#")
    DUP=DUP.replace("G","#")
    DUP=DUP.replace("C","#")
    count=0
    for a in range(len(DUP)):
      if DUP[a]=="#":
        count+=1
      else:
        break
    else:
      longest=max(longest,count)
print(longest)
S = input()
L=len(S)
longest=0
for i in range(L):
  for j in range(i+1):
    DUP=S[j:i+1]
    DUP=DUP.replace("A","#")
    DUP=DUP.replace("T","#")
    DUP=DUP.replace("G","#")
    DUP=DUP.replace("C","#")
    count=0
    for a in range(len(DUP)):
      if DUP[a]=="#":
        count+=1
      else:
        break
    else:
      longest=max(longest,count)
print(longest)


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


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


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

Verdicts: Wrong Answer

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

Submission attempts (in order):
s = input()
ACGT = ["A","C","G","T"]
ans = 0
ANS = [0]

for i in range(len(s)):
    if s[i] in ACGT:
        ans += 1
    else:
        ans = 0
        
    ANS.append(ans)
        
print(max(ANS))

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

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

b = input()

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

Verdicts: Runtime Error

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

Submission attempts (in order):
print('aaa')


import sys

input_line = sys.stdin.readline()

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

print(enki_map[input_line.strip()])

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

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

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

b = input()

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

b = input()
b.replace('A', 'T')
b.replace('T', 'A')
b.replace('C', 'G')
b.replace('G', 'C')
print(b)

print('ATCG'['ATCG'.index(input()) ^ 1])

Verdicts: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
#include<bits/stdc++.h>
using namespace std;
int main(){
	char a;
	cin>>a;
	switch(a){
		case "A":cout<<"T"<<endl;
		case "T":cout<<"A"<<endl;
		case "C":cout<<"G"<<endl;
		case "G":cout<<"C"<<endl;
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	char a;
	cin>>a;
	switch(a){
		case "A":cout<<"T"<<endl;break;
		case "T":cout<<"A"<<endl;break;
		case "C":cout<<"G"<<endl;break;
		case "G":cout<<"C"<<endl;break;
	}
	return 0;
}


i = input();print("AT"[i=="A"]) if i in list("AT") else print("GC"[i=="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):
print(input().lower().replace("a","T").replace("t","A")replace("c","G")replace("g","C"))

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

Verdicts: Runtime Error

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

Submission attempts (in order):
N, Q = map(int, input().split())
2 S = input()
3 t = [0] * (N + 1)
4 for i in range(N):
5 t[i + 1] = t[i] + (1 if S[i : i + 2] == 'AC' else 0)
6 for i in range(Q):
7 l, r = map(int, input().split())
8 print(t[r-1] - t[l-1])

import numpy as np

s=input()

if s=='A':
    print('T')

if s=='T':
    print('A')

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

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


Verdicts: Runtime Error

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

Submission attempts (in order):
import sys
import math
import bisect

def main():
    s = input()
    if s == 'A':
        print('T')
    elif s == 'C':
        print('G')
    elif s == 'G'
        print('C')
    elif s == 'T':
        print('A')
    
if __name__ == "__main__":
    main()


import sys
import math
import bisect

def main():
    s = input()
    if s == 'A':
        print('T')
    elif s == 'C':
        print('G')
    elif s == 'G':
        print('C')
    elif s == 'T':
        print('A')
    
if __name__ == "__main__":
    main()


Verdicts: Runtime Error

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

Submission attempts (in order):
base = {'A':'A', 'C':'T', 'G':'C', 'T':'G'}

b = int(input())
print(base[b])


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

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

Verdicts: Runtime Error

Wrong Answer

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

Submission attempts (in order):
import re

S = input()
lmax = 0

for i in range(len(S)):
    for j in range(i, len(S)):
        ss = S[i:j+1]
        l = re.findall(r'[^ACGT]', ss)
        if len(l) == 0:
            lmax = max(lmax, len(ss))
        else:
            continue
print(lmax) 

b = input()

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

print(ans)

Verdicts: 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())
str = input()
for i in range(q):
  l,r = map(int, input().split())
  sub_str = str[(l-1):r]
  count = 0
  for j in range(len(sub_str)):
    if (sub_str[j:j+2] == 'AC'):
      count += 1
  print(count)

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()
X = ['A', 'T']
Y = ['G', 'C']
print(str(X - b) if b in X else str(Y - b))

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

p = {}
p["A"] = "A"
p["C"] = "T"
p["G"] = "C"
p["T"] = "G"

print(p[c])

c = input()

p = {}
p["A"] = "T"
p["G"] = "C"
p["T"] = "A"
p["C"] = "G"

print(p[c])

Verdicts: Wrong Answer

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

Submission attempts (in order):
S = input()
count = 0
x = [0]

for i in S:
  if i in ('A','C','G','T'):
    count += 1
  else:
    x.append(count)
    count = 0
x.append(count)

print(max(x))

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

for i in range(Q):
  l, r = map(int,input().split())
  Si = S[l-1:r]
  
  m = re.match('AC',Si)
  print(len(m.group())

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

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


Verdicts: Runtime Error

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

Submission attempts (in order):
S = input()
maxlength = 0
length = 0
for i in S:
  if i in 'ATGC':
    length += 1
  else:
    length =0
  maxlength = max(maxlength, length)
print (maxlength)

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

S = input().rstrip()
d = {'A':'T','C':'G','G':'C','T':'A'}
print(d[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):
b = input()
if b = 'A':
  print("T")
elif b = 'T':
  print("G")
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):
def main():
    b = input()
    argc = len(b)
    data = []
    for i in range(argc):
      if (b[i]=='A'):
        data.append('T')
      elif (b[i]=='T'):
        data.append('A')
      elif (b[i]=='C'):
        data.append('G')
      else:
        data.append('C')
    print(data)
main()


def main():
    b = input()
    argc = len(b)
    data = []
    for i in range(argc):
#       print(b[i])
      if (b[i]=='A'):
        data.append('T')
      elif (b[i]=='T'):
        data.append('A')
      elif (b[i]=='C'):
        data.append('G')
      else:
        data.append('C')
    result = ''.join(data)
    print(result)
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):
b = input()

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

b = input()

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

out_1 = 0
tmp_s = []
for c in tmp:
        if c == "A" or c == "G" or c == "T" or c == "C":
                tmp_s.append(c)
        else:
                if out_1 < len(tmp_s):
                        out_1 = len(tmp_s)
                tmp_s = []
print(out_1)

tmp = input()

if tmp == "A":
    print("G")
else:
    print("C")

tmp = input()

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

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

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


Verdicts: Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `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 = int(input())
if X == "A":
  	print("T")
elif X == "T":
  	print("A")
elif X == "C":
  	print("G")
else:
	print("C")

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

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

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

X = input()
if X == "A":
  	print("T")
elif X == "T":
  	print("A")
elif X == "C":
  	print("G")
elif X == "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):
S = input()
if S=="A":
    set="set_A"
if S=="C":
    set="set_C"
if S=="G":
    set="set_G"
if S=="T":
    set="set_T"

if set == "set_A":
    ans = "A"
if set == "set_C":
    ans = "T"
if set == "set_G":
    ans = "C"
if set == "set_T":
    ans = "G"
print(ans)    

S = input()
if S=="A":
    set="set_A"
if S=="C":
    set="set_C"
if S=="G":
    set="set_G"
if S=="T":
    set="set_T"

if set == "set_A":
    ans = "T"
if set == "set_C":
    ans = "G"
if set == "set_G":
    ans = "C"
if set == "set_T":
    ans = "A"
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):
b = str(input())

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

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

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

s = list(input())

L = []
cnt = 0

for x in s:
    if x == "A" or x == "C" or x == "G" or x == "T":
        cnt += 1
    else:
        L.append(cnt)
        cnt = 0
L.append(cnt)

print(max(L))

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):
# coding: utf-8
length,question = map(int, input().split())
string = input()
e = [[int(i) for i in input().split()] for i in range(question)]
c = 0
tmp = []

for i in e:
    s = ''
    for j in range(i[0],i[1]+1):
        s+=string[j-1]
    
    for n in range(len(s)):
        if s[n:n+2] == "AC":
            c+=1

    print(c)
    c = 0


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

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

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

b = input()
L = [["A","T"],["C","G"]]
for i in range(2):
    if b in L[i]:
        if L[i][0] == b:
            print(L[i][1])
        else:
            print(L[i][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):
b = int(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):
import sys

input = sys.stdin.readline


def main():
    b = input().rstrip()

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

    print(ans)


if __name__ == "__main__":
    main()


import sys

input = sys.stdin.readline


def main():
    b = input().rstrip()

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

    print(ans)


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

if a="A" or "T":
    if a=="T":
        b="A"
    if a=="A":
        b="T"

if a="C" or "G":
    if a=="C":
        b="G"
    if a=="G":
        b="C"

print(b)

a=input()

if a=="A" or "T":
    if a=="T":
        b="A"
    if a=="A":
        b="T"

if a=="C" or "G":
    if a=="C":
        b="G"
    if a=="G":
        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):
S = input()
gene = ['A','T','C','G']

length = len(S)
ans = 0
tmp = 0

for i in range(length):
  if S[i] in gene:
    tmp += 1
  else:
    tmp = 0
  if tmp >= ans:
    ans = tmp
print(ans)

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

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


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

Verdicts: Wrong Answer

Wrong Answer

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

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


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


Verdicts: Runtime Error

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

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

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

print(b)

b = input()

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

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

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

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

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

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

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

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

Verdicts: Runtime Error

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

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

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

Verdicts: Runtime Error

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

Submission attempts (in order):
d = ["A":"T","G":"C","C":"G","T":"A"]
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):
x = input()
if x = "A":
  print("T")
elif x = "T":
  print("A")
elif x = "C":
  print("D")
else x = "D":
  print("C")

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

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

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

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

S = input()
cnt = 0
ans = 0
for s in S:
    if s in "ATCG":
        cnt += 1
    else:
        cnt = 0
    ans = max(ans, cnt)
print(ans)


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


Verdicts: Runtime Error

Runtime Error

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)

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

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

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



b = input()

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

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

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

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

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: On the Planet AtCoder, there are four types of bases: `A`, `C`, `G` and `T`. `A` bonds with `T`, and `C` bonds with `G`.  You are given a letter b as input, which is `A`, `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"
else if b == "T":
  b = "A"
else if b == "C":
  b = "G"
else if b == "G":
  b = "C"
print(b)

b = input()
if b[i] == "A":
  b[i] = "T"
else if b[i] == "T":
  b[i] = "A"
else if b[i] == "C":
  b[i] = "G"
else if b[i] == "G":
  b[i] = "C"
print(b)

b = input()
for i in b:
  if b[i] == "A":
    b[i] = "T"
  else if b[i] == "T":
    b[i] = "A"
  else if b[i] == "C":
    b[i] = "G"
  else if b[i] == "G":
    b[i] = "C"
print(b)

b = input()
for i in b:
  if b[i] == "A":
    b[i] = "T"
  if b[i] == "T":
    b[i] = "A"
  if b[i] == "C":
    b[i] = "G"
  if b[i] == "G":
    b[i] = "C"
print(b)

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

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

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


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


Verdicts: Wrong Answer

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

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

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


S=input()
SS=S+"X"
ACGT=["A","C","G","T"]
m=0
for i in range(len(S)):
  j=0
  while SS[i+j] in ACGT:
    j+=1   
  m=max(m,j)
print(m)

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


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

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

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

Submission attempts (in order):
# -*- coding:utf-8 -*-

s = input()


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

# -*- coding:utf-8 -*-

b = input()

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

Verdicts: Wrong Answer

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

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

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

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

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
 

#A:=0,G:=1,C:=2,T:=3
 

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

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

Verdicts: Runtime Error

Runtime Error

Accepted