AtCoder Beginner Contest 052 - Two Rectangles

There are two rectangles.
The lengths of the vertical sides of the first rectangle are A, and the lengths of the horizontal sides of the first rectangle are B.
The lengths of the vertical sides of the second rectangle are C, and the lengths of the horizontal sides of the second rectangle are D.
Print the area of the rectangle with the larger area.
If the two rectangles have equal areas, print that area.

-----Constraints-----
 - All input values are integers.
 - 1≤A≤10^4
 - 1≤B≤10^4
 - 1≤C≤10^4
 - 1≤D≤10^4

-----Input-----
The input is given from Standard Input in the following format:
A B C D

-----Output-----
Print the area of the rectangle with the larger area.
If the two rectangles have equal areas, print that area.

-----Sample Input-----
3 5 2 7

-----Sample Output-----
15

The first rectangle has an area of 3×5=15, and the second rectangle has an area of 2×7=14.
Thus, the output should be 15, the larger area.

Source: atcoder | Difficulty: EASY


Solutions:
(A, B, C, D) = map(int, input().split())
print(max(A * B, C * D))


(A, B, C, D) = map(int, input().split())
x = A * B
y = C * D
if x > y:
	print(x)
elif x < y:
	print(y)
elif x == y:
	print(x)


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

def answer(A: int, B: int, C: int, D: int) -> int:
	return max(A * B, C * D)
print(answer(A, B, C, D))


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


(a, b, c, d) = map(int, input().split())
k = a * b
l = c * d
if k >= l:
	print(k)
else:
	print(l)


(a, b, c, d) = map(int, input().split())
e = max(a * b, c * d)
print(e)


s = [int(i) for i in input().split()]
print(max(s[0] * s[1], s[2] * s[3]))


(A, B, C, D) = map(int, input().split())
s1 = A * B
s2 = C * D
if s1 == s2:
	print(s1)
elif s1 > s2:
	print(s1)
else:
	print(s2)


(a, b, c, d) = map(int, input().split())
if a * b <= c * d:
	print(c * d)
else:
	print(a * b)


n = list(map(int, input().split()))
print(max(n[0] * n[1], n[2] * n[3]))


a = list(map(int, input().split()))
print(max(a[0] * a[1], a[2] * a[3]))


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

def __starting_point():
	main()
__starting_point()


(A, B, C, D) = map(int, input().split())
X = A * B
Y = C * D
if X > Y:
	print(X)
else:
	print(Y)


(A, B, C, D) = map(int, input().split())
n1 = A * B
n2 = C * D
ans = max(n1, n2)
print(ans)


(a, b, c, d) = map(int, input().split())
obj1 = a * b
obj2 = c * d
if obj1 < obj2:
	ans = obj2
elif obj2 < obj1:
	ans = obj1
else:
	ans = obj1
print(ans)


(a, b, c, d) = map(int, input().split())
e = []
f = a * b
g = c * d
e.append(f)
e.append(g)
if f == g:
	print(f)
else:
	print(max(e))


(a, b, c, d) = map(int, input().split())
r1 = a * b
r2 = c * d
print(max(r1, r2))


(a, b, c, d) = (int(i) for i in input().split())
print(a * b if a * b >= c * d else c * d)


(a, b, c, d) = [int(x) for x in input().split()]
print(max(a * b, c * d))


n = [int(x) for x in input().split()]
print(max(n[0] * n[1], n[2] * n[3]))


(a, b, c, d) = map(int, input().split())
result = max(a * b, c * d)
print(result)


N = list(map(int, input().split()))
print(max([N[0] * N[1], N[2] * N[3]]))


(a, b, c, d) = [int(n) for n in input().split()]
print(max(a * b, c * d))


(A, B, C, D) = map(int, input().split())
if A * B == C * D:
	print(A * B)
elif A * B < C * D:
	print(C * D)
elif A * B > C * D:
	print(A * B)


