Problem:


Score : 100 points

Problem Statement

AtCoder Inc. holds a contest every Saturday.

There are two types of contests called ABC and ARC, and just one of them is held at a time.

The company holds these two types of contests alternately: an ARC follows an ABC and vice versa.

Given a string S representing the type of the contest held last week, print the string representing the type of the contest held this week.

Constraints

S is ABC or ARC.

Input

Input is given from Standard Input in the following format:

S

Output

Print the string representing the type of the contest held this week.

Sample Input 1

ABC

Sample Output 1

ARC

They held an ABC last week, so they will hold an ARC this week.



Sample input:
ABC


Sample output:
ARC

Submission status: Accepted

Solution code:
s = input()
print('ABC' if s != 'ABC' else 'ARC')

Submission status: Accepted

Solution code:
s = input()
if s == "ABC" :
    print("ARC")
else :
    print("ABC")

Submission status: Accepted

Solution code:
s = str(input())
if(s=="ABC"):
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
def resolve():
    S = input()

    if S == "ARC":
        print('ABC')
        return

    print('ARC')


resolve()

Submission status: Accepted

Solution code:
S = input("")
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    S = sr()
    if S == 'ABC':
        print('ARC')
    else:
        print('ABC')
resolve()

Submission status: Accepted

Solution code:
#A - A?C
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s=str(input())

if s=="ABC":
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
K = input()
if K == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
#a
k = input()
if k == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
#2020-05-03
a = input()
if a == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S = input()
print("ABC" if S == "ARC" else "ARC")

Submission status: Accepted

Solution code:
S = input()

if S[1] == "R":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
a = input()
if a == 'ARC':
    print('ABC')
else:
    print("ARC")

Submission status: Accepted

Solution code:
import math

i = input()

if i == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
def resolve():
    S = input()

    if S == "ABC":
        print("ARC")
    else:
        print("ABC")


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
i = input()

if i == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s = input()
if s == "ABC":print("ARC")
else: print("ABC")

Submission status: Accepted

Solution code:

S = input()

if S == 'ABC':
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:

S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

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

    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
S=input()

if S[1]=="B":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
n = str(input())
print("ABC") if n == "ARC" else print("ARC")

Submission status: Accepted

Solution code:
def resolve():
    '''
    code here
    '''
    S = input()

    if S == 'ABC':
        print('ARC')
    else:
        print('ABC')

if __name__ == "__main__":
    resolve()

Submission status: Accepted

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


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


# マイナス1した値を返却
def int1(x):
    return int(x) - 1


# 半角スペース区切り入力をIntに変換してMapで受け取る
def input_to_int_map():
    return map(int, input().split())


# 半角スペース区切り入力をIntに変換して受け取る
def input_to_int_tuple():
    return tuple(map(int, input().split()))


# 半角スペース区切り入力をIntに変換してマイナス1した値を受け取る
def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    s = input()

    if s == "ABC":
        return "ARC"

    return "ABC"


if __name__ == "__main__":
    print(main())

Submission status: Accepted

Solution code:
s = input()
if(s == 'ABC'):
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def main():
    S = get_input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input()
if s == 'ABC':
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
S = input()
if S[1] == "R":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
if input()[1] == "B":
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
x = input()

if x == 'ABC':
  print('ARC')
else:
  print("ABC")

Submission status: Accepted

Solution code:
t = input()
if t == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s = input()

if s == "ABC": print("ARC")
else: print("ABC")

Submission status: Accepted

Solution code:
# coding=UTF-8
from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
# input = sys.stdin.readline


def main():
    if input() == "ABC":
        print("ARC")
    else:
        print("ABC")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s=input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
N = str(input())

if N == "ABC":
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
# N, M = map(int, input().split())
A = input()

if A=='ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**5+10)
#input = sys.stdin.readline

S = input()
if S=='ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
S = input()
a = "ABC"
b = "ARC"
if S == b:
  print(a)
else:
  print(b)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline().rstrip()

def main():
  last = input()
  if last == 'ABC':
    print('ARC')
  else:
    print('ABC')

if __name__ == '__main__':
  main()

Submission status: Accepted

Solution code:
S = list(input())

