Problem:


Score : 100 points

Problem Statement

A balance scale tips to the left if L>R, where L is the total weight of the masses on the left pan and R is the total weight of the masses on the right pan. Similarly, it balances if L=R, and tips to the right if L<R.

Takahashi placed a mass of weight A and a mass of weight B on the left pan of a balance scale, and placed a mass of weight C and a mass of weight D on the right pan.

Print Left if the balance scale tips to the left; print Balanced if it balances; print Right if it tips to the right.

Constraints

1\leq A,B,C,D \leq 10

All input values are integers.

Input

Input is given from Standard Input in the following format:

A B C D

Output

Print Left if the balance scale tips to the left; print Balanced if it balances; print Right if it tips to the right.

Sample Input 1

3 8 7 1

Sample Output 1

Left

The total weight of the masses on the left pan is 11, and the total weight of the masses on the right pan is 8. Since 11>8, we should print Left.

Sample Input 2

3 4 5 2

Sample Output 2

Balanced

The total weight of the masses on the left pan is 7, and the total weight of the masses on the right pan is 7. Since 7=7, we should print Balanced.

Sample Input 3

1 7 6 4

Sample Output 3

Right

The total weight of the masses on the left pan is 8, and the total weight of the masses on the right pan is 10. Since 8<10, we should print Right.



Sample input:
3 8 7 1


Sample output:
Left

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
if A+B>C+D:
  print("Left")
elif A+B<C+D:
    print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)

a, b, c, d = list(map(int, input().split()))

e = a+b
f = c+d
if e > f:
    print("Left")
if e == f:
    print("Balanced")
if e < f:
    print("Right")

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): 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 LSS(): return input().split()

def resolve():
    A, B, C, D = LI()

    L = A + B
    R = C + D
    if L == R:
        print('Balanced')
    elif L > R:
        print('Left')
    else:
        print('Right')

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
# 083_a
A,B,C,D=map(int,input().split())
if (1<=A and A<=10)and(1<=B and B<=10)and(1<=C and C<=10)and(1<=D and D<=10):
    L=A+B
    R=C+D
    if L>R:
        print('Left')
    elif L==R:
        print('Balanced')
    elif L<R:
        print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A+B == C+D:
    print('Balanced')
elif A+B > C+D:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:

[A,B,C,D] = list(map(int,input().split()))
L,R = A+B, C+D

if L==R:
    print('Balanced')
elif L>R:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
print("Left" if a+b > c+d else "Right" if a+b < c+d else "Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b==c+d:
    print("Balanced")
elif a+b>c+d:
    print("Left")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split(" "))
print("Balanced") if a+b==c+d else print("Right") if a+b<c+d else print("Left")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())

L = A + B
R = C + D

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print("Left")
elif a + b < c + d:
    print("Right")
elif a + b == c + d:
    print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
if A+B>C+D:
    print("Left")
elif A+B<C+D:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
x = a + b
y = c + d
if x == y:
  print('Balanced')
elif x > y:
  print('Left')
else:
  print('Right')

Submission status: Accepted

Solution code:
import sys
mapin = lambda: map(int, sys.stdin.readline().split())
listin = lambda: list(map(int, sys.stdin.readline().split()))
inp = lambda: sys.stdin.readline()
A,B,C,D = mapin()
l = A + B;r = C + D
if l < r:print("Right")
elif l > r:print("Left")
else:print("Balanced")

Submission status: Accepted

Solution code:
a = input().split()
a = [int(j) for j in a]
a.append(a[:2])
a.append(a[2:4])
if sum(a[4]) > sum(a[5]):
    print("Left")
if sum(a[4]) == sum(a[5]):
    print("Balanced")
if sum(a[4]) < sum(a[5]):
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if (a+b)<(c+d):
    print("Right")
elif (a+b)>(c+d):
    print("Left")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b<c+d:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A + B > C + D:
  print("Left")
elif A + B == C + D:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
a, b, c, d = map(int,input().split())

L = a + b
R = c + d

print("Left" if L > R else "Balanced" if L == R else "Right")

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
#lis = list(map(int,input().split()))
if a+b>c+d:print("Left")
elif a+b<c+d:print("Right")
else:print("Balanced")

Submission status: Accepted

Solution code:
#a=int(input())

# c=[]
#  for i in b:
#     c.append(i)
A,B,C,D = map(int,input().split())
# f = list(map(int,input().split()))
#j = [input() for _ in range(a)]
# h = []
# for i in range(e1):
#     h.append(list(map(int,input().split())))
if A+B>C+D:
    print("Left")