(A, B, C, D) = map(int, input().split())
a = A * B
b = C * D
c = [a, b]
print(max(c))


(a, b, c, d) = map(int, input().split())
X = a * b
Y = c * d
print(max(X, Y))


(a, b, c, d) = map(int, input().split())
A = a * b
B = c * d
if A > B:
	print(A)
else:
	print(B)


(a, b, c, d) = map(int, input().split())
dum1 = a * b
dum2 = c * d
print(max(dum1, dum2))


(a, b, c, d) = map(int, input().split())
area1 = a * b
area2 = c * d
if area1 >= area2:
	print(area1)
else:
	print(area2)


import math
(a, b, c, d) = map(int, input().split())
print(max(a * b, c * d))


(a, b, c, d) = [int(i) for i in input().split()]
print(max([a * b, c * d]))


(A, B, C, D) = map(int, input().split())
if A * B > C * D:
	print(A * B)
else:
	print(C * D)


(a, b, c, d) = map(int, input().split())
area = [a * b, c * d]
print(max(area))


import sys, math
from itertools import combinations as c, product as p
from collections import deque
sys.setrecursionlimit(10 ** 9)

def si():
	return input()

def ii():
	return int(input())

def fi():
	return float(input())

def lstr():
	return input().split()

def lint():
	return list(map(int, input().split()))

def lint_dec():
	return list([int(x) - 1 for x in input().split()])

def lnstr(n):
	return [input() for _ in range(n)]

def lnint(n):
	return [int(input()) for _ in range(n)]

def lint_list(n):
	return [lint() for _ in range(n)]
(A, B, C, D) = lint()
print(max(A * B, C * D))


(a, s, d, f) = map(int, input().split())
print(max(a * s, d * f))


(a, s, d, f) = map(int, input().split())
if a * s > d * f:
	print(a * s)
else:
	print(d * f)


def atc_052a(input_value: str) -> int:
	(A, B, C, D) = list(map(int, input_value.split(' ')))
	return max(A * B, C * D)
input_value = input()
print(atc_052a(input_value))


(vertical1, horizontal1, vertical2, horizontal2) = map(int, input().split())
area1 = vertical1 * horizontal1
area2 = vertical2 * horizontal2
if area1 < area2:
	print(area2)
else:
	print(area1)


(a, b, c, d) = map(int, input().split())
e = a * b
f = c * d
if e >= f:
	print(e)
else:
	print(f)


(A, B, C, D) = [int(i) for i in input().split()]
S1 = A * B
S2 = C * D
print(max(S1, S2))


[A, B, C, D] = list(map(int, input().split()))
s1 = A * B
s2 = C * D
print(max(s1, s2))


num = input().split()
print(max(int(num[0]) * int(num[1]), int(num[2]) * int(num[3])))


(a, b, c, d) = map(int, open(0).read().split())
print(max(a * b, c * d))


square = list(map(int, input().split()))
result = [square[0] * square[1], square[2] * square[3]]
print(max(result))


val = list(map(int, input().split()))
print(max(val[0] * val[1], val[2] * val[3]))


s = list(map(int, input().split()))
print(max(s[0] * s[1], s[2] * s[3]))


(a, b, c, d) = list(map(int, input().split()))
rec1 = a * b
rec2 = c * d
if rec1 >= rec2:
	print(rec1)
else:
	print(rec2)


(a, b, c, d) = map(int, input().split())
print([a * b, c * d][a * b < c * d])


(a, b, c, d) = input().split(' ')
print(max(int(a) * int(b), int(c) * int(d)))


(a, b, c, d) = map(int, input().split())
aa = a * b
ab = c * d
print(max(aa, ab))


(a, b, c, d) = map(int, input().split())
L = [a * b, c * d]
L.sort()
print(L[1])


(a, b, c, d) = map(int, input().split(' '))
x = a * b
y = c * d
print(max(x, y))