if S[1] == 'B':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
s = input()
print("ARC" if s =="ABC" else "ABC")

Submission status: Accepted

Solution code:
S =input()
if S=='ARC':
    print('ABC')
else:
    print('ARC')

Submission status: Accepted

Solution code:

a=(input())

if a=="ARC":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
S = input()
if S=="ARC":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
# coding:utf-8

S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
pi = 3.1415926

############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))
################################################################
s = input().strip()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')
#print('No')
#print()

Submission status: Accepted

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

def input_one_number():
    return int(input())

def input_multiple_number():
    return map(int, input().split())

def input_multiple_number_as_list():
    return list(map(int, input().split()))

S = input()

if S == "ABC":
	print("ARC")
else:
	print("ABC")

Submission status: Accepted

Solution code:
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


def readints():
    return list(map(int, input().split()))


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]

s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
S=input()
if S=="ARC":
  print("ABC")
else:
  print("ARC")

Submission status: Accepted

Solution code:
def solve(a):
    if a == 'ABC':
        return 'ARC'
    else:
        return 'ABC'

if __name__ == "__main__":
    a = input()
    print(solve(a))

Submission status: Accepted

Solution code:
s = input()

print('ABC') if s == 'ARC' else print('ARC')

Submission status: Accepted

Solution code:
S = input()
ans = "ABC" if S == "ARC" else "ARC"
print(ans)

Submission status: Accepted

Solution code:
# Template 1.0
import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s = input()
if(s=="ABC"):
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s = input()
if s[1] == "R":print("ABC")
else:print("ARC")

Submission status: Accepted

Solution code:
K = input()
if K =="ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
X = input()
if X == "ABC":print("ARC")
else:print("ABC")

Submission status: Accepted

Solution code:
a = input()

if a == "ABC":
  print("ARC")
  
elif a == "ARC":
  print("ABC")

Submission status: Accepted

Solution code:
# coding: utf-8
import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
#@lru_cache(maxsize=None)
readline=sys.stdin.readline
sys.setrecursionlimit(2000000)
#import numpy as np
alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):#aはbの累乗数か
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
def hani(x,min_,max_):
    ret=x
    if x<min_:ret=min_
    if x>max_:ret=max_
    return ret
def seifu(x):
    return x//abs(x)
###################################################
def f():
    return
def main():
    s=input()
    if s=="ABC":print("ARC")
    else:print("ABC")
main()

Submission status: Accepted

Solution code:
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math


NN = 202020
MOD = 10**9+7
# MOD = 998244353
INF = float("inf")

s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import math
import collections

def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
    return 0

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = input()

if a == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s = input()
if s == 'ABC':
    print("ARC")
else:
    print('ABC')

Submission status: Accepted

Solution code:
S = input()
if(S == "ARC"):
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
S = input()

if S == 'ARC':
  print('ABC')
elif S == 'ABC':
  print('ARC')

Submission status: Accepted

Solution code:
S = input().rstrip()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input()
if s =="ABC":
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
x=input()
if x =="ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

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


def solve(S: str):
    print("ABC" if S == "ARC" else "ARC")
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  # type: str
    solve(S)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    s=input()
    print('ARC' if s=='ABC' else 'ABC')
main()

Submission status: Accepted

Solution code:
S=input()
if S=='ABC':
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
if __name__ == '__main__':
	S = input()
	if S =='ABC':
		print('ARC')
	else:
		print('ABC')

Submission status: Accepted

Solution code:
print({"ABC": "ARC", "ARC":"ABC"}[input()])

Submission status: Accepted

Solution code:
s = input()  # x = 1, y = 2

if s == "ABC":
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import collections
import itertools as it
import math
#import numpy as np
 
s  = input()
#  = int(input())
#  = map(int, input().split())
#  = list(map(int, input().split()))
#  = [int(input()) for i in range(N)]
#
# c = collections.Counter()

print('ABC' if s == 'ARC' else 'ARC')

Submission status: Accepted

Solution code:
S = input()
if S == "ABC": print("ARC")
else: print("ABC")

Submission status: Accepted

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

def main():
     s = input()

     if s == 'ABC':
          print('ARC')
     else:
          print('ABC')
     
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    s = input()
    if s == 'ARC':
        print('ABC')
    else:
        print('ARC')


