Problem:


Score : 100 points

Problem Statement

On the Planet AtCoder, there are four types of bases: A, C, G and T. A bonds with T, and C bonds with G.

You are given a letter b as input, which is A, C, G or T. Write a program that prints the letter representing the base that bonds with the base b.

Constraints

b is one of the letters A, C, G and T.

Input

Input is given from Standard Input in the following format:

b

Output

Print the letter representing the base that bonds with the base b.

Sample Input 1

A

Sample Output 1

T

Sample Input 2

G

Sample Output 2

C



Sample input:
A


Sample output:
T

Submission status: Accepted

Solution code:
enki = input()

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

Submission status: Accepted

Solution code:
b = input()
ans = ''
for i in range(len(b)):
    if b[i] == 'A':
        ans = ans + 'T' 
    elif b[i] == 'T':
        ans = ans + 'A'
    elif b[i] == 'G':
        ans = ans + 'C'
    elif b[i] == 'C':
        ans = ans + 'G'
        
print(ans)

Submission status: Accepted

Solution code:
word = input()
if word == "A":
  print("T")
elif word == "T":
  print("A")
elif word == "G":
  print("C")
elif word == "C":
  print("G")

Submission status: Accepted

Solution code:
l1 = ['A', 'C', 'G', 'T']
l2 = ['T', 'G', 'C', 'A']

s = input()
print(l2[l1.index(s)])

Submission status: Accepted

Solution code:
moji = input()

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

exit()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

for c in b:
  if c == 'A': print('T', end="")
  if c == 'T': print('A', end="")
  if c == 'G': print('C', end="")
  if c == 'C': print('G', end="")
print()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

i = input()


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

Submission status: Accepted

Solution code:
b = str(input())

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
c = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
input_text = input()
output_text = ''

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

Submission status: Accepted

Solution code:
pair = {'A': 'T', 'T':'A', 'C': 'G', 'G': 'C'}
b = raw_input()
print pair[b]

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    b = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G'}
    print(b[input()])


main()

Submission status: Accepted

Solution code:
gene = {x:y for x,y in zip("ATCG","TAGC")}
b = input()
print(gene[b])

Submission status: Accepted

Solution code:
def readln():
    return list(map(int, input().split()))


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

Submission status: Accepted

Solution code:
from sys import stdin
import math
import itertools


def makeIntMatrix(lines):
    intMatrix = []
    for a in makeStringMatrix(lines):
        intMatrix += [int(b) for b in a]
    return intMatrix


def makeStringMatrix(lines):
    stringMatrix = [line.split() for line in lines]
    return stringMatrix


def makeInt(line):
    return int(line.rstrip())


def makeMultiInteger(line):
    return [int(x) for x in line.rstrip().split()]


def solve(input_string):
    N = input_string
    if N == 'A':
        return 'T'
    elif N == 'T':
        return 'A'
    elif N == 'G':
        return 'C'
    elif N == 'C':
        return 'G'


def main():
    input_lines = stdin.readline().rstrip()
    answer = solve(input_lines)
    print(answer)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
N = input()
if N == "A":
    print("T")
elif N == "T":
    print("A")
elif N == "C":
    print("G")
elif N == "G":
    print("C")

Submission status: Accepted

Solution code:
blist = ["A", "C", "G", "T"]
alist = ["T", "G", "C", "A"]

b = input()
print(alist[blist.index(b)])

Submission status: Accepted

Solution code:
a = input()
if a is "A":
	print("T")
elif a is "T":
	print("A")
elif a is "G":
	print("C")
elif a is "C":
	print("G")

Submission status: Accepted

Solution code:

 
def solve(b):
    if(b=='A'):
        print('T')
    elif(b=='T'):
        print('A')
    elif(b=='C'):
        print('G')
    else:
        print('C')
    
 
 
def main():
    b = input()
    solve(b)
 
 
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

#A
def A():
    b = S()
    b = b[0]
    if b == "A":
        print("T")
    elif b == "T":
        print("A")
    elif b == "C":
        print("G")
    elif b == "G":
        print("C")
    return

#B
def B():
    s = S()
    print(s.count("A")+s.count("G")+s.count("C")+s.count("T"))
    return

#C
def C():
    return

#D
def D():
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
ans = ""
for i in b:
    if i == 'A':
        ans = ans + 'T'
        continue
    if i == 'C':
        ans = ans + 'G'
        continue
    if i == 'G':
        ans = ans + 'C'
        continue
    if i == 'T':
        ans = ans + 'A'
        continue
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

