Problem:


Score : 100 points

Problem Statement

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

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

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

Constraints

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

All input values are integers.

Input

Input is given from Standard Input in the following format:

A B C D

Output

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

Sample Input 1

3 8 7 1

Sample Output 1

Left

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

Sample Input 2

3 4 5 2

Sample Output 2

Balanced

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

Sample Input 3

1 7 6 4

Sample Output 3

Right

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



Sample input:
3 8 7 1


Sample output:
Left

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
print('RLiegfhtt'[a+b>c+d::2] 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 = list(map(int, input().split()))
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:
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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
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("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('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("Balanced")
elif left > right:
  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 = 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 = SJIS
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 math

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

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

Submission status: Accepted

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

Submission status: Accepted

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

import sys
# import time
# import math
# import numpy as np
# import scipy.sparse.csgraph as cs            # csgraph_from_dense(ndarray, null_value=inf), bellman_ford(G, return_predecessors=True), dijkstra, floyd_warshall
# import random                                # random, uniform, randint, randrange, shuffle, sample
# import string                                # ascii_lowercase, ascii_uppercase, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from datetime import date, datetime          # date.today(), date(year,month,day) => date obj; datetime.now(), datetime(year,month,day,hour,second,microsecond) => datetime obj; subtraction => timedelta obj
# from datetime.datetime import strptime       # strptime('2019/01/01 10:05:20', '%Y/%m/%d/ %H:%M:%S') returns datetime obj
# from datetime import timedelta               # td.days, td.seconds, td.microseconds, td.total_seconds(). abs function is also available.
# from copy import copy, deepcopy              # use deepcopy to copy multi-dimentional matrix without reference
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)



def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1             # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, c, d = mi()
    if a + b > c + d:
        print('Left')
    elif a + b == c + d:
        print('Balanced')
    else:
        print('Right')


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c, d = map(int, input().split())
diff = a + b - c - d
print("Left" if diff > 0 else "Balanced" if diff == 0 else "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:
def main():
    A, B, C, D = map(int, input().split())
    left = A + B
    right = C + D
    ans = "Left" if left > right else "Balanced" if left == right else "Right"
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c, d = list(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("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:
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: #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:
import collections

#文字列を一文字ずつ取得したいとき
def inputStrOnebyOne():
    s = list(input())
    return s

#整数を一つずつリストに入れる
def inputOnebyOne_Int():
    a = list(int(x) for x in input().split())
    return a

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:
# -*- coding: utf-8 -*-
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())

l = a + b
r = c + d

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Thu May 14 01:14:08 2020

@author: shinba
"""

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:

import sys
def input(): return sys.stdin.readline().strip()

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

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 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

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

#############
# Main Code #
#############

A,B,C,D = inputIL()

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

Submission status: Accepted

Solution code:
import sys
import math
import bisect

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def ABC_83_A():
    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__':

    ABC_83_A()

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

input = sys.stdin.readline


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


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:
#!/usr/bin/env python3
import sys


input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    A, B, C, D = IL(int)
    if A + B > C + D:
        print('Left')
    elif A + B == C + D:
        print('Balanced')
    else:
        print('Right')


solve()

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

Submission status: Accepted

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

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C, D = 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 = 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:
# region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
PI = math.pi
# endregion
A, B, C, D = ri_()
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 'Balanced' if A+B == C+D else 'Right')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
a+=b;c+=d
if a==c:print("Balanced")
if a>c:print("Left")
if c>a: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 = (int(i) for i in input().split())

x = A + B
y = C + D

if x > y:
    print('Left')
elif x < y:
    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())
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("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())
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())

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

Submission status: Accepted

Solution code:
def libra(l,r):
    if l>r:
        return "Left"
    elif l == r:
        return "Balanced"
    else:
        return "Right"
def sum(a,b):
    c = a+b
    return c
a,b,c,d=[int(i) for i in input().split()]
print(libra(sum(a,b),sum(c,d)))

Submission status: Accepted

Solution code:
def libra(l,r):
    if l>r:
        return "Left"
    elif l==r:
        return "Balanced"
    else:
        return "Right"
def sum(a,b):
    return a+b
    
a,b,c,d=[int(_) for _ in input().split()]
print(libra(sum(a,b),sum(c,d)))

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

Submission status: Accepted

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

Submission status: Accepted

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

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