def input_list():
    return list(map(int, input().split()))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
S = str(input())

if S[1] == 'B':
    print ('ARC')
else:
    print ('ABC')

Submission status: Accepted

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


def main():
    S = input()

    if S == "ABC":
        print("ARC")
    else:
        print("ABC")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def resolve():
	s = input()
	if s == 'ABC':
		print('ARC')
	else:
		print('ABC')
resolve()

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    s=input()
    if s=='ABC':
        print('ARC')
    else:
        print('ABC')
resolve()

Submission status: Accepted

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


def solve(S: str):
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  # type: str
    solve(S)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
S = input()


if S == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s=input()
if "ABC"==s:
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
def main():
    S = input()
    if S == 'ABC':
        print('ARC')
    else:
        print('ABC')
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')



main()

Submission status: Accepted

Solution code:
s = input()

print('ARC' if s=='ABC' else 'ABC')

Submission status: Accepted

Solution code:
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
s = input().strip()
if s =='ABC':
    print('ARC')
elif s == 'ARC':
    print('ABC')

Submission status: Accepted

Solution code:
a = input()
if(a[1] == 'B'):
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

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

if s == 'ABC':
    print('ARC')
elif s == 'ARC':
    print('ABC')

Submission status: Accepted

Solution code:
s=input()

if s=='ABC':
	print('ARC')
else:
	print('ABC')

Submission status: Accepted

Solution code:
def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")   

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
S = input()
if (S == 'ABC'):
  print('ARC')
else:
  print('ABC')

Submission status: Accepted

Solution code:
# list(map(int, input().split()))
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
s = input()
if s == "ABC":
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
A = input()

if A=="ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import bisect,sys
import math
from collections import deque

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
        
    return CONV()


def cumsum(As):
    s = 0
    for a in As:
        s+=a
        yield s


sys.setrecursionlimit(200005)


def main():
    S =sRaw()
    return "ABC" if S=="ARC" else "ARC"
    
if __name__ == "__main__":
    print(main())

Submission status: Accepted

Solution code:
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

if load(str) == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
s = input()
if(s=='ABC'):
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
s = input()
if (s=="ABC"):
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
i = input()
if i == "ABC":
	print("ARC")
else:
	print("ABC")

Submission status: Accepted

Solution code:
a = input()
if a == 'ABC': print('ARC')
else: print('ABC')

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
a = input().rstrip()
if a[1] == "B":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:

s = input()
if s =="ABC":
	print("ARC")

else:
	print("ABC")

Submission status: Accepted

Solution code:
def read_int():
    return int(input())

def read_int_map():
    return map(int,input().split(' '))

def read_int_list():
    return list(map(int,input().split(' ')))

def read_s_list_loop(n):
    return [input() for _ in range(n)]

S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
S=input()
if S[1]=='B':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
def resolve():
    s = input()
    if s == "ABC":
        print("ARC")
    else:
        print("ABC")
resolve()

Submission status: Accepted

Solution code:
s = input().strip()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
# coding: utf-8


def main():
    S = input()
    
    if S == "ABC":
        return "ARC"
    else:
        return "ABC"


print(main())

Submission status: Accepted

Solution code:
s = input()
# n = int(input())
# a, b = map(int, input().split())
# l = list(map(int, input().split()))

if s=="ABC":
    print("ARC")
elif s=="ARC":
    print("ABC")

Submission status: Accepted

Solution code:
a=input()
if a[1]=='B':
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

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

if S[1]=="B":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7

s=input().rstrip()
if s=="ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
s = input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
a = input()
if (a == "ABC"):
  print("ARC")
else:
  print("ABC")

Submission status: Accepted

Solution code:
def a166(s):

    ans = {"ABC":"ARC", "ARC":"ABC"}

    return ans[s]
def main():
    s = str(input())
    print(a166(s))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import numpy as np
import sys
import math
read = sys.stdin.readline

s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]

# n = int(input())
# a, b = list(map(int, input().split()))
# 
s = input()
ans = "ABC"
if s == "ABC":
    ans = "ARC"
print(ans)

Submission status: Accepted

Solution code:
n = input()

lis = {'ABC':'ARC','ARC':'ABC'}
print(lis[n])