elif A+B==C+D:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b>c+d:print('Left')
elif a+b<c+d:print('Right')
else:print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())
print('Left' if (a+b) > (c+d) else 'Balanced' if (a+b) == (c+d) else 'Right')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
z = a + b - c - d
if z > 0:
    print('Left')
elif z < 0:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
import math
# s=int(input())
# b=input()
# c=[]
# for i in range(b):
#     c.append(a[i])
a = list(map(int,input().split()))
#b = list(map(int,input().split()))

if a[0]+a[1]<a[2]+a[3]:
    print("Right")
elif a[0]+a[1]==a[2]+a[3]:
    print("Balanced")
elif a[0]+a[1]>a[2]+a[3]:
    print("Left")

Submission status: Accepted

Solution code:
a, b, c, d = list(map(int, input().split()))
if a+b > c+d:
    print('Left')
elif a+b == c+d:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
left_a, left_b, right_a, right_b = map(int, input().split())

left_weight = left_a + left_b
right_weight = right_a + right_b

if left_weight == right_weight:
    print('Balanced')
elif left_weight > right_weight:
    print('Left')
elif right_weight > left_weight:
    print('Right')

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
ab = a + b
cd = c + d
if ab > cd:
    print('Left')
elif ab < cd:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
def main():
    a, b, c, d = map(int, input().split())

    if a + b > c + d:
        print("Left")
    elif a + b == c + d:
        print("Balanced")
    else:
        print("Right")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
l = a+b
r = c+d
if l > r:
  print('Left')
elif l < r:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a + b > c + d:
    print("Left")
elif a + b == c + d:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=(int(x) for x in input().split())
e = int(a) + int(b)
f = int(c) + int(d)
if e > f:
    print('Left')
elif e < f:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
# A - Libra
# https://atcoder.jp/contests/abc083/tasks/abc083_a

A, B, C, D = map(int, input().split())

ab = A + B
cd = C + D
result = 'Balanced'

if ab > cd:
    result = 'Left'
elif ab < cd:
    result = 'Right'

print(result)

Submission status: Accepted

Solution code:
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    x = list(map(int, readline().split()))

    first = x[0] + x[1]
    second = x[2] + x[3]

    if first > second:
        print("Left")
    elif first < second:
        print("Right")
    else:
        print("Balanced")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
e,f=a+b,c+d
if e<f:
    print("Right")
elif e==f:
    print("Balanced")
else:
    print("Left")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
AB = A + B
CD = C + D

if AB > CD:
    print('Left')
elif AB < CD:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a+b > c+d:
  print("Left")
elif a+b == c+d:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
a,b,c,d = [int(x) for x in input().split()]
if a+b == c+d:
  print("Balanced")
elif a+b > c+d:
  print("Left")
else:
  print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())

print('Left') if a+b>c+d else print('Right') if a+b<c+d else print('Balanced')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A + B > C + D:
    print('Left')
elif A + B < C + D:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())

if (A + B) > (C + D):
    print("Left")
elif (A + B) < (C + D):
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A + B > C + D:
    print('Left')
elif A + B < C + D:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
a += b
c += d
if a>c:
    print('Left')
elif a < c:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
left = a + b
right = c + d

if left == right:
    print('Balanced')
elif left > right:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
if A+B < C+D:
    print("Right")
elif A+B > C+D:
    print("Left")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())

L = A + B
R = C + D

if L > R:
    print('Left')

elif L == R:
    print('Balanced')

else:
    print('Right')

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b==c+d:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
a, b, c, d = (int(x) for x in input().split())
if a+b > c+d:
    ans = 'Left'
elif a+b < c+d:
    ans = 'Right'
else:
    ans = 'Balanced'
print(ans)

Submission status: Accepted

Solution code:
# A - Libra

# 天秤の左の皿におもりA,Bを、右の皿におもりB,Dを載せた場合、
# 天秤がどちらに傾くかを出力する


A,B,C,D = map(int,input().split())

left_dish = A + B
right_dish = C + D

if left_dish > right_dish:
    print('Left')
elif left_dish < right_dish:
    print('Right')
elif left_dish == right_dish:
    print('Balanced')

Submission status: Accepted

Solution code:
# 4つのおもりで天秤の重さ比べ

