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

import math
h, w, n = (int(input()) for _ in range(3))
n_drawing = math.ceil(n / max(h, w))
print(n_drawing)

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

a = max(H, W)

ans = math.ceil(N/a)

print(ans)

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

print(ans)

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

m = min(h, w)

sum = 0
ans = 0
for i in range(m):
    sum += max(h, w)
    ans += 1
    if sum >= n:
        break
print(ans)

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

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())
if H>W:
  print(N//H if (N/H)%1==0 else N//H+1)
else:
  print(N//W if (N/W)%1==0 else N//W+1)

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

p = H if H>W else W

ans = (N//p)+1 if N%p!=0 else  N//p
print(ans)

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

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

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

ans = 0
cnt = 0
first = min(h, w)
second = max(h, w)
for i in range(first):
    if cnt >= n:
        break
    ans += 1
    cnt += second
print(ans)

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

counter = 0
output = 0

while True:
    if counter >= x:
        break
    if a > b:
        counter += a
        output += 1
    else:
        counter += b
        output += 1

print(output)

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

x = H if H > W else W

print(-(-N // x))

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

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

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

print(ans)

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

if w > h:
    h, w = w, h

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

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
d=max(h,w)
ans=1
while d*ans<n:
  ans+=1
print(ans)

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

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

    L = max(H,W)
    S = min(H,W)

    print(math.ceil(N / L))

if __name__ == "__main__":
    main()

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

Solution (Python):
import math

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

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

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

if H < W:
    count = N // W
    if N % W != 0:
        count +=1
else:
    count = N // H
    if N % H != 0:
        count += 1

print(count)

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

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

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

total = 0;
ans = 0;
while total < n :
	ans += 1;
	total += max([h,w]);

print(ans);

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 

H = iin()
W = iin()
N = iin()

loop_cnt1 = min(H,W)
loop_cnt2 = max(H,W)

ans = 0
cnt = 0
for i in range(loop_cnt1):
    cnt += 1  
    ans += loop_cnt2
    if ans >= N:
        break
if ans >= N:
    print(cnt)

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 = n / max(h, w)

if ans.is_integer():
    print(int(ans))

else:
    print(int(ans) + 1)

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

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

if h > w:
    if n % h != 0:
        print((n//h)+1)
    else:
        print(n//h)
else:
    if n % w != 0:
        print((n//w)+1)
    else:
        print(n//w)

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

ans=0
while N>0:
    if H>W:
        N-=H
        W-=1
    else:
        N-=W
        H-=1
    ans+=1

print(ans)

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())
num=0
count=0
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())

if(H>W):
  p = H
else:
  p = W

total = 0
i = 0
while(total < N):
  total += p
  i += 1
  
print(i)

Solution (Python):
import math

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


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

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

c = 0
count = 0
while(True):
    c += max(h,w)
    count += 1
    if c>=n:
        break
    if h >= w:
        w -= 1
    else:
        h -= 1
        
print(count)

Solution (Python):
a = int(input())
b = int(input())
n = int(input())
if a<b : a,b=b,a
print((n+a-1)//a)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
p = max(h, w)
s = 0
for i in range(min(h, w) + 1):
  if s >= n:
    break
  s += p
print(i)

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

big = max(h,w)

if n % big == 0:
  ans = (n // big)
else:
  ans = (n // big) + 1

print(ans)

Solution (Python):
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy


from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
 
def inp(): 
    return int(input())
def inpm(): 
    return map(int,input().split())
def inpl(): 
    return list(map(int, input().split()))
def inpls(): 
    return list(input().split())
def inplm(n): 
    return list(int(input()) for _ in range(n))
def inpll(n): 
    return [list(map(int, input().split())) for _ in range(n)]


def main():
    h = inp()
    w = inp()
    n = inp()
    if h < w:
        h,w = w,h
    for i in range(w+1):
        if i*h>=n:
            print(i)
            return

if __name__ == "__main__":
    main()

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

result = 0
count = 0

while True:
    if N <= count:
        break
    result += 1
    if H > W:
        count += H
        W -= 1
    else:
        count += W
        H -= 1

print(result)

Solution (Python):

import math


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

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

Solution (Python):
import math

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

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

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

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

print(ans)

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

if h >= w:
    max= h
    min=w
else:
    max = w
    min=h
count =0
c=0
for _ in range(min):
    count += max
    c+=1
    if n<=count:
        break
print(c)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
ma = max(H, W)
count = 0
for i in range(H*W+1):
    count+= ma
    if count >= N:
        count = i + 1
        break
print(count)

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

import math

if H>W:
    num=H
else:
    num=W
    
ans=math.ceil(N/num)

print(ans)

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

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

Solution (Python):
def main():
    from sys import stdin, setrecursionlimit
    
    
    
    
    
    r = [int(stdin.readline()) for i in range(3)]
    
    if r[0] < r[1]:
        if r[2] % r[1] == 0:
            print(r[2] // r[1])
        else:
            print(r[2] // r[1] + 1)
    else:
        if r[2] % r[0] == 0:
            print(r[2] // r[0])
        else:
            print(r[2] // r[0] + 1)
    
    
    
    

if __name__ == '__main__':
    main()

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

long = W

if H > W:
    long = H

ans = math.ceil(N/long)

print(ans)

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

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

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

longer = max(h, w)
step = n // longer
if n % longer != 0:
    step += 1
print(step)

Solution (Python):
import math

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

P = W if H < W else H

print(math.ceil(N/P))

Solution (Python):
import math

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

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

Solution (Python):
import sys
input = sys.stdin.readline
h = int(input())
w = int(input())
n = int(input())

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

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

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

Solution (Python):
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

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

ans = 0

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

print(ans)

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

Solution (Python):

import math


def solve(*args: str) -> str:
    h, w, n = map(int, args)

    return str(math.ceil(n/max(h, w)))


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

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

if h>w:
    print(-(-n//h))

else:
    print(-(-n//w))

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

a = max(H,W)

x = math.ceil(N/a)
print(x)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

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

	ans = 0
	tmp = max(H,W)
	
	ans = -(-N // tmp)

	print(ans)


if __name__ == "__main__":
	main()

Solution (Python):
import math

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

l = max([h, w])
c = n / l 
print(math.ceil(c))

Solution (Python):


h=int(input())
w=int(input())
N=int(input())
m=max(h,w)
n=min(h,w)
cnt=0
for i in range(n):
    cnt+=1
    N-=m
    if N<=0:
        break
if N>0:
    for i in range(m):
        cnt+=1
        M-=n
        if N<=0:
            break
print(cnt)

Solution (Python):

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

m_num = max(H, W)

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

Solution (Python):
from math import ceil

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

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

if h >= w:
  if n % h == 0:
    c = n // h
  else:
    c = n // h + 1
else:
  if n % w == 0:
    c = n // w
  else:
    c = n // w + 1
print(c)

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

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

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

if H>W:
    a = H
else:
    a = W

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

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

max_h_w = max([H, W])
min_h_w = max([H, W])

count = 0
for i in range(min_h_w):
    N -= max_h_w
    count += 1
    if N <= 0:
        break
print(count)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
for i in range(1000000):
    if max(H, W) * i >= N:
        print(i)
        exit()

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
black = 0
ooicnt = 0
skncnt = 0
for i in range(n):
    if ooicnt < n:
        ooicnt+=1
        black += max(h,w)
        if black >= n:
            break
    else:
        skncnt+= 1
        black += min(h,w)
        if black >= n:
            break
print(ooicnt+skncnt)

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict


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


def main():
	H = int(input())
	W = int(input())
	N = int(input())
	ans = H + W
	for i in range(H + 1):
		for j in range(W + 1):
			if H * W - i * j >= N:
				ans = min(ans, H - i + W - j)

	print(ans)


if __name__ == '__main__':
	main()

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

if h > w:
    if n%h == 0:
        print(int(n/h))
    else:
        print(int(n/h) + 1)
else:
    if n%w == 0:
        print(int(n/w))
    else:
        print(int(n/w) + 1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
a, b = max(h, w), min(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())


t = max(H, W)
c = 0
for i in range(10 ** 9):
    c = t * i
    if c >= N:
        break

print(i)

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=input()
W=input()
N=input()

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

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

choice = max(h,w)
i = 0

while i * choice < n:
    i += 1
print(i)

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

for i in range(min(H,W)):
    if max(H,W)*(i+1)>=N:
        print(i+1)
        exit()

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

    ans = 0
    h, w = 0, 0
    while True:

        if H >= W and h != H:
            N -= H
            h += 1
        elif w != W:
            N -= W
            w += 1
            
        ans += 1

        if N <= 0:
            print(ans)
            exit()
if __name__ == '__main__':
    main()

Solution (Python):


import sys
from math import ceil

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    H = i2n()
    W = i2n()
    N = i2n()
    lgr = max(H, W)
    print(ceil(N / lgr))
    return

main()

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

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


    return 0

if __name__ == '__main__':
    main()

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

if h > w:
    if n%h==0:
        answer=int(n/h)
    else:
        answer=int(n/h)+1
else:
    if n%w==0:
        answer=int(n/w)
    else:
        answer=int(n/w)+1
print(answer)

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

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


if __name__ == '__main__':
    main()

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

if h > w:
    print(math.ceil(n/h))
else:
    print(math.ceil(n/w))

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

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

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

print(N//max(H,W)+(not (N%max(H,W)==0)))

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

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

	ans = 0
	tmp = max(H,W)
	
	ans = -(-N // tmp)

	print(ans)


if __name__ == "__main__":
	main()

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

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):
H = int(input())
W = int(input())
N = int(input())

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

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())
if W<H:
  H,W=W,H

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

Solution (Python):

import math

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

if H >= W:
    out = math.ceil(N / H)
else:
    out = math.ceil(N / W)

print(out)

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

greater = max(h, w)

ans = (n +greater-1) // greater

print(ans)

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

m = max(H,W)
print(-(-N // m))

Solution (Python):


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

m = max(h, w)
if n < m:
    print(1)
elif n % m == 0:
    print(n // m)
else:
    print(n // m + 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
a = int(input())
b = int(input())
c = int(input())
print(math.ceil(c/max(a,b)))

Solution (Python):
sizeI = int(input())
sizeJ = int(input())
n = int(input())

mx = max(sizeI, sizeJ)
print((n + mx - 1) // mx)

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

Solution (Python):
import math
h=int(input())
w=int(input())
n=int(input())
ans=math.ceil(n/(max(h,w)))
print(int(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())
print(-(-N//max(H,W)))

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):
def main():
  H=int(input())
  W=int(input())
  N=int(input())
  if W>H:
    tmp=W
    W=H
    H=tmp
  for i in range(1,W+1):
    if H*i>=N:
      print(i)
      return 0
main()

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

Solution (Python):
import math as m

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

if H > W:
    target=H

print(m.ceil(N/target))

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

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

Solution (Python):

"""
Created on Sat Jan 18 20:52:41 2020

@author: masat
"""
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())

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

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

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

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):
import math
H=int(input())
W=int(input())
N=int(input())

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

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

Solution (Python):
from sys import stdout
printn = lambda x: stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
BIG = 999999999
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
mx = max(h,w)
ans = 0
for i in range(h*w):

    if i * mx >= n:
        ans = i
        break
print(ans)

Solution (Python):
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(a, b, c):
    big = max(a, b)
    if c % big == 0: return c // big
    else: return (c // big) + 1
    
    
    



do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    
    
    a = int(input())
    b = int(input())
    c = int(input())
    
    print(sol(a, b, c))

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

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

Solution (Python):
import math

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

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

Solution (Python):
import math
h = int(input())
w = int(input())
n = int(input())
if h>= w:
    print(math.ceil(n/h))
else:
    print(math.ceil(n/w))

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

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

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

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

ans = 0
H, W = max(H, W), min(H, W)

cnt = 0
while (True):
  if N > cnt:
    cnt += H
    ans += 1
  else:
    print(ans)
    break

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

if W>=H:
    cnt=(N-1+W)//W
else:
    cnt=(N-1+H)//H

print(cnt)

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
a=max(h,w)
cnt=1
while True:
  if a*cnt>=n:
    print(cnt)
    break
  cnt+=1

Solution (Python):
import math
H, W, N = [int(input()) for _ in range(3)]
print(math.ceil(N / max(H, W)))

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

bigger = max(H, W)

ans = N // bigger
if N % bigger != 0:  
    ans += 1
    print(ans)
else:
    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())

X=max([W,H])
Y=N//X
if X*Y==N:
  print(Y)
else:
  print(Y+1)

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

if N % H == 0:
    H_count = N // H
else:
    H_count = N // H + 1
    
if N % W == 0:
    W_count = N // W
else:
    W_count = N // W + 1


print(min(H_count, W_count))

Solution (Python):
import math

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

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

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

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

t = 0
ans = 0
for i in range(max(H, W)):
    t += max(H, W)
    ans += 1
    if t >= N:
        break

print(ans)

Solution (Python):
from sys import stdin
import math

H = int(stdin.readline().rstrip())
W = int(stdin.readline().rstrip())
N = int(stdin.readline().rstrip())

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

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

if h > w:
  h, w = w, h
print(math.ceil(n / w))

Solution (Python):

def solve(h,w,n):
    temp = max(h,w)
    if n % temp == 0:
        return n // temp
    else:
        return n // temp + 1

def main():
    h = int(input())
    w = int(input())
    n = int(input())
    print(solve(h,w,n))

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import sys
from math import floor, ceil
inputs = sys.stdin.readlines()

h = int(inputs[0])
w = int(inputs[1])
n = int(inputs[2])

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
print(N // max(H, W) + (N % max(H, W) > 0))

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


if h > w:
    wkv = h
else:
    wkv = w

ans = int(n / wkv) + 1

if (n % wkv) == 0:
    ans = ans - 1


print(ans)

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

L = max(H, W)

if N // L == N / L:
    print(N // L)
else:
    print((N // L) + 1)

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

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

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

H = ir()
W = ir()
N = ir()

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

Solution (Python):
x=int(input())
y=int(input())
z=int(input())
if x<=y:
  b=z//y
  c=z%y
else:
  b=z//x
  c=z%x
if c!=0:
  b+=1
print(str(b))

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-1) // max(H,W) + 1)

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

x = max(h, w)
a, b = divmod(n, x)
b = 0 if b == 0 else 1
print(a + b)

Solution (Python):






import math
import statistics
import numpy as np
import queue


def fact(n):
  if(n == 1):
    return 1
  else:
    return (n * fact(n - 1))


def gcd(a,b):
  if a == 0:
    return b
  elif b == 0:
    return a
  else:
    return gcd(b,a % b)


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


def qsort(seq):
  if len(seq) < 1:
      return seq
  pivot = seq[0]
  left = []
  right = []
  for x in range(1, len(seq)):
    if seq[x] <= pivot:
        left.append(seq[x])
    else:
        right.append(seq[x])
  left = qsort(left)
  right = qsort(right)
  foo = [pivot]
  return (left + foo + right)






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

if n / h > n / w:
  print(math.ceil(n / w))
else:
  print(math.ceil(n / h))

Solution (Python):
import math
h,w,n=map(int,open(0).read().split())
print(math.ceil(n/max(h,w)))