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 = int(input())
w = int(input())
n = int(input())

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

Solution (Python):
from sys import stdin
H = int(stdin.readline().rstrip())
W = int(stdin.readline().rstrip())
N = int(stdin.readline().rstrip())
print((N-1)//max(H, W) + 1)

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

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

Solution (Python):
row = int(input())
colmun = int(input())
top = int(input())
low, high = 0,0
if row <= colmun:
  low, high = row, colmun
else:
  low, high = colmun, row
for n in range(low):
  if (n + 1) * high >= top:
    print(n + 1)
    break

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

all_cell = 0
count = 0
while all_cell < n:
    if h > w:
        all_cell += h
        w -= 1
    else:
        all_cell += w
        h -= 1

    count += 1
print(count)

Solution (Python):
H,W,N = [int(input()) for i in range(3)]
for o in range(1,10000):
  if H <= W and N / o <= W:
    break
  elif H >= W and N / o <= H:
    break
print(o)

Solution (Python):
import math

size = {}
size['H'] = int(input())
size['W'] = int(input())
N = int(input())
if size['H'] > size['W']:
    bigsize = 'H'
else:
    bigsize = 'W'
lines_num = math.ceil(N/size[bigsize])

print(lines_num)

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

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

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

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

Solution (Python):
h=int(input())
w=int(input())
n=int(input())
if h<w:
	w,h=h,w
from math import ceil
print(ceil(n/h))

Solution (Python):
h,w,n=map(int,[input() for i in range(3)])
a=max(h,w)
print((n+a-1)//a)

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

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

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

H = input()
W = input()
N = input()
den = max(H, W)
print N / den + (N % den != 0)

Solution (Python):
import sys
H = int(sys.stdin.readline())
W = int(sys.stdin.readline())
N = int(sys.stdin.readline())
 
print((N - 1) // max(H, W) + 1)

Solution (Python):

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

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

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

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

answer = h+w
for i in range(h+1):
  for j in range(w+1):
    area = i * w + j * h - i * j
    if area >= n:
      answer = min(answer, i+j)

print(answer)

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

X = 0

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

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

for i in range(1, min(h,w) + 1):
    if i * max(h,w) >= n:
        print(i)
        exit()

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

if h >= w:
    larger = h
else:
    larger = w

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

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

x = max(h, w)
cnt = 0
cur = 0

while cur < n:
	cur += x
	cnt+=1

print(cnt)

Solution (Python):

import sys


def solve(H: int, W: int, N: int):
    if N % max(H, W) != 0:
        print(int(N / max(H, W) + 1))
    else:
        print(int(N / max(H, W)))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  
    W = int(next(tokens))  
    N = int(next(tokens))  
    solve(H, W, N)

if __name__ == '__main__':
    main()

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

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

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):
h = int(input())
w = int(input())
n = int(input())
count = 0
if h < w:
  a = w
  b = h
else:
  a = h
  b = w
 
x = int(n/a)
if n%a != 0:
  x += 1
print(x)

Solution (Python):
H, W, N = [int(input()) for _ in range(3)]
print(min((N+H-1)//H, (N+W-1)//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):
import math
h = int(input())
w = int(input())
n = int(input())

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

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

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

ans = -(-n // 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):
def a_painting():
    from math import ceil
    H = int(input())
    W = int(input())
    N = int(input())
    return ceil(N / max(H, W))

print(a_painting())

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

painted = 0
cnt = 0


for _ in range(min(H, W)):
    painted += max(H, W)
    cnt += 1
    if painted >= N:
        break

print(cnt)

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

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

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

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

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

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

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
HW =H*W
ans =H+W
for h in range(0,H+1):
    for w in range(0,W+1):
        cntB = HW - (H-h)*(W-w)
        if cntB>=N:
            ans = min(ans, h+w)
print(ans)

Solution (Python):
from sys import stdin
H = int(stdin.readline().rstrip())
W = int(stdin.readline().rstrip())
N = int(stdin.readline().rstrip())
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(-(-n//max(h,w)))

Solution (Python):


import sys, math
sys.setrecursionlimit(300000)


def solve(H: int, W: int, N: int):
    ret = min(math.ceil(N / H), math.ceil(N / W))
    print(ret)
    return

def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  
    W = int(next(tokens))  
    N = int(next(tokens))  
    solve(H, W, N)

if __name__ == '__main__':
    main()

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

a = max(H, W)
print(N // a + min(1, N % a))

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

ans=0
a=0
while a<n:
    if h<w:
        a+=w
        h-=1
    else:
        a+=h
        w-=1
    ans+=1
print(ans)

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

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

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

Solution (Python):
h=int(input())
w=int(input())
m=max(h,w)
x=int(input())

print((x+m-1)//m)

Solution (Python):
input_list = []
for i in range(0, 3):
  input_list.append(int(input()))

h = input_list[0]
w = input_list[1]
n = input_list[2]

temp_num = 0
if w <= h:
  temp_num = h
else:
  temp_num = w

answer = 0
if n % temp_num == 0:
  answer = int(n / temp_num)
else:
  answer = (n // temp_num) + 1
print(answer)

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

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

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

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

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

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

Solution (Python):
import sys
read=sys.stdin.read
h,w,n=map(int, read().split())
m=max(h,w)
print(n//m+(n%m!=0))

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

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

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

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

cnt=0
black=0
if H>=W:
  for i in range(W):
    black+=H
    cnt+=1
    if black>=N:
      break
elif H<W:
  for i in range(H):
    black+=W
    cnt+=1
    if black>=N:
      break
print(cnt)

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

longer = H

if longer < W:
    longer = W
    

print(((N-1)//longer)+1)

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

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

print(int(ans))

Solution (Python):
def main():
    H = int( input())
    W = int( input())
    N = int( input())
    if H < W:
        H, W = W, H
    ans = N//H
    if N%H != 0:
        ans += 1
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10


def solve():
    h, w, n = IR(3)
    print(min(n // h + (n % h > 0), n // w + (n % w > 0)))
    return

if __name__ == '__main__':
    solve()

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

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

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
def paint(num):
    if num >= n:
        print(1)
    else:
        k = 0
        c = 0
        while k < n:
            k +=num
            c+=1
        print(c)

if h <= w:
    paint(w)
else:
    paint(h)

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

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

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

Solution (Python):
A = [int(input()) for i in range(3)] 
a, b = 0, 0
for j in range(min(A[0],A[1])):
  if a < A[2]:
    a += max(A[0],A[1])
    b += 1
  else:
    break
print(b)

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):
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())
ma = max(h, w)
print(n // ma) if n // ma == n / ma else print(n // ma + 1)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def main():
    h = I()
    w = I()
    n = I()
    t = max(h,w)


    return (n+t-1) // t


print(main())

Solution (Python):
def main(h: int, w: int, n: int):
    m = max(h, w)

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


if __name__ == "__main__":
    h = int(input())
    w = int(input())
    n = int(input())

    main(h, w, n)

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

Big = W if W > H else H

print(math.ceil(N / Big))

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

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

Solution (Python):
def solve(h, w, n):
    return min((n+h-1) // h, (n+w-1) // w)

h = int(input())
w = int(input())
n = int(input())
print(solve(h, w, n))

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
H,W,N=map(int,open(0))
L=max(H,W)
print((N+L-1)//L)

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

use = h if h >= w else w

print(n//use + 1 if n%use else n//use)

Solution (Python):
h,w,n=map(int,open(0));print(0--n//max(h,w))

Solution (Python):

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


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


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)

def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max,mod=DIV):
    fac,finv,inv = [0]*max, [0]*max, [0]*max
    fac[0]=fac[1]=1
    finv[0]=finv[1]=1
    inv[1]=1
    for i in range(2,max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod -inv[mod%i] * (mod//i)%mod
        finv[i] = finv[i-1]*inv[i]%mod
    class CONV:
        def __init__(self):
            pass
        def ncr(self,n,k):
            if(n<k):
                return 0
            if(n<0 or k<0 ):
                return 0
            return fac[n]*(finv[k]*finv[n-k]%mod)%mod
    return CONV()



def main():
    H,W,N = iRaw(),iRaw(),iRaw()
    Z = max(H,W)
    return (N+Z-1)//Z

if __name__ == "__main__":
    print(main())

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

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

print(c//max(a,b)+(c%max(a,b)!=0))

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

Solution (Python):
def resolve():
    import sys
    import math
    H, W, N = map(int, sys.stdin.read().split())
    m = max(H, W)
    print(math.ceil(N / m))

resolve()

Solution (Python):
def resolve():
    import sys
    import math
    H, W, N = map(int, sys.stdin.read().rstrip().split())
    m = max(H, W)
    print(math.ceil(N / m))

resolve()

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

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

Solution (Python):
import math

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

num = h if h>w else w

print(math.ceil(n/num))

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

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

Solution (Python):


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

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

Solution (Python):
import math




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

best = max(h,w)
operations = n//best
if n%best != 0:
    operations += 1

print(operations)

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

m = max(h, w)
ans, mod = n // m, n % m
if mod:
    ans += 1
print(ans)

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, W, N = [int(input()) for i in range(3)]

p = max(H, W)

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

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

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

b = max(h, w)

print(n//b + min(n%b, 1))

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):
h=int(input())
w=int(input())
n=int(input())

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

Solution (Python):
def solve():
    H, W, N = map(int, open(0).read().split())
    bigger = max(H, W)
    print(N // bigger if N % bigger == 0 else N // bigger + 1)


if __name__ == '__main__':
    solve()

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

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
a, m = divmod(N, max(H, W))
if m != 0:
    a += 1
print(a)

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

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

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

total = h*w
kesu = max(h, w)

if n%kesu==0:
    print(n//kesu)
else:
    print(n // kesu + 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
def solve():
  h = int(input())
  w = int(input())
  n = int(input())
  ans = int(min(math.ceil(n/h),math.ceil(n/w)))
  print(ans)
solve()

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

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

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

target = max(h, w)
for i in range(1, min(h, w)+1):
  if target * i >= n:
    print(i)
    break

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

num1 = n/h
num2 = n/w

if not num1.is_integer():
  num1 = int(num1) + 1
  
if not num2.is_integer():
  num2 = int(num2) + 1
  
num1 = int(num1)
num2 = int(num2)
print(min(num1, num2))

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

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

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

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

Solution (Python):
def resolve():
    import sys
    import math
    H, W, N = map(int, sys.stdin.read().rstrip().split('\n'))
    m = max(H, W)
    print(math.ceil(N / m))

resolve()

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

k = max(H, W)

print(int(np.ceil(N/k)))

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

print((n + x - 1) // x)

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    h = ri()
    w = ri()
    n = ri()
    m = max(h, w)
    print((n+m-1)//m)


if __name__ == '__main__':
    main()

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

a = 0
ans = 0

if h < w:
    a = w
else:
    a = h

ans = n // a

if n % a > 0:
    ans += 1

print(ans)

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

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

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

    if h >= w:
        big = h
    else:
        big = w

    if n <= big:
        print(1)
        exit()

    for i in range(big+1):
        if i * big >= n:
            count = i
            print(count)
            exit()
 
if __name__ == '__main__':
    main()

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
res,i = max(H,W),0
while res*i<N:
    i+=1
print(i)

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

import math
if H > W:
    ans = N / H
else:
    ans = N / W

print(math.ceil(ans))

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

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

Solution (Python):

def read():
    h = int(input())
    w = int(input())
    n = int(input())
    return h, w, n


def calc(h, w, n):
    if h > w:
        w = h
    
    if n % w  == 0:
        return int(n / w)
    else:
        return int(n/w)+1


def main():
    print(calc(*read()))


if __name__ == "__main__":
    main()

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

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

print(cnt)

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

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

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

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):
N = int(input())
M = int(input())
K = int(input())
print(-(-K//max(N,M)))

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())
x=max(h,w)
ans=(n+x-1)//x
print(ans)

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(math.ceil(N/max(H,W)))

Solution (Python):
h,w,n=[int(input()) for i in range(3)]
print(-(-n//max(h,w)))

Solution (Python):
h, w, n = [input() for i in range(3)]
x = int(n)//(int(h)+0.1)+1 if int(h)>int(w) else int(n)//(int(w)+0.1)+1
print(int(x))

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
 
upper = H if H >= W else W

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

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):
s = [int(input()) for i in range(3)]
target = s[2]
if s[0] >= s[1]:
  long = s[0]
  short = s[1]
else:
  long = s[1]
  short = s[0]
 
for i in range(short):
  if long * (i+1) >= target:
    print(str(i+1))
    break

Solution (Python):
import math

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

bigger = max(H,W)
count = N / bigger

print(math.ceil(count))

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

ans = 0
point = 0
if h <= w:
    for i in range(h):
        point += w
        ans += 1
        if point >= n:
            break
else:
    for i in range(w):
        point += h
        ans += 1
        if point >= n:
            break
print(ans)

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

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

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

Solution (Python):
import sys
bbn=1000000007
	


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

isTest=False

def pa(v):
	if isTest:
		print(v)

if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
mn = max(H,W)
mx = max(H,W)
ans = 0
x = 0
while x<N:
  x += mx
  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):
import math 

H, W, N = [int(input()) for i in range(3)]

if H >= W:
    long = H
else:
    long = W

c = math.ceil(N / long )

print(c)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
count = 0
sum_a = 0
sum_b = 0

while True:
	count += 1
	sum_a += H
	if sum_a >= N:
		print(count)
		break
	sum_b += W
	if sum_b >= N:
		print(count)
		break

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

Solution (Python):
r=int(input())
c=int(input())
n=int(input())
if n%r==0:
    t=n//r
else:
    t=n//r+1
if n%c==0:
    s=n//c
else:
    s=n//c+1

if t>s:
    print(s)
else:
    print(t)

Solution (Python):
import math
import sys

H = int(input())
W = int(input())
N = int(input())
s = max(H,W)
print((N-1) // s + 1 )

Solution (Python):
H=int(input())
W=int(input())
N=int(input())
count=0
tmp=0
flag=True
while flag:
  tmp+=max(H,W)
  count+=1
  if tmp>=N:
    flag=False
print(count)

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

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

print(ans)

Solution (Python):

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


M = max(H, W)
answer = 0
temp = 0

while temp < N:
    temp += M
    answer += 1

print(answer)

Solution (Python):

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

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

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

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

Solution (Python):
import math

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

max_number_of_tiles = max(H, W)

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

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

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

Solution (Python):
import math

height = int(input())
width = int(input())
require = int(input())

check = height if height > width else width

ans = math.ceil(require / check)
print(ans)