A, B, C, D = map(int, input().split())
L = A + B
R = C + D

if L > R:
    print('Left')
elif L == R:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
# 上皿天秤は、左の皿に乗っているおもりの重さの合計を L とし、
# 右の皿に乗っているおもりの重さの合計を R としたとき、
# L > R なら左に傾き、 L = R なら釣り合い、
# L < R なら右に傾きます。
#
# 高橋君は、上皿天秤の左の皿に重さ A のおもりと重さ B のおもりを、
# 右の皿に重さ C のおもりと重さ D のおもりを置きました。
#
# 上皿天秤が左に傾くなら Left を、
# 釣り合うなら Balanced を、
# 右に傾くなら Right を出力してください。

# 制約
# 1 ≦ A, B, C, D ≦ 10
# 入力はすべて整数である

# 標準入力から A, B, C ,D の値を取得する
a, b, c, d = map(int, input().split())

# 上皿天秤の状態を判定し、結果を出力する
result = "ret"

if (a + b) > (c + d):
    result = "Left"
elif (a + b) < (c + d):
    result = "Right"
else:
    result = "Balanced"

print(result)

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
print("Left" if a+b>c+d else "Balanced" if a+b==c+d else "Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b>c+d:
  print("Left")
elif a+b==c+d:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b<c+d:
  print("Right")
elif a+b>c+d:
  print("Left")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

if a + b < c + d:
    print("Right")
elif c + d < a + b:
    print("Left")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())

if A + B > C + D: print('Left')
elif A + B == C + D: print('Balanced')
else: print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int,input().split())

if A + B > C + D:
    print("Left")
elif A + B < C + D:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
L = a+b
R = c+d
print("Left" if L>R else "Right" if R>L else "Balanced")

Submission status: Accepted

Solution code:
#   AtCoder abc083 a
#   ストレッチ課題

#   入力
a, b, c, d = map(int, input().split())

#   判定
diff = (a + b) - (c + d)
if diff == 0:
    print("Balanced")
elif diff > 0:
    print("Left")
else:
    print("Right")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())

L = A + B
R = C + D

if L > R:
    print("Left")
elif L == R:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
# 入力
A, B, C, D = map(int,input().split())

# 処理
if A + B == C + D:
    print('Balanced')
elif A + B > C + D:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
print('Right' if C + D > A + B else 'Left' if C + D < A + B else 'Balanced')

Submission status: Accepted

Solution code:
left1, left2, right1, right2 = map(int, input().split())
if right1 + right2 > left1 + left2:
    print('Right')
elif right1 + right2 < left1 + left2:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d=map(int,input().split())
if a+b<c+d:
  print("Right")
elif a+b==c+d:
  print("Balanced")
else:
  print("Left")

Submission status: Accepted

Solution code:
# 入力
A, B, C, D = map(int, input().split())

# 出力
if 1 <= A and B and C and D <= 10:
    if A + B == C + D:
        print('Balanced')
    elif A + B > C + D:
        print('Left')
    elif A + B < C + D:
        print('Right')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

L = a + b
R = c + d

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
left = a + b 
right = c + d

if left > right:
    print('Left')
elif left == right:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
# 083a

A, B, C, D = map(int, input().split())

if A + B == C + D:
    print('Balanced')
elif A + B > C + D:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
if a+b > c + d:
    print("Left")
elif a+b == c+d:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
l=list(map(int,input().split()))
x,y=l[0]+l[1],l[2]+l[3]
if(x>y):
    print("Left")
elif(x==y):
    print("Balanced")
else:
    print('Right')

Submission status: Accepted

Solution code:
# 各錘の重量を取得
A,B,C,D = map(int,input().split())

# 左と右の皿の重さを計算
LWeight = A + B
RWeight = C + D

# 比較結果にもどづいて各メッセージを出力
if LWeight > RWeight:
    print("Left")
elif LWeight < RWeight:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
if A+B>C+D :
  print("Left")
elif A+B==C+D :
  print("Balanced")
else :
  print("Right")

Submission status: Accepted

Solution code:
# A,B,C,Dのおもりの重さを整数で入力
A,B,C,D = map(int,input().split())
if A + B > C + D:
# 左の皿（A+B）の方が重いならLeft、同じならBalanced、左の皿（C+D）が重いならRightを出力
    print("Left")
elif A + B == C + D:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d = list(map(int, input().split()))
if sum((a,b)) > sum((c,d)):
    print("Left")
