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:
def main():
    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')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A,B,C,D = [int(i) for i 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())
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 "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())
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())
 
if (A + B) == (C + D):
  r = 'Balanced'
elif (A + B) > (C + D):
  r = 'Left'
elif (A + B) < (C + D):
  r = 'Right'
print(r)

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:
num = input().split()
num_i = [int(s) for s in num]

if((num_i[0]+num_i[1]) > (num_i[2]+num_i[3])):
    print('Left')
elif((num_i[0]+num_i[1]) == (num_i[2]+num_i[3])):
    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')
elif a+b < c+d:
    print('Right')

Submission status: Accepted

Solution code:
x = [int(i) for i in input().split()]

A = x[0]
B = x[1]
C = x[2]
D = x[3]

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

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
A, B, C, D = map(int,input().split())
AB = A+B
CD = C+D
if AB >= CD:
    if AB > CD:
        print("Left")
    else:
        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:
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): #最大公約数
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): #最小公倍数
    return a/gcd(a,b)*b

def divisors(a): # 約数列挙
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): #素数判定
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): #素数列挙
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): #素因数分解
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

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

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 "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:
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:
import sys
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")

Submission status: Accepted

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

left = a+b
right = c+d

if left < right:
  print("Right")
elif left > right:
  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:
import sys
input = sys.stdin.readline
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(lambda x: int(x), 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('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:
    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())

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, B, C, D = map(int, input().split())
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=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())
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("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("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")
elif L<R:
    print("Right")

Submission status: Accepted

Solution code:
# coding: utf-8
import sys


def main(argv=sys.argv):
  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')
    
    
  return 0


if __name__ == '__main__':
  sys.exit(main())

Submission status: Accepted

Solution code:
# coding: utf-8
import sys


def main(argv=sys.argv):

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

    return 0


if __name__ == '__main__':
    sys.exit(main())

Submission status: Accepted

Solution code:

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
import math
import time
from fractions import gcd
#import random


def I(): return int(input())


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['Yes', 'No']
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)


# show_flg = False
show_flg = True


def main():
    A, B, C, D = MI()
    left = A + B
    right = C + D

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

Submission status: Accepted

Solution code:
import sys

a, b, c, d = map(int, sys.stdin.readline().split())

def main():
    l = a + b
    r = c + d
    if l > r:
        return 'Left'
    elif l == r:
        return 'Balanced'
    else:
        return 'Right'

if __name__ == '__main__':
    ans = main()
    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())

ans="Balanced"

if a+b>c+d:
    ans="Left"
elif a+b<c+d:
    ans="Right"

print(ans)

"""


3 8 7 1

Left

3 4 5 2

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:
from sys import stdin


def fetch_one_line():
    return stdin.readline().rstrip()


def fetch_int_input():
    return [int(s) for s in fetch_one_line().split()]


def fetch_inputs(times):
    return [fetch_one_line() for _ in range(times)]


def fetch_int_inputs(times):
    return [[int(s) for s in fetch_one_line()] for _ in range(times)]


answers = "Left Balanced Right".split()
A, B, C, D = fetch_int_input()

left = A + B
right = C + D
if left > right:
    id = 0
elif left < right:
    id = 2
else:
    id = 1

print(answers[id])

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

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:
import math

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 = 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:
import sys

a, b, c, d = map(int, sys.stdin.readline().split())

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

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, string
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = 0 ;count = 0 ;pro = 1


a,b,c,d=map(int,input().split())
if a+b-c-d>0:
    print("Left")
if a+b-c-d==0:
    print("Balanced")
if a+b-c-d<0:
    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=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())
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())
print("Balanced" if a+b==c+d else "Right" if a+b < c+d else "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:
r=lambda:map(int,input().split())
a,b,c,d=r()
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:
# -*- coding: utf-8 -*-

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

Submission status: Accepted

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

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

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:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))

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

m = a +b -c-d

if m>0:
    print("Left")
elif m ==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())

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

Submission status: Accepted

Solution code:
dbflag=""

def debug(*args):
	if ""!=dbflag: print(*args)

if ""!=dbflag: _INDATA=open(dbflag)

def readline():
	if ""!=dbflag:return _INDATA.readline()
	else: return input()


result = 0

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



x = A+B -(C+D)
if x > 0:
	result="Left"
elif x == 0:
	result ="Balanced"
else:
	result="Right"


print(result)

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

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

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")
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:
la,lb,ra,rb = map(int,input().split())
if la+lb > ra+rb:
    print('Left')
elif la+lb < ra+rb:
    print("Right")
else:
    print("Balanced")

Submission status: Accepted

Solution code:
# ABC083a
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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=list(map(int,input().split(" ")))
wL=A+B # 左の皿
wR=C+D # 右の皿

if wL<wR: # 右に傾く場合
    print("Right")
elif wL>wR: # 左に傾く場合
    print("Left")
elif wL==wR:
    print("Balanced")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

#入力
#C1 = str(input())
#C2 = str(input())
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:
A, B, C, D = map(int, input().split())
left = A + B
right = C + D

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

print(ans)

Submission status: Accepted

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

A_B = (A+B)
C_D = (C+D)

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

Submission status: Accepted

Solution code:
from sys import stdin

a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]

k = a+b
j = c+d

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

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

Submission status: Accepted

Solution code:
def examA():
    A, B, C, D = LI()
    if A+B==C+D:
        ans= "Balanced"
    elif A+B<C+D:
        ans = "Right"
    else:
        ans = "Left"
    print(ans)


import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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')
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=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:
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

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

main()

Submission status: Accepted

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

print('Balanced') if a + b == c + d else print('Left') if a + b > c + d 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())
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:
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:
#Libra
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:
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics

def main():
    a, b, c, d = (int(x) for x in sys.stdin.read().split())
    left = a + b
    right = c + d
    if left > right: ans = "Left"
    elif right > left: ans = 'Right'
    else: ans = 'Balanced'
    print(ans)


if __name__ == "__main__":
    # execute only if run as a script
    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('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('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('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:
# -*- 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 - Libra
a, b, c, d = [int(s) for s 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())
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, = (int(i) for i 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())
L = A+B
R = C+D
if L>R:
  print('Left')
elif L<R:
  print('Right')
else:
  print('Balanced')