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

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:
a = input()
if a == 'A':
  print("T")
elif a == 'T':
  print("A")
elif a == 'G':
  print("C")
else:
  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:
d = {
  'A': 'T',
  'T': 'A',
  'C': 'G',
  'G': 'C'
}
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:
"""
n = int(sys.stdin.readline())
a, b = map(int, sys.stdin.readline().split())
c = list(map(int, sys.stdin.readline().split()))
s = [list(map(int,list(sys.stdin.readline()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

a = 100
b = 0.987654321
print('{0:06d}-{1:6f}'.format(a,b))  # 0埋め, 小数点出力桁指定時のときの出力
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)


mod = 1000000007

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

Submission status: Accepted

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

Submission status: Accepted

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

b = input()

# print(b)

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

Submission status: Accepted

Solution code:
# 122 Double Helix
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()
s = "ACGT"
t = "TGCA"
print(t[s.find(b)])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:


b = input()
text = 'ATCGTAGC'
print(text[text.find(b)+4])

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:
b=input()
l="AGCTTCGA"
print(l[l.find(b)+4])

Submission status: Accepted

Solution code:
b = input()
AT = ['A','T']
CG = ['C','G']

if b in AT:
  print(list(set(AT)-set(b))[0])
else:
  print(list(set(CG)-set(b))[0])

Submission status: Accepted

Solution code:
b=input()
a=["A","T"]
c=["C","G"]
if b in a:
  a.remove(b)
  r = a 
else:
  c.remove(b)
  r = c
print("".join(r))

Submission status: Accepted

Solution code:
s = input()

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

Submission status: Accepted

Solution code:
a = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

main()

Submission status: Accepted

Solution code:
s=input()

if s=='A': 
	res='T'
else:
	if s=='T':
		res='A'
	else:
		if s=='G':
			res='C'
		else:
			res='G'

print(res)

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

Submission status: Accepted

Solution code:
enki_list_1 = ["A","T"]
enki_list_2 = ["C","G"]

b = input()
if (b=="A") or (b=="T"):
  enki_list_1.remove(b)
  print(enki_list_1[0])
else:
  enki_list_2.remove(b)
  print(enki_list_2[0])

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 = 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()
ans=""
for j in s:
  if j =="A":
    ans += "T"
  elif j =="T":
    ans += "A"
  elif j == "C":
    ans += "G"
  else:
    ans += "C"
print(ans)

Submission status: Accepted

Solution code:
S = str(input())

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

Submission status: Accepted

Solution code:
n=input();m="ATACGC";print(m[m.index(n)+1])

Submission status: Accepted

Solution code:
b = input()

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

Submission status: Accepted

Solution code:
b = input()
tmp = ['A','T','A','C','G','C']
for i in range(6):
  if b == tmp[i]:
    print(tmp[i+1])
    break

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

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

Submission status: Accepted

Solution code:
s1 = 'ACGT'
s2 = 'TGCA'
s = str(input())
for i in range(len(s1)):
  if s == s1[i]:
    print(s2[i])

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

Submission status: Accepted

Solution code:
"""
# 標準入力取得
## 文字列
 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())

## 数値
 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    b = sys.stdin.readline().rstrip()
    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:
s=input()
dic={'A':'T','T':'A','C':'G','G':'C'}
print(dic[s])

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
b = input()
d = {
    "A": "T",
    "T": "A",
    "G": "C",
    "C": "G"
}

print(d[b])

Submission status: Accepted

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

Submission status: Accepted

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

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

# input
b = input()

# solve
if b == 'A':
    ans = 'T'
elif b  == 'T':
    ans = 'A'
elif b == 'C':
    ans = 'G'
else:
    ans = 'C'

# output
print(ans)

Submission status: Accepted

Solution code:
b = input()

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

print(out[b])

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
print(*["A" if x=="T" else "T" if x=="A" else "C" if x=="G" else "G" for x in str(input())])

Submission status: Accepted

Solution code:
s = input()

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

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

Submission status: Accepted