(a, b, c, d) = list(map(int, input().split()))
rectangles_1 = a * b
rectangles_2 = c * d
if rectangles_1 > rectangles_2:
	print(rectangles_1)
else:
	print(rectangles_2)


(a, b, c, d) = map(int, input().split())
(x, y) = (a * b, c * d)
print(x) if x > y else print(y)


(A, B, C, D) = list(map(int, input().split()))
S1 = A * B
S2 = C * D
if (1 <= A & A <= 10 ** 4) & (1 <= B & B <= 10 ** 4) & (1 <= C & C <= 10 ** 4) & (1 <= D & D <= 10 ** 4):
	if S1 > S2:
		print(S1)
	elif S1 <= S2:
		print(S2)


(A, B, C, D) = map(int, input().split())
ab = A * B
cd = C * D
if ab > cd:
	print(ab)
elif cd > ab:
	print(cd)
else:
	print(ab)


(A, B, C, D) = map(int, input().split())
area_ab = A * B
area_cd = C * D
if area_ab > area_cd:
	print(area_ab)
else:
	print(area_cd)


(a, b, c, d) = map(int, input().split())
list01 = [a * b, c * d]
print(max(list01))


(A, B, C, D) = map(int, input().split())
AB = A * B
CD = C * D
print(max(AB, CD))


(a, b, c, d) = [int(item) for item in input().split()]
print(max(a * b, c * d))


(vertical1, horizontal1, vertical2, horizontal2) = map(int, input().split())
if vertical1 * horizontal1 < vertical2 * horizontal2:
	print(vertical2 * horizontal2)
else:
	print(vertical1 * horizontal1)


n = input().split(' ')
a1 = int(n[0]) * int(n[1])
a2 = int(n[2]) * int(n[3])
print(max(a1, a2))


(A, B, C, D) = [int(s) for s in input().split()]
print(sorted([A * B, C * D])[1])


(a, b, c, d) = map(int, input().split())
n = a * b
m = c * d
p = [n, m]
p.sort()
print(p[1])


(a, b, c, d) = [int(v) for v in input().split()]
print(max(a * b, c * d))


f = lambda x: max(x[0] * x[1], x[2] * x[3])
print(f(list(map(int, input().split()))))


(a, b, c, d) = map(int, input().split())
s1 = a * b
s2 = c * d
print(max(s1, s2))


(A, B, C, D) = map(int, input().split())
area1 = A * B
area2 = C * D
if area1 > area2 or area1 == area2:
	print(area1)
else:
	print(area2)


S_list = iter(list(map(int, input().split())))
area = list()
for (x, y) in zip(S_list, S_list):
	area.append(x * y)
print(max(area))


(A, B, C, D) = map(int, input().split())
areaAB = A * B
areaCD = C * D
if areaAB == areaCD:
	result = areaAB
elif areaAB > areaCD:
	result = areaAB
else:
	result = areaCD
print(result)


(a, b, c, d) = map(int, input().split())
s1 = a * b
s2 = c * d
print(s1 if s1 >= s2 else s2)


(a, b, c, d) = map(int, input().split())
S = a * b
T = c * d
print(max(S, T))


(a, b, c, d) = map(int, input().split())
mx = max(a * b, c * d)
print(mx)


(a, b, c, d) = map(int, input().split())
ans = a * b
if a * b < c * d:
	ans = c * d
print(ans)


(A, B, C, D) = list(map(int, input().split()))
area = [A * B, C * D]
print(max(area))


class Solver:
	ans = 0

	def __init__(self, a, b, c, d):
		self.solve(a, b, c, d)

	def compare(self, s1, s2):
		return s1 if s1 > s2 else s2

	def calc_area(self, h, w):
		return h * w

	def solve(self, h1, w1, h2, w2):
		s1 = self.calc_area(h1, w1)
		s2 = self.calc_area(h2, w2)
		self.ans = self.compare(s1, s2)

def input_data():
	return list(map(int, input().split()))