blist = ["A", "C", "G", "T"]

b = stdin.readline().rstrip()

index = blist.index(b)

if index == 0:
    print("T")
elif index == 1:
    print("G")
elif index == 2:
    print("C")
else:
    print("A")

Submission status: Accepted

Solution code:
b = str(input())

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

print(X)

Submission status: Accepted

Solution code:
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces


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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
if b == 'A':
    b = b.replace('A', 'T')
elif b == 'T':
    b = b.replace('T', 'A')
elif b == 'C':
    b = b.replace('C', 'G')
else:
    b = b.replace('G', 'C')

print(b)

Submission status: Accepted

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

print(ans)

Submission status: Accepted

Solution code:
b = str(input())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
a1 = ['A', 'T']
a2 = ['C', 'G']
if b in a1: ans = a1
else: ans = a2
print(ans[1] if b==ans[0] else ans[0])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    b = input()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# 
import math
import sys
import itertools
import numpy as np

b = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a=list(input())
kekka=[]
for i in range(len(a)):
    if a[i]=="A":
        kekka.append("T")
    elif a[i]=="T":
        kekka.append("A")
    elif a[i]=="C":
        kekka.append("G")
    elif a[i]=="G":
        kekka.append("C")

print(kekka[0])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b=raw_input()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
b = input()

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

print(output)

Submission status: Accepted

Solution code:
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline

def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    S = input_raw[0]
    ans = ""
    for i in range(len(S)):
        if S[i] == "A":
            ans += "T"
        if S[i] == "T":
            ans += "A"
        if S[i] == "C":
            ans += "G"
        if S[i] == "G":
            ans += "C"
    print ans



if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    to = ['T', 'G']
    fr = ['A', 'C']

    inc = input()

    try:
        print(to[fr.index(inc)])
    except Exception:
        print(fr[to.index(inc)])


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3


if __name__ == '__main__':
    pair = {
        'A': 'T',
        'C': 'G',
        'G': 'C',
        'T': 'A'}

    b = input()

    ans = pair[b]
    print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 24 21:01:13 2019