elif sum((a,b)) < sum((c,d)):
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D = map(int, input().split())
if A+B > C+D:
  print("Left")
elif A+B == C+D:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:
S = input()
S_list = S.split()

L = int(S_list[0]) + int(S_list[1])
R = int(S_list[2]) + int(S_list[3])
 
if L-R>0:
    print("Left")
elif L-R<0:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=input().split()
a=int(a)
b=int(b)
c=int(c)
d=int(d)
if a+b==c+d:
  print("Balanced")
if a+b>c+d:
  print("Left")
if a+b<c+d:
  print("Right")

Submission status: Accepted

Solution code:
a, b, c, d = (int(x) for x in input().split())
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
A, B, C, D=map(int, input().split())
L=A+B
R=C+D

if L>R:
    print("Left")
elif L==R:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
A,B,C,D = map(int, input().split())
if A+B > C+D:
    print('Left')
elif A+B == C+D:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
# 左の皿の重さ
L = A + B
# 右の皿の重さ
R = C + D

if L == R:
    print("Balanced")
elif L < R:
    print("Right")
else:
    print("Left")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input(). split())

if A + B > C + D:
    print('Left')
elif A + B < C + D:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

l = a+b
r = c+d

if l == r:
    print('Balanced')
elif l > r:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
L = A + B
R = C + D

if L > R:
    print('Left')
elif L < R:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
a+=b
c+=d
if a>c:
  print("Left")
elif a<c:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
print('Left' if a+b>c+d else 'Right' if a+b<c+d else 'Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
l = a + b
r = c + d
if l > r:
  print("Left")
elif l < r:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
L=A+B
R=C+D
if L>R:
    ans="Left"
elif L<R:
    ans="Right"
else:
    ans="Balanced"
print(ans)

Submission status: Accepted

Solution code:
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
#    d = m - k[i] - k[j]
#    if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
import sys
sys.setrecursionlimit(10000000)
#mod = 10**9 + 7
#mod = 9982443453
mod = 998244353
def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b,c,d = readInts()
left = a+b
right = c+d
print('Left' if left > right else ('Balanced' if left == right else 'Right'))

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
left = A + B
right = C + D
if left > right:
    print("Left")
elif left < right:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int,input().split())
if (A+B > C+D):
  print("Left")
elif (A+B < C+D):
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int,input().split())
if A + B > C + D:
    print("Left")
elif A + B < C + D:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())

ans = "Balanced"
if a+b > c+d: ans = "Left"
elif a+b < c+d: ans = "Right"
print(ans)

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())
if A+B>C+D:
    print("Left")
elif A+B<C+D:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())
l = a+b
r = c+d
if l ==r:
    print('Balanced')
elif l > r:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
l = a+b
r = c+d

if l<r:
  print('Right')
elif l==r:
  print('Balanced')
else:
  print('Left')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

l = a + b
r = c + d
if l < r:
    print("Right")
elif r < l:
    print("Left")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
A,B,C,D=map(int,input().split())
a=A+B
b=C+D
if a>b:
  print("Left")
elif a==b:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:


def main():
    a, b, c, d = map(int, input().split())
    if a + b > c + d:
        print("Left")
    elif a + b == c + d:
        print("Balanced")
    else:
        print("Right")
        

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
print("Left" if a + b > c + d else "Right" if a + b < c + d else "Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b > c+d:
  print('Left')
elif a+b < c+d:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
left, right = A + B, C + D
if left > right:
    print('Left')
elif left < right:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if (a + b) < (c + d):
  print('Right')
elif (a + b) > (c + d):
  print('Left')
else: 
  print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a+b > c+d:
  print('Left')
elif a+b == c+d:
  print('Balanced')
else:
  print('Right')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split());print('Balanced'if a+b==c+d else'RLiegfhtt'[a+b>c+d::2])

Submission status: Accepted

Solution code:
a,b,*c=map(int,input().split());print('Balanced'if a+b==sum(c) else'RLiegfhtt'[a+b>sum(c)::2])

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())
if a+b > c+d:
  print("Left")
elif a+b < c+d:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
print([["Balanced","Left"][a+b>c+d],"Right"][a+b<c+d])

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
if a+b>c+d:
    print('Left')
elif a+b<c+d:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())
if a+b < c+d:
    print('Right')
elif a+b == c+d:
    print('Balanced')
else:
    print('Left')

Submission status: Accepted