def main():
	(a, b, c, d) = input_data()
	answer = Solver(a, b, c, d).ans
	print(answer)

def __starting_point():
	main()
__starting_point()


(a, b, c, d) = map(lambda x: int(x), input().split())
print(max(a * b, c * d))


(a, b, c, d) = map(int, input().split())
S1 = a * b
S2 = c * d
print(max(S1, S2))


(a, b, c, d) = map(int, input().split())
ans = (a * b, c * d)
print(max(ans))


(A, B, C, D) = [int(x) for x in input().split()]
print(max(A * B, C * D))


(a, b, c, d) = map(int, input().split())
ab = a * b
cd = c * d
print(max(ab, cd))


(A, B, C, D) = map(int, input().split())
ab = A * B
cd = C * D
print(max([ab, cd]))


(a, b, c, d) = map(int, input().split())
t1 = a * b
t2 = c * d
print(max(t1, t2))


L = list(map(int, input().split()))
print(max(L[0] * L[1], L[2] * L[3]))


(A, B, C, D) = map(int, input().split())
S1 = A * B
S2 = C * D
print(max(S1, S2))


(n, m, k, j) = map(int, input().split())
print(max(n * m, k * j))


(a, b, c, d) = map(int, input().split())
print(sorted([a * b, c * d])[-1])


A = list(map(int, input().split()))
print(max(A[0] * A[1], A[2] * A[3]))


(A, B, C, D) = map(int, input().split())
x = A * B
y = C * D
l = [x, y]
print(max(l))


(a, b, c, d) = list(map(int, input().split()))
x = a * b
y = c * d
if x == y:
	print(x)
elif x > y:
	print(x)
elif y > x:
	print(y)


(a, b, c, d) = map(int, input().split())
A = a * b
C = c * d
print(int(max(A, C)))


print(max((x * y for (x, y) in zip(*[iter(map(int, input().split()))] * 2))))


(a, b, c, d) = [int(s) for s in input().split()]
print(max(a * b, c * d))


(A, B, C, D) = [int(_) for _ in input().split()]
print(max(A * B, C * D))


(a, b, c, d) = map(int, input().split())
res = max(a * b, c * d)
print(res)


data = list(map(int, input().split()))
print(max(data[0] * data[1], data[2] * data[3]))


icase = 0
if icase == 0:
	(a, b, c, d) = map(int, input().split())
	print(max(a * b, c * d))


i = list(map(int, input().split()))
a = i[0]
b = i[1]
c = i[2]
d = i[3]
print(max(a * b, c * d))


(a, b, c, d) = (int(x) for x in input().split())
menseki1 = a * b
menseki2 = c * d
if menseki1 > menseki2:
	print(menseki1)
elif menseki1 < menseki2:
	print(menseki2)
else:
	print(menseki1)


(a, b, c, d) = map(int, input().split())
A = a * b
B = c * d
print(max(A, B))


(a, b, c, d) = [int(_) for _ in input().split()]
print(max(a * b, c * d))


z = list(map(int, input().split()))
print(max(z[0] * z[1], z[2] * z[3]))


l = list(map(int, input().split()))
print(max(l[0] * l[1], l[2] * l[3]))


(A, B, C, D) = (int(T) for T in input().split())
print(max(A * B, C * D))


(rectangle1_scale1, rectangle1_scale2, rectangle2_scale1, rectangle2_scale2) = list(map(int, input().split()))
big_rectangle_area = max(rectangle1_scale1 * rectangle1_scale2, rectangle2_scale1 * rectangle2_scale2)
print(big_rectangle_area)


import sys
input = sys.stdin.readline
l = list(map(int, input().split()))
recA = l[:2]
recB = l[2:]
areaA = int(recA[0]) * int(recA[-1])
areaB = int(recB[0]) * int(recB[-1])
if areaA > areaB:
	print(areaA)
elif areaB > areaA:
	print(areaB)
elif areaB == areaA:
	print(areaB)