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

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("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('Balanced')
elif a+b < c+d:
  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:
# /usr/bin/python
# -*- coding: utf-8 -*-
#
import sys
import math


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

Submission status: Accepted

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

import sys
input = sys.stdin.readline

def io_generator():
	return input()

#+++++++++++++++++++

def main(io):
	a,b,c,d = map(int, io().split())
	
	rets=['Left', 'Balanced', 'Right']
	
	if a+b > c+d:
		return rets[0]
	elif a+b < c+d:
		return rets[2]
	else:
		return rets[1]

#++++++++++++++++++++

if __name__ == "__main__":
	io= lambda : io_generator()
	print (main(io))

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

Submission status: Accepted

Solution code:
W = list(map(int, input().split()))
if (sum(W[:2:]) > sum(W[2::])):
  print('Left')
elif (sum(W[:2:]) < sum(W[2::])):
  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())
X =A+B
Y =C+D
if X > Y:
    print('Left')
elif X < Y:
    print('Right')
elif X==Y:
    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())
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())
print('Balanced' if A+B == C+D else 'Left' if A+B > C+D else '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 = [int(item) for item 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 = list(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())
e=a+b
f=c+d
if e==f:
    print('Balanced')
elif e>f:
    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('Right')
else:
    print('Left')

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())
l = a + b
r = c + d

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

Submission status: Accepted

Solution code:
a, b, c, d = [int(_) for _ in 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(' '))
e=a+b
f=c+d
if e>f:
    print('Left')
elif e==f:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

Solution code:
#ABC 088 A - Libra
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 = [int(n) for n in input().split()]

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = [ int(i) for i in input().split() ]
if a[0] + a[1] == a[2] + a[3]:
    print("Balanced")
elif a[0] + a[1] > a[2] + a[3]:
    print("Left")
else:
    print("Right")

Submission status: Accepted

Solution code:
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007

#A
def A():
    a,b,c,d = LI()
    if a+b > c+d:
        print("Left")
    elif a+b == c+d:
        print("Balanced")
    else:
        print("Right")
    return

#B
def B():
    return

#C
def C():
    x,y = LI()
    ans = 1
    for i in range(10000000000000):
        x *= 2
        if x > y:break
        ans += 1
    print(ans)

#D
def D():
    s = S()
    n = len(s)
    ans = n
    for i in range(n-1):
        if s[i] != s[i+1]:
            ans = min(ans,max(i+1,n-i-1))
    print(ans)

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == "__main__":
    A()

Submission status: Accepted

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

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

Submission status: Accepted

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

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 '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 'Right' if a+b<c+d else 'Balanced')

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

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

else:
  print('Right')

Submission status: Accepted

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


if __name__ == '__main__':
    print(solve(input()))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
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("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('Right')
else:
    print('Balanced')

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

L = A_1[0] + A_1[1]
R = A_1[2] + A_1[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())
n=a+b
m=c+d
if n>m:
  print("Left")
elif m>n:
  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("Balanced")
else:
  print("Right")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split());a,b=a+b,c+d