Solution code:
a, b, c, d = map(int,input().split())
if a + b > c + d:
    print('Left')
elif a + b < c + d:
    print('Right')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
l = list(map(int,input().split()))

if sum(l[:2]) == sum(l[2:]): print('Balanced')
elif sum(l[:2]) > sum(l[2:]): print('Left')
else: print('Right')

Submission status: Accepted

Solution code:
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [list(input()) for _ in range(n)]
#a = [int(input()) for _ in range(n)]

a,b,c,d=map(int, input().split())

if (a+b > c+d):
    print("Left")
elif (a+b < c+d):
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
a,b,c,d = (int(x) for x in input().split())
L = a+b
R = c+d
if L == R:
  print ('Balanced')
elif L > R:
  print ('Left')
else:
  print ('Right')

Submission status: Accepted

Solution code:
A = input().split(" ")
L = int(A[0])+int(A[1])
R = int(A[2])+int(A[3])
if L>R:
  print("Left")
elif L == R:
  print("Balanced")
else :
  print("Right")

Submission status: Accepted

Solution code:
A,B,C,D = map(int,input().split())
L = A+B
R = C+D
if L > R:
  print('Left')
elif L == R:
  print('Balanced')
else:
  print('Right')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a + b > c + d:
  print("Left")
elif a + b == c + d:
  print("Balanced")
else:
  print("Right")

Submission status: Accepted

Solution code:

def main():
    a, b, c, d = map(int, input().split())    
    if a + b > c + d:
        print('Left')
    elif a + b < c + d:
        print('Right')
    else:
        print('Balanced')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    A, B, C, D = map(int, readline().split())
    if A + B > C + D:
        print('Left')
    elif A + B == C + D:
        print('Balanced')
    else:
        print('Right')


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
if (a+b) > (c+d):
  print("Left")
elif (a+b) < (c+d):
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
if a + b < c + d:
    print('Right')
elif a + b > c + d:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())

if a+b>c+d:
  print('Left')
elif a+b<c+d:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if a+b>c+d:print('Left')
elif a+b==c+d:print('Balanced')
else:print('Right')

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())

print("Left" if a+b>c+d else "Balanced" if a+b==c+d else "Right")

Submission status: Accepted

Solution code:
w = list(map(int, input().split()))
l = w[0]+w[1]
r = w[2]+w[3]
if l < r:
    print('Right')
elif l > r:
    print('Left')
else:
    print('Balanced')

Submission status: Accepted

Solution code:
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    A, B, C, D = map(int, readline().split())

    if A + B > C + D:
        print('Left')
    elif A + B < C + D:
        print('Right')
    else:
        print('Balanced')

    return


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

if (a + b) > (c + d):
    print('Left')
elif (a + b) == (c + d):
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

def main():
    a,b,c,d = map(int, input().split())

    l = a + b
    r = c + d
    if l > r:
        print('Left')
    elif l < r:
        print('Right')
    else:
        print('Balanced')


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
ais = map(int, raw_input().split())
if sum(ais[:2]) == sum(ais[2:]):
	print 'Balanced'
elif sum(ais[:2]) > sum(ais[2:]):
	print 'Left'
elif sum(ais[:2]) < sum(ais[2:]):
	print 'Right'

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
l=a+b
r=c+d
if l>r:
    print("Left")
elif l==r:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
l = a+b
r = c+d
if l>r:
  print("Left")
elif r>l:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

Solution code:
a, b, c, d = list(map(int, input().split()))
l = a + b
r = c + d
if l > r:
  print('Left')
elif l == r:
  print('Balanced')
else:
  print('Right')

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
if (a+b)>(c+d):
    print('Left')
elif (a+b)==(c+d):
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
A,B,C,D=list(map(int, input().split()))
L=A+B
R=C+D
if L>R:
  print('Left')
elif L<R:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d=map(int, input().split())
if a+b < c+d:
  print('Right')
elif a+b==c+d:
  print('Balanced')
else:
  print('Left')

Submission status: Accepted

Solution code:
a,b,c,d=map(int, input().split())
if (a+b)>(c+d):
  print('Left')
elif (a+b)<(c+d):
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

Solution code:
A,B,C,D = map(int, input().split())
if A+B > C+D:
	print('Left')
elif A+B < C+D:
	print('Right')
else:
	print('Balanced')

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())

if a+b>c+d:
  print('Left')
elif a+b<c+d:
  print('Right')
else:
  print('Balanced')