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()
if s=='ABC':print('ARC')
else:print('ABC')

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

if __name__ == '__main__':
    s = sys.stdin.readline().rstrip()
    if s[1] == 'B':
        print('ARC')
    else:
        print('ABC')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = input()
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:
S=input()

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

Submission status: Accepted

Solution code:
from math import factorial as fact
import math
import sys
import itertools
import numpy as np
from collections import Counter
import datetime


#入力:N(int:整数)
def input1():
	return int(input())

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())

#入力:[n1,n2,...nk](int:整数配列)
def input_array():
	return list(map(int,input().split()))

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(range(n),r))



def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets

#公約数の列挙
def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	#x:縦，y:横
	return fact(x+y)/fact(x)/fact(y)

# 素因数分解
def factorization(n):
	tmp=n
	count=0
	for i in range(2,int(n**0.5)+2):
		if tmp%i==0:
			cnt=0
			while tmp%i==0:
				cnt+=1
				tmp//=i
			count+=1
	if tmp!=1:
		count+=1

	return count
			

s=str(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=='ARC':
  print('ABC')
else:
  print('ARC')

Submission status: Accepted

Solution code:
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

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

Submission status: Accepted

Solution code:
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    SS = S()

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

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

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

s = s_in()

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:
import sys
import math
from collections import Counter
import itertools
import fractions
#from functools import reduce

# 入力を整数に変換して受け取る
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
# 入力全てを整数に変換したものの配列を受け取る
def LI(): return list(map(int, sys.stdin.readline().split()))
# 入力全てを整数に変換して1引いたものの配列を受け取る
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'

# リストを改行区切りで出力する
p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")

# ###########################################
 
S=SR()

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

result = "ABC" if n=="ARC" else "ARC"

print(result)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import numpy as np
from collections import deque
S = (input())
if (S == 'ABC'):
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
# ABC166 A

def main():
    s = input()

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import sqrt,ceil,floor
def mi():return map(int,input().split())
def li():return list(mi())
def ii():return int(input())

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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


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

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

Submission status: Accepted

Solution code:
ma = lambda :map(int,input().split())
ni = lambda:int(input())
s = input()
if s=="ABC":print("ARC")
else:print("ABC")

Submission status: Accepted

Solution code:
n = input()

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

Submission status: Accepted

Solution code:
from sys import stdin
import sys
import math

# A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
# A, B = [int(x) for x in stdin.readline().rstrip().split()]
# U = input().split()
S=input()
if S=="ARC":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
#import sympy as syp(素因数分解とか)
Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  #startline-------------------------------------------
    print("ABC" if input() == "ARC" else "ARC")
if __name__ == "__main__":
    main() #endline===============================================

Submission status: Accepted

Solution code:

s = str(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:

import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import sys
import bisect


sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
msi = lambda: map(str, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))

# ----------

S = si()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math as m

s = input()

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

Submission status: Accepted

Solution code:
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    s = ns()

    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()
print(["ABC", "ARC"][S=="ABC"])

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10**6)
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(S):
    return 'ABC' if S != 'ABC' else 'ARC'


def main():
    S = read_str()
    print(slv(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:
# Code for A - A?C
# Use input() to fetch data from STDIN

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

Submission status: Accepted

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

# -- submit ----

# --- fetch input ---
inputs: list = []
while True:
    try:
        inputs.append(input().strip('\n'))
    except EOFError:
        break

# --- write code below ---
s = inputs[0]

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
s = input().strip()


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


solve()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

s = input().replace("\n","")

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

Submission status: Accepted

Solution code:
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7

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().rstrip()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  s=S()
  if s=='ABC':
    return 'ARC'
  return 'ABC'

# main()
print(main())

Submission status: Accepted

Solution code:
# A
s = input()

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

Submission status: Accepted

Solution code:
#[int(i) for i in input().split()]
s = input()
if s[1] == "R":
    print("ABC")
else:
    print("ARC")

Submission status: Accepted

Solution code:
print('AABRCC'[input() == 'ABC'::2])

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8


def solve(*args: str) -> str:
    return 'ABC' if args[0] == 'ARC' else 'ARC'


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Submission status: Accepted

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

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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:
#import math
inp = input()
#list(map(int, input().split(" ")))

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

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 = str(input())
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Submission status: Accepted

Solution code:
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

s = input()

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

Submission status: Accepted

Solution code:
import math
import fractions
import collections
import itertools
S=input()
if S=="ABC":
    print("ARC")
else:
    print("ABC")

Submission status: Accepted

Solution code:
import sys

X = sys.stdin.readline().rstrip()

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

Submission status: Accepted

Solution code:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

S = str(input())

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

Submission status: Accepted

Solution code:
if input()=='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:
#A
s = input()

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

Submission status: Accepted

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

Submission status: Accepted

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


def main():
  if input().strip() == '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:
def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import defaultdict

import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

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


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
s=str(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:
input = raw_input

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

Submission status: Accepted

Solution code:
from collections import *

S = input()

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
l = ["ARC","ABC"]
print(l[l.index(input())-1])

Submission status: Accepted

Solution code:
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


def main():
    S = input()[:-1]
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
        


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
string = input()

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

Submission status: Accepted

Solution code:
con = input()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
s = str(input())

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

Submission status: Accepted

Solution code:
#map(int,input().split())
s = input()
print(["ABC","ARC"][s=="ABC"])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
S = input()
print({'ABC': 'ARC', 'ARC': 'ABC'}[S])

Submission status: Accepted

Solution code:
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S = rs()

if S == '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, combinations_with_replacement
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:
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

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

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

Submission status: Accepted

Solution code:
n = input()
if n=="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:
str = input()
if str == 'ABC': print('ARC')
else:print('ABC')

Submission status: Accepted

Solution code:
import sys
import math  # noqa
import bisect  # noqa
import queue  # noqa


def input():
    return sys.stdin.readline().rstrip()


def main():
    S = input()

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


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

S = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

s = stdin.readline().rstrip()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
    return list(map(int,input().split()))
def m(): #複数文字
    return map(int,input().split())
def onem(): #Nとかの取得
    return int(input())
def s(x): #圧縮
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): #listをスペースごとに分ける
    return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
    return max(map(max,x))
def In(x,a): #aがリスト(sorted)
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

s = input()[:-1]

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:
import sys
import math
from collections import deque
import heapq
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s = S()
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")
else:
    print("ARC")

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:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

Submission status: Accepted

Solution code:
S = input()

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

Submission status: Accepted

Solution code:
N = input()

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

Submission status: Accepted

Solution code:
# A

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

	if k == "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=='ABC':
  print('ARC')
else:
  print('ABC')

Submission status: Accepted

Solution code:
n = str(input())

if n[1] =='B':
    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 main():
    s = list(input())
    if s[1] == 'B':
        print('ARC')
    else:
        print('ABC')
if __name__=='__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

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