Problem:
 Score : 100 points    Problem Statement We have a grid with H rows and W columns, where all the squares are initially white.  You will perform some number of painting operations on the grid.
In one operation, you can do one of the following two actions:   Choose one row, then paint all the squares in that row black.  Choose one column, then paint all the squares in that column black.   At least how many operations do you need in order to have N or more black squares in the grid?
It is guaranteed that, under the conditions in Constraints, having N or more black squares is always possible by performing some number of operations.      Constraints  1 \leq H \leq 100  1 \leq W \leq 100  1 \leq N \leq H \times W  All values in input are integers.         Input Input is given from Standard Input in the following format:  H  W  N       Output Print the minimum number of operations needed.        Sample Input 1 3
7
10      Sample Output 1 2  You can have 14 black squares in the grid by performing the "row" operation twice, on different rows.       Sample Input 2 14
12
112      Sample Output 2 8       Sample Input 3 2
100
200      Sample Output 3 2

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

num = max(H,W)
if N % num == 0:
    ans = N // num
else:
    ans = N //num +1
print(ans)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

if H > W:
    if N % H == 0:
        print(N // H)
    else:
        print(N // H + 1)
else:
    if N % W == 0:
        print(N // W)
    else:
        print(N // W + 1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

bigger = max(H,W)

if N%bigger==0:
    print(N//bigger)
else:
    print(N//bigger+1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

if h > w:
    m = -(-n // h)
else:
    m = -(-n // w)

print(m)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
x=max(h,w)
for i in range(10**4):
    if x>=n:
        print(i+1)
        exit()
    if h>w:
        x+=h
    else:
        x+=w

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
a=0
ans=0
paint=max(h,w)
while a<n:
    a+=paint
    ans+=1
print(ans)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())

x=max(h,w)
if (n/x)%1==0:
  print(n//x)
else:
  print(n//x+1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

mm = max(h,w)
if (n%mm)==0:
    ans = n//mm
else:
    ans = (n//mm)+1

print(ans)

Solution (Python):
import queue
import copy
import math


h = int(input())
w = int(input())
n = int(input())

ans = 0
while 0 < n:
    n -= max(h, w)
    ans += 1

print(ans)

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]

H = int(input())
W = int(input())
N = int(input())

if H>=W:
    t = N%H
    if t==0:
        print(N//H)
    else:
        print(N//H+1)
else:
    t = N%W
    if t==0:
        print(N//W)
    else:
        print(N//W+1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
ans = N // max(H,W)
if not N % max(H,W) == 0:
    ans += 1
print(ans)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
a = b = 100000000
for i in range(h+1):
    if n <= i * w:
        a = i
        break
for i in range(w+1):
    if n <= i * h:
        b = i
        break
print(min(a,b))

Solution (Python):
import math

h = int(input())
w = int(input())
n = int(input())
x = max(h, w)
ans = math.ceil(n / x)
print(ans)

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


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


def S(): return input()


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


def MS(): return map(str, 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 = ['No', 'Yes']
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    H = I()
    W = I()
    N = I()

    if H > W:
        print(int(math.ceil(N / H)))
    else:
        print(int(math.ceil(N / W)))


if __name__ == '__main__':
    main()

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

print((n-1)//max(h,w)+1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
print(-(-N // max(H, W)))

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import bisect
import sys
input = sys.stdin.readline

setrecursionlimit(1000000)

def main():
	h,w,m = int(input()),int(input()),int(input())
	h,w = max(h,w),min(h,w)
	print(math.ceil(m/h))

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

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

Solution (Python):
h=int(input())
w = int(input())
n = int(input())

x = max(h, w)
if n % x == 0:
    print(n // x)
else:
    print(n//x+1)

Solution (Python):
import math


H = int(input())
W = int(input())
N = int(input())

large = max(H, W)

ans = math.ceil(N / large)
print(ans)

Solution (Python):
import numpy as np
H = int(input())
W = int(input())
N = int(input())

h=max(H,W)
print(int(np.ceil(N/h)))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
if H > W:
    a = H
    b = W
else:
    a = W
    b = H
ans = 0
c = 0
while(1):
    c += a
    ans += 1
    if c >= N:
        break
print(ans)

Solution (Python):
ans = 2000
H = int(input())
W = int(input())
N = int(input())
for nh in range(H+1):
    for nw in range(W+1):
        white = (H-nh)*(W-nw)
        if H*W-white>=N:
            ans = min(ans, nh+nw)
print(ans)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

print((n+max(h,w)-1)//max(h,w))

Solution (Python):
h=int(input())
w=int(input())

n=int(input())
a=max(h,w)
count=1
while a*count<n:
    count+=1

print(min(count,h,w))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())


if H > W:
    if N % H != 0:
        result = N // H + 1
    else:
        result = N // H
else:
    if N % W != 0:
        result = N // W + 1
    else:
        result = N // W
print(result)

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

def resolve():
    H = int(input())
    W = int(input())
    N = int(input())

    x = max(H, W)
    a, b = divmod(N, x)
    if b:
        a += 1
    print(a)

if __name__ == "__main__":
    resolve()

Solution (Python):
import math

def Key1():
    H = int(input())
    W = int(input())
    N = int(input())

    ans = math.ceil(N / max(H, W))
    print(ans)

Key1()

Solution (Python):
from math import ceil

H=int(input())
W=int(input())
N=int(input())

print(ceil(N/max(H,W)))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
if n % max(h,w) != 0:
    print(n // max(h,w) + 1)
else:
    print(n // max(h,w))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
k = max(h,w)
for i in range(k):
    n = n -k
    if n <= 0:
        print(i+1)
        exit()

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
cnt=0
while n>0:
  n-=max(h,w)
  cnt+=1
print(cnt)

Solution (Python):
import math
H = int(input())
W = int(input())
N = int(input())

ans = 0
a = max(H,W)
print(math.ceil(N / a))

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
p=max(h,w)

if n%p!=0:
	print(n//p+1)
else:
  	print(n//p)

Solution (Python):
from math import ceil
H = int(input())
W = int(input())
N = int(input())
n = max(H, W)
print(ceil(N/n))

Solution (Python):

H = int(input())
W = int(input())
N = int(input())

blacked = 0
larger_rows = max(H, W)
ans = 0

while blacked < N:
    blacked += larger_rows
    ans += 1

print(ans)

Solution (Python):
import math

h = int(input().strip())
w = int(input().strip())
n = int(input().strip())
t = 0
if h <= w:
    t = w
else:
    t = h
print(math.ceil(n / t))

Solution (Python):
import math
H = int(input())
W = int(input())
N = int(input())
n = max(H,W)
print(math.ceil(N/n))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

if (N % max(W,H) == 0):
    print(N // max(W,H))
else:
    print(N // max(W,H) + 1)

Solution (Python):
a = int(input())
b = int(input())
c = int(input())

k = max(a, b)
ans = c//k
if c%k:
    ans += 1
print(ans)

Solution (Python):
n = int(input())
m = int(input())
k = int(input())
print(min((k + m - 1) // m, (k + n - 1) // n))

Solution (Python):
import math
def A():
    H = int(input())
    W = int(input())
    N = int(input())
    print(int(min(math.ceil(N/H), math.ceil(N/W))))

A()

Solution (Python):
''' Hey stalker :) '''
INF = 10**10
def main():
    
    ''' Cook your dish here! '''
    k = max(get_int(), get_int())
    n = get_int()
    print((n+k-1)//k)


''' Pythonista fLite 1.1 '''
import sys
from collections import defaultdict, Counter
from bisect import bisect_left, bisect_right



out = []
get_int = lambda: int(input())
get_list = lambda: list(map(int, input().split()))
main()

Solution (Python):
def main():
    H = int(input())
    W = int(input())
    N = int(input())
    long = max(H, W)
    cnt = N // long
    if N % long != 0:
        cnt += 1
    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):
H = int(input())
W = int(input())
N  = int(input())
A = max(H,W)
output = N//A
if N%A!=0:
    output += 1
print(output)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
ans=0
ansc=0
while True:
    if ansc>=n:
        print(ans)
        break
    if h>w:
        w-=1
        ansc+=h
        ans+=1
    else:
        h-=1
        ansc+=w
        ans+=1

Solution (Python):


H = int(input())
W = int(input())
N = int(input())

longer = max(H, W)

count = int(N / longer)
if N % longer > 0:
    count += 1

print(count)

Solution (Python):
def num():
    return int(input())
def nums():
    return list(map(int,input().split()))

import itertools as iter
import math
import fractions
from functools import reduce

def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

H = num()
W = num()
N = num()
u = max(H,W)
print(math.ceil(N/u))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

cnt = 0
while N > 0:
    N -= max(H, W)
    cnt += 1

print(cnt)

Solution (Python):

h = int(input())
w = int(input())
n = int(input())
l = max(h,w)
s = 0
ans = 0
while s < n:
    ans += 1
    s += l
print(ans)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

H, W, N = map(int, read().split())

print((N + max(H, W) - 1) // max(H, W))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
if H > W:
    if N%H == 0:
        print(N//H)
    else:
        print(N//H+1)
else:
    if N%W == 0:
        print(N//W)
    else:
        print(N//W+1)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())

_max=max(h,w)
_min=min(h,w)
ans=0

for i in range(_min):
    n-=_max
    ans+=1
    if n<=0:
        print(ans)
        exit()
    
for i in range(_max):
    n-=_min
    ans+=1
    if n<=0:
        print(ans)
        exit()

Solution (Python):
H=int(input())
W=int(input())
N=int(input())
n=max(H,W)
if N%n==0:
    print(N//n)
else:
    print(N//n+1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

if h >= w:
    ans = -(-n//h)
else:
    ans = -(-n//w)

print(int(ans))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
s = max(h, w)
print(int(n / s)) if(n % s == 0) else print(int(n / s) + 1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

a = min(H, W)
b = max(H, W)

c = 0

for i in range(a):
    c += 1
    N -= b
    if N <= 0:
        print(c)
        quit()

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

H = INT()
W = INT()
N = INT()
c = 0
ans = 0
while N > c:
    c += max(H, W)
    ans += 1
print(ans)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

M = max(H, W)
ans = N//M

if N%M == 0:
    print(ans)
else:
    print(ans + 1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

ans = float('INF')
for i in range(0, h+1):
    for j in range(0, w+1):
        if i*h + j*w >= n:
            ans = min(ans, i+j)
print(ans)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())

buf=max(h,w)

if n%buf == 0:
    print(n//buf)
else:
    print(n//buf+1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

from math import ceil

print(ceil(N/max(H,W)))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
print(n//max(h, w)) if n%max(h,w)==0 else print(n//max(h,w)+1)

Solution (Python):
import sys
import math
input = sys.stdin.readline
H = int(input())
W = int(input())
N = int(input())
a = max(H,W)
print(math.ceil(N/a))

Solution (Python):
import sys
import math
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

h = ni()
w = ni()
n = ni()

print(min((n-1)//h+1, (n-1)//w+1))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
cnt = 0
if h > w:
    while True:
        if n <= 0:
            break
        n -= h
        cnt += 1
    while True:
        if n <= 0:
            break
        n -= (w - 1)
        cnt += 1
else:
    while True:
        if n <= 0:
            break
        n -= w
        cnt += 1
    while True:
        if n <= 0:
            break
        n -= (h - 1)
        cnt += 1
print(cnt)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

print((n-1)//max(h, w) + 1)

Solution (Python):
import math

H = int(input())
W = int(input())
N = int(input())

tmp = max(H,W)
print(math.ceil(N/tmp))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
a = max([H,W])
print((N-1)//a+1)

Solution (Python):
import math

H = int(input())
W = int(input())
N = int(input())

print(math.ceil(N/max(H,W)))

Solution (Python):
import math

input =raw_input
h = int(input())
w = int(input())
n = float(int(input()))

out = int(math.ceil(n / max(w, h)))
print(out)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
a = max(h, w)
x = 0
ans = 0
while x < n:
    x += a
    ans += 1

print(ans)

Solution (Python):
from math import ceil
h,w,n=[int(input()) for i in range(3)]
num=max(h,w)
print(ceil(n/num))

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

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

def my_round(a,dig=0):
    p = 10 ** dig
    return (a * p * 2 + 1) // 2 / p

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():
    h = int(input())
    w = int(input())
    n = int(input())
    ans = 0
    if n % max(h,w) == 0:
        ans = n // max(h,w)
    else:
        ans = n // max(h,w) + 1
    print(ans)
    return

if __name__=='__main__':
    main()

Solution (Python):
import math
H = int(input())
W = int(input())
N = int(input())
if H<W:H,W=W,H
print(math.ceil(N/H))

Solution (Python):
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30

def main():
    h = int(input().strip())
    w = int(input().strip())
    n = int(input().strip())
    print((n + max(h, w) - 1) // max(h, w))

if __name__ == '__main__':
    main()

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
k=max(h,w)
print((n-1)//k+1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

for i in range(1, 100000):
    if h * i >= n or w * i >= n:
        print(i)
        exit()

Solution (Python):
import math
h = int(input())
w = int(input())
n = int(input())

print(math.ceil(n / max(h,w)))

Solution (Python):

import math
h = int(input())
w = int(input())
n = int(input())

print(min(math.ceil(n/h), math.ceil(n/w)))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
print(-(-n//max(h,w)))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

a = max([h, w])

ans = n // a
if n % a > 0:
    ans += 1

print(ans)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

high = max(h,w)
low = min(h,w)

count = 0
ans = 0
for i in range(low):
  count += high
  ans += 1
  if count >= n:
    break
print(ans)

Solution (Python):
H=int(input())
W=int(input())
N=int(input())

X = max(H,W)
ans = (N + X - 1) // X

print(ans)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

a = max(h, w)

if n % a == 0:
    print(n//a)
else:
    print((n//a)+1)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

bigger = max(H, W)
painted = 0
ans = 0

while painted < N:
    ans += 1
    painted += bigger

print(ans)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

hw = max(h,w)

tmp = 0
cnt = 0

if hw == h:
    for i in range(w):
        tmp += h
        cnt += 1
        if tmp >= n:
            print(cnt)
            exit()
else:
    for i in range(h):
        tmp += w
        cnt += 1
        if tmp >= n:
            print(cnt)
            exit()

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

long_ = max(h,w)

ans = - (-n // long_)

print(ans)

Solution (Python):
import math
H=int(input())
W=int(input())
N=int(input())
ma = max([H,W])
res = math.ceil(N/ma)
print(res)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())

M = max(h, w)

if n % M == 0:
    print(n//M)
else:
    print(n//M + 1)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())

hw=max(h,w)

print(int(-1*((-1*n)//hw)))

Solution (Python):
import math
H = int(input())
W = int(input())
N = int(input())
print(math.ceil(N/max(H,W)))

Solution (Python):
import math
h = int(input())
w = int(input())
n = int(input())
x = max(h,w)
print(math.ceil(n/x))

Solution (Python):
import math

h = int(input())
w = int(input())
n= int(input())

print(math.ceil(n / max(h, w)))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
ans = 10**18
for a in range(H+1):
    for b in range(W+1):
        if a*W+b*H-a*b>=N:
            ans = min(a+b, ans)
print(ans)

Solution (Python):
from math import ceil
def main():
    H = int(input())
    W = int(input())
    N = int(input())
    print(ceil(N / max(H,W)))

if __name__ == "__main__":
    main()

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
import math
large = max(H, W)
ans = math.ceil(N / large) 
print(ans)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

a = max(H,W)
ans = N // a 
if N % a != 0:
    ans += 1
print(ans)

Solution (Python):


H=int(input())
W=int(input())
N=int(input())
ans=0
k=0
for i in range(100):
   k+=max(H,W)
   ans+=1
   if k>=N:
       break
print(ans)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())

if N % max(H, W) == 0:
  ans = N // max(H, W)
else:
  ans = N // max(H, W) + 1
  
print(ans)

Solution (Python):
H=int(input())
W=int(input())
N=int(input())

a=max(H,W)
ans=N//a
if N%a!=0:
    ans+=1


print(ans)

Solution (Python):
import sys
import math
input = sys.stdin.readline

H = int(input())
W = int(input())
N = int(input())





m = max(H, W)

print(math.ceil(N/m))