@author: Wataru
"""

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#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')

Submission status: Accepted

Solution code:
enki = input()
if enki == "A":
    print("T")
if enki == "T":
    print("A")
if enki == "G":
    print("C")
if enki == "C":
    print("G")

Submission status: Accepted

Solution code:

b  = input()

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

Submission status: Accepted

Solution code:
#a
dic = {
    'A': 'T',
    'T': 'A',
    'G': 'C',
    'C': 'G',
}
s = input()
print(dic.get(s))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

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

def inputList():
	a=list(map(int,input().split()))
	return a

def multisort(li,index):
	return sorted(li,key=lambda x: x[index])

if(__name__=='__main__'):
	main()

Submission status: Accepted

Solution code:
S=input()

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

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

s = input()
d=dict(A='T', C='G', T='A', G='C')
print(d[s])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
L = ['A', 'C', 'G', 'T']
idx = L.index(b)
print(L[3-idx])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
I=input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys,heapq
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG =  True
def ddprint(x):
  if DBG:
    print(x)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
  b = input()
  if ('A' == b):
    print('T')
  elif ('T' == b):
    print('A')
  elif ('C' == b):
    print('G')
  elif ('G' == b):
    print('C')
  else:
    print(' ')

main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

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

print(h_dict[b])

Submission status: Accepted

Solution code:
b = input()
out = ""
for i in range(len(b)):
    if b[i] == "A":
        out += "T"
    elif b[i] == "T":
        out += "A"
    elif b[i] == "C":
        out += "G"
    elif b[i] == "G":
        out += "C"
print(out)

Submission status: Accepted

Solution code:
# coding: utf-8
data = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}
print(data[input()])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b=input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

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

a = input()

print(dic[a])

Submission status: Accepted

Solution code:
b = str(input())

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

Submission status: Accepted

Solution code:
x = input()

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

Submission status: Accepted

Solution code:
def main():
    x = input()
    print({ "A": "T", "T": "A", "C": "G", "G": "C" }[x])

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
in_ = input()

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

Submission status: Accepted

Solution code:
#coding: utf-8

n = raw_input()
translator = {"A": "T", "T": "A", "G": "C", "C": "G"}
print(translator[n])

Submission status: Accepted

Solution code:
txt=input()
ans=''
for t in txt:
	if(t=='A'):
		ans+='T'
	elif(t=='G'):
		ans+='C'
	elif(t=='C'):
		ans+='G'
	elif(t=='T'):
		ans+='A'

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
ans = ''
for i in range(len(b)):
    tmp = b[i]
    if tmp == 'A':
        ans += 'T'
    elif tmp == 'T':
        ans += 'A'
    elif tmp == 'C':
        ans += 'G'
    elif tmp == 'G':
        ans += 'C'

print(ans)

Submission status: Accepted

Solution code:
N = input()

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

Submission status: Accepted

Solution code:
N = input()

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

Submission status: Accepted

Solution code:
def solve():
  b = input()
  if b == 'A': return 'T'
  elif b == 'T': return 'A'
  elif b == 'C': return 'G'
  elif b == 'G': return 'C'
  return ' '

print(solve())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = "ACTG"
c = input()
print(a[(a.find(c) + 2) % 4])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
dicts_ = {"A": "T", "T": "A", "C": "G", "G": "C"}

string = input()

print(dicts_[string])

Submission status: Accepted

Solution code:
# /usr/bin/python
# -*- coding: utf-8 -*-
#
import sys


def solve(c):
  if c == 'A':
    return 'T'
  elif c == 'T':
    return 'A'
  elif c == 'G':
    return 'C'
  elif c == 'C':
    return 'G'

c = str(input())[0]
print(solve(c))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s=input()

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

Submission status: Accepted

Solution code:
a = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

d = dict({'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'})

print(d[b])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print('TAGC'['ATCG'.index(input())])

Submission status: Accepted

Solution code:
import sys,collections,math;sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

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

print(result)

Submission status: Accepted

Solution code:
from sys import stdin
b = input()

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

Submission status: Accepted

Solution code:
s=input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding:utf-8 -*-

def main():
  b = input()
  if b == 'A':
    print('T')
  if b == 'T':
    print('A')

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

if __name__=='__main__':
  main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = raw_input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import collections

def main():
	b = input()
	ans = "a"
	if b == 'A':
		ans = "T"
	if b == "T":
		ans = "A"
	if b == "C":
		ans = "G"
	if b == "G":
		ans = "C"
	
	
	print(ans)
			
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 24 20:49:38 2019

@author: Yamazaki Kenichi
"""

b = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()
ans =""
for chat in b:
    if chat == "A":
        ans += "T"
    elif chat == "T":
        ans += "A"
    elif chat == "G":
        ans += "C"
    else:
        ans += "G"
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
base = input()
a = ['A', 'T']
b = ['G', 'C']
if base in a:
  print([a[0], a[1]][base == 'A'])
else:
  print([b[0], b[1]][base == 'G'])

Submission status: Accepted

Solution code:
B=input()
if B=="A":
  print("T")
elif B=="G":
  print("C")
elif B=="C":
  print("G")
elif B=="T":
  print("A")

Submission status: Accepted

Solution code:
n = input()
if n == "A" :
    print("T")
if n == "T" :
    print("A")
if n == "C" :
    print("G")
if n == "G" :
    print("C")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
chars = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

b = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
pairs = {
    'A': 'T',
    'T': 'A',
    'C': 'G',
    'G': 'C',
}

x = input()
print(pairs[x])

Submission status: Accepted

Solution code:
num = input()

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

Submission status: Accepted

Solution code:
b=list(input())
ans=''
for i in b:
    if i=='A':
        ans+='T'
    elif i=='T':
        ans+='A'
    elif i=='C':
        ans+='G'
    elif i=='G':
        ans+='C'

print(ans)

Submission status: Accepted

Solution code:
a = input().rstrip()
if a == 'A':
  print('T')
elif a == 'T':
  print('A')
elif a == 'C':
  print('G')
else:
  print('C')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input().strip()
print({'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}[s])

Submission status: Accepted

Solution code:
enki=input()

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

print(ans)

Submission status: Accepted

Solution code:
n = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:
n=input()
#n=int(input())
#li=input().split()
#li=list(map(int,input().split()))
#d=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
#import math
#import numpy as np
if n=="A":
    ans="T"
elif n=="T":
    ans="A"
elif n=="C":
    ans="G"
elif n=="G":
    ans="C"




print(ans)

Submission status: Accepted

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