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

l = a+b
r = c+d

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

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())
AB=A+B
CD=C+D
print("Left" if AB>CD else  "Right" if CD>AB else "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) = (int(tok) for tok in input().split())
l = a + b
r = c + d

print("Balanced" if l == r else "Left" if l > r else "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())
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())
a+=b
c+=d
if a > c:
    print('Left')
elif a == c:
    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:
        return "Balanced"
    elif A+B > C+D:
        return "Left"
    else:
        return "Right"

if __name__ == '__main__':
    print(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:
a,b,c,d = (int(i) for i in input().split())
l = a+b
r = c+d
if l == r:
    print("Balanced")
else:
    print("Left" if l > r 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())
print('Left' if a+b > c+d else 'Balanced' if a+b == c+d else '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")
main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
w = list(map(int, input().split()))
l, r = sum(w[:2]), sum(w[2:])
print("Left" if l>r else "Right" if l<r else "Balanced")

Submission status: Accepted

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


if __name__ == "__main__":
    test()

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, R = A + B, C + D
print("Left" if L > R else "Right" if L < R else "Balanced")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
n = A + B - C - D
print("Left" if n > 0 else "Balanced" if n == 0 else "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 'Right' if l < r else 'Balanced')

Submission status: Accepted

Solution code:
import math
import sys
from itertools import accumulate
from functools import reduce
import queue
from fractions import gcd

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

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

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

sys.setrecursionlimit(10000)

mod = 1000000007

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

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

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

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

if __name__ == "__main__":
    A, B, C, D = map(int, sys.stdin.readline().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=[int(x) for x in input().split()]
A+=B
C+=D
if A==C:
  print('Balanced')
elif A>C:
  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:
A,B,C,D=map(int,input().split())
x=A+B-C-D
if x>0:
    print("Left")
elif x==0:
    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:
from sys import stdin

a,b,c,d = [int(x) for x in stdin.readline().rstrip().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
print("Left" if l>r else "Right" if l<r else "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())

print('Right' if a+b < c+d else 'Left' 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())
l = a+b
r = c+d
if l>r:
    print('Left')
elif r>l:
    print('Right')
elif r==l:
    print('Balanced')

Submission status: Accepted

Solution code:
a,b,c,d=list(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("Right")
elif a+b == c+d:
    print("Balanced")
else:
    print("Left")

Submission status: Accepted

Solution code:
S = list(map(int,open(0).read().split()))
L = sum(S[:2])
R = sum(S[2:])
if L-R >0:
  print("Left")
elif L-R<0:
  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 "Balanced" if l == r else "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:
a,b,c,d=map(int,input().split())
A=a+b
C=c+d
print("Left" if A>C else "Balanced" if A==C 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("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())
print(((("Balanced","Left")[c+d<a+b]),"Right")[a+b<c+d])

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:
  print('Left')
elif l < r:
  print('Right')
else:
  print('Balanced')

Submission status: Accepted

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

print(['RLiegfhtt'[A+B>C+D::2],'Balanced'][A+B==C+D])

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

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

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('Right')
elif l>r:
  print('Left')
else:
  print('Balanced')

Submission status: Accepted

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

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

if A+B > C+D:
    print("Left")
elif A+B == C+D:
    print("Balanced")
elif A+B < C+D:
    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()[:4])

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

Submission status: Accepted

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

R = w[2]+w[3]
L = w[0]+w[1]

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('Balanced')
elif A + B < C + D:
    print('Right')

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("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())
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 = 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 = list(map(int, input().split()))

if a + b > c + d:
    ans = 'Left'
elif a + b == c+ d:
    ans = 'Balanced'
else:
    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:
#!/usr/bin/env python3
import sys
INF = float("inf")


def solve(A: int, B: int, C: int, D: int):
    if A+B < C+D:
        print("Right")
    elif A+B == C+D:
        print("Balanced")
    else:
        print("Left")
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = int(next(tokens))  # type: int
    solve(A, B, C, D)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

if lw == rw:
    print("Balanced")
elif lw < rw:
    print("Right")
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("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())
if A+B == C+D:
  print("Balanced")
elif A+B > C+D:
  print("Left")
else:
  print("Right")

Submission status: Accepted

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

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

# solve
if (A + B) > (C + D):
    ans = 'Left'
elif (A + B) < (C + D):
    ans = 'Right'
else:
    ans = 'Balanced'

# output
print(ans)

Submission status: Accepted

Solution code:
a=list(map(int,input().split()))
b=(a[0]+a[1])/(a[2]+a[3])
if b>1:
    print("Left")
elif b==1:
    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 c+d > a+b:
  print('Right')
else:
  print('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())
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())
left = a + b
right = c + d
if left > right:
  print('Left')
elif left == right:
  print('Balanced')
else:
  print('Right')

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

Submission status: Accepted

Solution code:
i1 = input().split(' ')
a=int(i1[0])+int(i1[1])
b=int(i1[2])+int(i1[3])

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

Submission status: Accepted

Solution code:
weight = list(map(int, input().split()))
if weight[0]+weight[1] > weight[2]+weight[3]:
  print('Left')
elif weight[0]+weight[1] < weight[2]+weight[3]:
  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('Right')
elif a+b == c+d:
    print('Balanced')

Submission status: Accepted

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

if w1<w2:
  print("Right")
elif w2<w1:
  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')
if l == r: print('Balanced')
if l < r:  print('Right')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d = map(int,input().split())
x = a+b
y = c+d
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())
if a+b<c+d:
    print('Right')
elif a+b==c+d:
    print('Balanced')
elif a+b>c+d:
    print('Left')

Submission status: Accepted

Solution code:
# ABC083-A
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())
l = a+b
r = c+d
if l > r:
  print('Left')
elif l==r:
  print('Balanced')
else:
  print('Right')

Submission status: Accepted

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

weights = list(map(int, input().split()))
left = weights[0] + weights[1]
right = weights[2] + weights[3]

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import math

# NO, PAY-PAY
#import numpy as np
#import statistics
#from statistics import mean, median,variance,stdev
 
def main():
    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")
	
if __name__ == "__main__":
	main()

Submission status: Accepted

Solution code:
a,b,c,d = map(int, input().split())
if a+b>c+d:
    print("Left")
if a+b<c+d:
    print("Right")
if a+b == c+d:
    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 'Balanced' if l==r else '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("Right")
else:
    print("Left")

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-S
A,B,C,D = [int(i) for i in input().split()]

if A + B > C + D:
    print("Left")
elif A + B == C + D:
    print("Balanced")
elif A + B < C + D:
    print("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('Balanced')
else:
    print('Right')

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
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

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 LIST(): return list(map(str, input().split()))
# def LIST(): return list(input())

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B, C, D = MAP()
left = A + B
right = C + D
if left > right:
    print("Left")
elif left == right:
    print("Balanced")
else:
    print("Right")
# 16:02

Submission status: Accepted

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

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()))
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 = a + b
right = c + d
ans = None
if left == right:
    ans = 'Balanced'
elif left > right:
    ans = 'Left'
elif left < right:
    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('Balanced')
else:
	print('Right')

Submission status: Accepted

Solution code:
A, B, C, D = [int(e) for e 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())

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:
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:
a,b,c,d=map(int,input().split())
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())

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=(int(i) for i in 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("Right")
else:
    print("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:
# coding: utf-8
# Your code here!

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

# 上皿天秤が左に傾くなら Left を、釣り合うなら Balanced を、右に傾くなら Right を出力してください。

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=(int(i) for i in 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 = [int(i) for i in 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:
import sys

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

if __name__ == "__main__":
    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:
d = list(map(int, input().split()))
if sum(d[:2]) < sum(d[2:]):
    print("Right")
elif sum(d[:2]) == sum(d[2:]):
    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')

if A + B < C + D:
    print('Right')

if A + B == C + D:
    print('Balanced')

Submission status: Accepted

Solution code:
a=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")
else:
  print("Left")

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 = list(map(int,input().split()))
b = a[0]+a[1]
c = a[2]+a[3]

if b == c:
  print("Balanced")
elif b < c:
  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("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:
#!/usr/bin/env python3
import sys


def solve(A: int, B: int, C: int, D: int):
    left = A + B
    right = C + D

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

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = int(next(tokens))  # type: int
    solve(A, B, C, D)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#96
A,B,C,D = map(int,input().split())
ans= (A+B)-(C+D)
if ans>0:
    print("Left")
elif ans==0:
    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())
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("Left")
elif A+B<C+D:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

A, B, C, D = nl()

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('Right')
else:
    print('Balanced')

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
e = a + b
f = c + d
if e > f:
    print('Left')
elif e == f:
    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())
if a+b==c+d:
    print('Balanced')
elif a+b>c+d:
    print('Left')
else:
    print('Right')

Submission status: Accepted

Solution code:
inp = input().split()
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
d = int(inp[3])


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())
if (A+B) > (C+D):
    print("Left")
elif (A+B) == (C+D):
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

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


def solve(A: int, B: int, C: int, D: int):
    L = A + B
    R = C + D

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


# Generated by 1.1.4 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()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = int(next(tokens))  # type: int
    solve(A, B, C, D)

if __name__ == '__main__':
    main()