if a>b:print("Left")
elif 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('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:
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:
#ABC83
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:
def libra(A: int, B: int, C: int, D: int) -> str:
    if A + B > C + D:
        return 'Left'
    if A + B < C + D:
        return 'Right'
    return 'Balanced'


if __name__ == "__main__":
    A, B, C, D = map(int, input().split())
    ans = libra(A, B, C, D)
    print(ans)

Submission status: Accepted

Solution code:
o=input().split();s=sum(map(int,o));sl=sum(map(int,o[:2]))
if sl>s/2:
  m='Left'
elif sl==s/2:
  m='Balanced'
else:
  m='Right'
print(m)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#83A
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:
v,b,n,m = map(int,input().split())

if v+b == n+m:
  print("Balanced")
elif v+b > n+m:
  print("Left")
else:
  print("Right")

Submission status: Accepted

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

import itertools
import collections
import bisect
import sys
input = sys.stdin.readline

def main():
    A, B, C, D = map(int, input().split())
    if A + B == C + D:
        print("Balanced")
    else:
        print("Left" if A + B > C + D else "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("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 = [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())
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 = (int(i) for i in input().split())
x=a+b
y=c+d
if x > y:
    print("Left")
if x < y:
    print("Right")
if x == y:
    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:
import sys

def main():
    input = sys.stdin.readline
    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())
if A+B > C+D:
  print("Left")
elif A+B < C+D:
  print("Right")
else:
  print("Balanced")

Submission status: Accepted

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

l = a + b
r = c + d

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

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:
l=list(map(int,input().split()))
L=l[0]+l[1]
R=l[2]+l[3]

if R==L:
  print('Balanced')
elif R>L:
  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("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('Balanced')
else:
  print('Right')

Submission status: Accepted

Solution code:
import numpy as np

data = list(map(int, input().split()))

l = data[0] + data[1]
r = data[2] + data[3]

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

Submission status: Accepted

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


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('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:
from sys import exit
A,B,C,D = [int(n) for n in 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())
print("Balanced" if a+b == c+d else "RLiegfhtt"[a+b > c+d::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('Balanced')
else: print('Right')

Submission status: Accepted

Solution code:
# coding: utf-8
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('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:
# -*- coding: utf-8 -*-
"""
Created on Mon Mar  4 15:01:58 2019

@author: kaned
"""
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=[int(i) for i in input().split()]
right=a+b
left=c+d
if right==left:
    print("Balanced")
elif right>left:
    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())
if (a + b) > (c + d):
    print("Left")
elif (a + b) < (c + d):
    print("Right")
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('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")
elif a+b == c+d:
  print("Balanced")

Submission status: Accepted

Solution code:
A, B ,C, D = (int(i) for i in input().split())

left = A + B
right = C + D
ans = ""

if (left > right):
    ans = "Left"
elif(left < right):
    ans = "Right"
else:
    ans = "Balanced"

print(ans)

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

if A + B < C + D:
    ans = "Right"
elif A + B > C + D:
    ans = "Left"
else:
    ans = "Balanced"

print(ans)
print()

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","Right"][(a+b>c+d)-(a+b<c+d)])

Submission status: Accepted

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

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:
import bisect
import numpy as np
import sys
input = sys.stdin.readline
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a = IL()
l = a[0]+a[1]
r = a[2]+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());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('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, raw_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('Left')
elif A + B == C + D:
    print('Balanced')
else:
    print('Right')

Submission status: Accepted

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

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:
if __name__ == '__main__':
    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:
int_a, int_b, int_c, int_d = map(int, input().split())

if int_a + int_b == int_c + int_d:
    print("Balanced")
elif int_a + int_b > int_c + int_d:
    print("Left")
else:
    print("Right")

Submission status: Accepted

Solution code:
# -*- coding:utf-8 -*-
# L,Rで大きい方に傾く

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

left = A + B
right = C + D

if left == right:
    print("Balanced")
elif left < right:
    print("Right")
else :
    print("Left")

Submission status: Accepted

Solution code:
A, B, C, D = map(int, input().split())
print("Left" if C + D < A + B 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:
abcd = list(int(i) for i in input().split())
left = abcd[0] + abcd[1]
right = abcd[2] + abcd[3]
if left > right:
    print("Left")
elif left == right:
    print("Balanced")
else:
    print("Right")

Submission status: Accepted

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

Submission status: Accepted

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

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

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

AB = A + B
CD = C + D

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

Submission status: Accepted

Solution code:
# encoding:utf-8

import numpy as np
import random

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

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

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

Submission status: Accepted

Solution code:
num=list(map(int,input().split()))
a=num[0]+num[1]
b=num[2]+num[3]
if a>b:
    print("Left")
elif a==b:
    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("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("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("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")
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 = list(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("Balanced")
elif A + B > C + D:
    print("Left")
else:
    print("Right")