Solution code:
def main():

    """ convenient functions
    # for i, a in enumerate(iterable)
    # q, mod = divmod(a, b)
    # divmod(x, y) returns the tuple (x//y, x%y)
    # Higher-order function: reduce(operator.mul, xyz_count, 1)
    # manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
    """

    """convenient decorator
    # @functools.lru_cache():
    # to facilitate use of recursive function
        # ex:
        # from functools import lru_cache
        # import sys
        # sys.setrecursionlimit(10**9)
        # @lru_cache(maxsize=None)
        # def fib(n):
        #     if n < 2:
        #         return n
        #     return fib(n-1) + fib(n-2)
        # print(fib(1000))
    """
    
    # import numpy as np
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product # https://docs.python.org/ja/3/library/itertools.html
    # accumulate() returns iterator! to get list: list(accumulate())
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  # prime factor
        b, e = 2, 0  # base, exponent
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        # TODO: How should I do when n - r is negative?
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict # https://docs.python.org/ja/3/library/collections.html#collections.deque
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
    from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
    import operator
    from operator import itemgetter
    # ex1: List.sort(key=itemgetter(1))
    # ex2: sorted(tuples, key=itemgetter(1,2))
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    # first create factorial_list
    # fac_list = mod_factorial_list(n)
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!
    def modinv(a, p = MOD):
        # evaluate reciprocal using Fermat's little theorem:
        # a**(p-1) is identical to 1 (mod p) when a and p is coprime
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        # fac_list = modfactorial_list(100)
        # print(modcomb(100, 5, modfactorial_list(100)))
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    # initialize variables
        # to initialize list, use [0] * n
        # to initialize two dimentional array, use [[0] * N for _ in range(N)]
    # set inputs
        # open(0).read() is a convenient method:
        # ex) n, m, *x = map(int, open(0).read().split())
        #     min(x[::2]) - max(x[1::2])
        # ex2) *x, = map(int, open(0).read().split())
        #     don't forget to add comma after *x if only one variable is used
    # preprocessing
        # transpose = [x for x in zip(*data)]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
        # flat = [flatten for inner in data for flatten in inner]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # calculate and output
        # output pattern
        # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6
    """

    # functions used
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    # single int: int(r())
    # single string: r()
    # single float: float(r())
    # line int: R()
    # line string: r().split()
    # line (str, int, int): [j if i == 0 else int(j) for i, j in enumerate(r().split())]
    # lines int: [R() for _ in range(n)]
    """

    if __name__ != '__main__':
        # for test
        sys.stdin = open('sample.txt')

    # ----------------------------------
    # main

    b = r()
    if b == 'A':
        print('T')
    elif b == 'T':
        print('A')
    elif b == 'G':
        print('C')
    else:
        print('G')
    
    # end of main
    # ----------------------------------

    """memo: how to use defaultdict of list
    # initialize
    Dic = defaultdict(list)
    # append / extend
    Dic[x].append(y)
    # for
    for k, v in Dic.items():
    """

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

b = input()

f(b)

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

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    
    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:
ACGT = ['A', 'C', 'T', 'G']
X = input()
for i in range(0, 4):
	if ACGT[i] == X:
		print(ACGT[(i+2)%4])

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
b=str(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:
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()

bases = ('A', 'C', 'G', 'T')

for idx, base in enumerate(bases):
  if base == b:
    print(bases[int(~(idx))])
    break

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')
else:
    pass

Submission status: Accepted

Solution code:
b = input()
enki = {"A":"T", "C":"G", "G":"C", "T":"A"}
print(enki[b]) if b in enki else 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")
elif s=="G":
      print("C")

Submission status: Accepted

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

Submission status: Accepted

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


main()

Submission status: Accepted

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

Submission status: Accepted

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

def input(): return sys.stdin.readline()[:-1]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def MATINT(h): return [list(map(int, input().split())) for _ in range(h)]
def MATSTR(h): return [input() for _ in range(h)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
inf = float('inf')
mod = 10 ** 9 + 7

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

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = input()
b = [["A", "T"], ["T", "A"], ["C", "G"], ["G", "C"]]
for i in range(4):
    if b[i][0] == a:
        print(b[i][1])
        exit()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(dic[b])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def A(n):
    dic = {"A":"T","T":"A","G":"C","C":"G"}
    return dic[n]

b = input()
print(A(b))

Submission status: Accepted

Solution code:
b = input()

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

print(t[b])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b=input()
l=['A','T','C','G']
for i in range(4):
	t=l.index(b)+i
	if t==1:
		print(l[i])
	elif t==5:
		print(l[i])

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
enki_a = ['A','T']
enki_b = ['C','G']

b = input()

if b in enki_a:
  enki_a.remove(b)
  print(''.join(enki_a))
elif b in enki_b:
  enki_b.remove(b)
  print(''.join(enki_b))

Submission status: Accepted

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

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:
# Double Helix

b = input()

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

Submission status: Accepted

Solution code:
b = input()
print(b.replace('A','a').replace('T','t').replace('C','c').replace('G','g').replace('a','T').replace('t','A').replace('c','G').replace('g','C'))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
b=input()
l=[['A','T'],['C','G']]
for i in range(2):
    if b==l[i][0]:
        print(l[i][1])
        break
    elif b==l[i][1]:
        print(l[i][0])
        break

Submission status: Accepted

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

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

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:
B=input()
W="TACG"
N="ATGC".find(B)
#print(N)
print(W[N])

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 = str(input())
sample = ["A", "C", "G", "T"]
ans = ["T", "G", "C", "A"]
print(ans[sample.index(b)])

Submission status: Accepted

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

Submission status: Accepted

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