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 sys
from fractions import gcd
from string import ascii_lowercase as ABC

def inpl(): return list(map(int, input().split()))
H = int(input())
W = int(input())
N = int(input())
X = max(H, W)
print(-(-N//X))

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

A = N % H
B = N % W
if H > W and A != 0:
	print(N // H + 1)
elif H > W and A == 0:
	print(N // H)
elif H < W and B != 0:
  print(N // W + 1)
elif H < W and B == 0:
  print(N // W)
else:
  print(N // W)

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

Solution (Python):
import math

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

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

ans = N / select_num

print(math.ceil(ans))

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

x = max(w,h)

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

print(ans)

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

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

print(ans)

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

d = max(a,b)

e = c // d
mod = c % d
if mod == 0:
    print(e)
elif mod != 0:
    print(int(e) + int(1))

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

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

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

big = max(H, W)
tmp = max(H, W)
count = 0

for i in range(10**8):
    count += 1
    if big >= N:
        print(count)
        exit()
    big += tmp

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

colored = 0
ans = 0

if h >= w:
  for i in range(w):
    colored += h
    if colored >= n:
      ans = i + 1
      break
else:
  for i in range(h):
    colored += w
    if colored >= n:
      ans = i + 1
      break

print(ans)

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 = math.ceil(n / w)
b = math.ceil(n / h)

if a > b:
    print(b)
else:
    print(a)

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

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

m = max(h, w)

for i in range(10000):
    if i * m >= n:
        print(i)
        break

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

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

myflag = [ [ 0 for w in range(W)] for h in range(H) ]


def check_black():
    mycnt = 0
    for h in range(H):
        for w in range(W):
            if myflag[h][w] == 1:
                mycnt += 1
    return mycnt

mycnt = check_black()


myans = 0
myblack = 0
h_cnt = 0
w_cnt = 0
while mycnt < N:
    if H > W and w_cnt < W:
        for h in range(H):
            myflag[h][w_cnt] = 1
        w_cnt += 1
    else:
        for w in range(W):
            myflag[h_cnt][w] = 1
        h_cnt += 1
    myans += 1
    mycnt = check_black()

print(myans)

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())
k=0
if H<=W:
    for i in range(H):
        ans=0
        ans=(i+1)*W
        k=k+1
        if ans>=N:
            break
else:
    for i in range(W):
        ans=0
        ans=(i+1)*H
        k=k+1
        if ans>=N:
            break

print(k)

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

print(ans)

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

counter = 0
i = 0

if (H >= W):
    while(True):
        if (H*i) < N:
            counter += 1
        else:
            break
        i += 1
else:
    while(True):
        if (W*i) < N:
            counter += 1
        else:
            break
        i += 1

print(counter)

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

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

cnt=0
if H<=W:
    while True:
        if N>0:
            cnt+=1
            N-=W
        else:
            print(cnt)
            exit()

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

Solution (Python):
import sys

input = sys.stdin.readline

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

count = 0
ans = 0
if H <= W:
    for i in range(H):
        count += W
        if count >= N:
            ans = i + 1
            break
else:
    for i in range(W):
        count += H
        if count >= N:
            ans = i + 1
            break
print(ans)

Solution (Python):
import math

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

max_len = max(H, W)
result = math.ceil(N / max_len)

print(result)

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

big = max(h, w)
count = 0
kuro = 0
while kuro < n:
    kuro += big
    count += 1
print(count)

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

ans = 0
if h <= w:
  while ans * w < n:
    ans += 1
else:
  while ans * h < n:
    ans += 1

print(ans)

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

if n <= h or n <= w :
 print(1)
else:
 print(math.ceil(n/max(h,w)))

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

L = H
if W > H:
  L = W

if N < L:
  ans = 1
elif N % L == 0:
  ans = N/L
else:
  ans = N/L + 1
  
print('{:.0f}'.format(ans))

Solution (Python):


h = int(input())
w = int(input())
n = int(input())
count  = num = 0

higher = max(h,w)
lower = min(h,w)

for i in range(lower):
    count = higher*(i+1)
    num += 1
    if count>=n:
        print(num)
        exit()

Solution (Python):
import math
line=[int(input()) for i in range(3)]
a=max(line[0],line[1])
b=int(math.ceil(line[2]/a))
print(b)

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
        lines.append(input())
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    h = int(lines[0])
    w = int(lines[1])
    n = int(lines[2])
    return (h, w, n)


def solve(h, w, n):

    o = max([h, w])

    if n % o == 0:
        result =  n // o
    else:
        result = int(math.floor(n / o)) + 1
    
    return result


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

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

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

Solution (Python):
import math

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

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

Solution (Python):
s = input()
k = input()
l = input()
if s > k :
        d = l/s
        j = l % s
        if j != 0:
                d += 1
                print(d)
        else:
                print(d)
else:
        d = l/k
        j = l % k
        if j != 0:
                d += 1
                print(d)
        else:
                print(d)

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

max_num = H if H > W else W

i = 1
while (max_num*i < N):
    i += 1

print(i)

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

Solution (Python):
import math

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

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

Solution (Python):
import sys
s = [int(sys.stdin.readline()) for _ in range(3)]

if s[0] < s[1]:
  ans = s[2]//s[1]
  if s[2]%s[1] != 0:
    ans += 1
else:
  ans = s[2]//s[0]
  if s[2]%s[0] != 0:
    ans += 1

print(ans)

Solution (Python):
import math
args = [int(input()) for i in range(3)]

draw_flag = 0
if args[0] < args[1]:
    print(math.ceil(args[2] / args[1]))
else:
    print(math.ceil(args[2] / args[0]))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
count = 0
black = 0
big = 0
if h >= w:
  big = h
else:
  big = w
while black < n:
  black += big
  count += 1
print(count)

Solution (Python):

import sys
import math

def solve(H: int, W: int, N: int):
    print(-(-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):

def f(t, _ans, length):
    for _ in range(length):
        t += length
        _ans += 1

        if t >= n:
            print(_ans)
            exit()

    return _ans

h = int(input())
w = int(input())
n = int(input())
t = 0
ans = 0

if h > w:
    f1, f2 = h, w
else:
    f1, f2 = w, h

ans = f(t, ans, f1)
f(t, ans, f2)

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

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

co = 0
ans = 0

if H >= W:
    for i in range(W):
        co += H
        ans += 1
        if co >= N:
            break
else:
    for i in range(H):
        co += W
        ans += 1
        if co >= N:
            break

print(ans)

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

a = n / h
b = n / w

if a.is_integer():
    a -= 1

if b.is_integer():
    b -= 1

if a < b:
    print(int(a) + 1)
else:
    print(int(b) + 1)

Solution (Python):
line = int(input())
column = int(input())
min_black_tile = int(input())
paint_tile = 0
count = 0

if line > column:
  while paint_tile < min_black_tile:
    paint_tile += line
    count += 1
  print(count)
else:
  while paint_tile < min_black_tile:
    paint_tile += column
    count += 1
  print(count)

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

a=max(h,w)
b=min(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
num_bk = 0
for i in range(0,min(H,W)+1):
  num_bk += max(H,W)
  ans +=1
  if num_bk>=N:
    print(ans)
    break

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
a = max(H, W)
c = 0
ans = 0
while N > c:
    c += a
    ans += 1
print(ans)

Solution (Python):
import math

a = float(input())
b = float(input())
c = float(input())

out_a = math.ceil(c/a) 
out_b = math.ceil(c/b)

if out_a < out_b:
  print(out_a)
else:
  print(out_b)

Solution (Python):
from sys import stdin


def fetch_one_line():
    return stdin.readline().rstrip()


def fetch_int_input():
    return [int(s) for s in fetch_one_line().split()]


def fetch_inputs(times):
    return [fetch_one_line() for _ in range(times)]


def fetch_int_inputs(times):
    return [[int(s) for s in fetch_one_line()] for _ in range(times)]


def fetch_ints_inputs(times):
    return [fetch_int_input() for _ in range(times)]

H = int(fetch_one_line())
W = int(fetch_one_line())
N = int(fetch_one_line())

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

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

done=0
count=0
while True:
  if h>w:
    if w==0:
      exit()
    else:
      done+=h
      count+=1
      w-=1
  else:
    if h==0:
      exit()
    else:
      done+=w
      count+=1
      h-=1
  if done>=n:
    print(count)
    exit()

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

print(s)

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

write = 0
result = 0

while write < n:
    if w > h:
        write += w
        h -= 1
    else:
        write += h
        w -= 1
    result += 1

print(result)

Solution (Python):

import numpy as np
h = int(input())
w = int(input())
n = int(input())

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

Solution (Python):
from math import ceil

H = int(input())
W = int(input())
N = int(input())
long = max(H, W)
    
print(ceil(N/long))

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

if W >= H:
  Max = W
else:
  Max = H

print(math.ceil(N / Max))

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


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

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

Solution (Python):
import sys
from random import choice,randint
inp=sys.stdin.readline
out=sys.stdout.write
flsh=sys.stdout.flush
 
sys.setrecursionlimit(10**9)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
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 MI(): return map(int, inp().strip().split())
def LI(): return list(map(int, inp().strip().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]
def LI_(): return [int(x)-1 for x in inp().strip().split()]
def LF(): return [float(x) for x in inp().strip().split()]
def LS(): return inp().strip().split()
def I(): return int(inp().strip())
def F(): return float(inp().strip())
def S(): return inp().strip()
def pf(s): return out(s+'\n')
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()
    if H>=W:
        c,s=0,0
        while W>0:
            s+=H
            c+=1
            
            if s>=N:
                break
            W-=1
        print(c)
    else:
        c,s=0,0
        while H>0:
            s+=W
            c+=1
            
            if s>=N:
                break
            H-=1
        print(c)

if __name__ == "__main__":
    main()

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

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

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

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

M=max(H,W)

print(int(-(-N//M)))

Solution (Python):

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

temp=int(N%max(H,W)!=0)

print(N//max(H,W)+temp)

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

if H >= W:
  t = N//H
  if not N % H == 0:
    t +=1
else:
  t=N//W
  if not N % W == 0:
    t +=1

  
print(t)

Solution (Python):


from math import ceil

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



ret = min(ceil(n/h), ceil(n/w))

print(ret)

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

cnt = 0
painted = 0

while painted < N:
    if H < W:
        painted += W
        cnt += 1
        H -= 1
    else:
        painted += H
        cnt += 1
        W -= 1

print(cnt)

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

decr = max(h,w)

ans = 1
for i in range(min(h,w)):
    n -= decr
    if n <=0:
        print(ans)
        exit()
    ans += 1
print(ans)

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

C = 0
D = 0

while C < N:
    if H >= W:
        C = C + H
        D = D + 1
    if H < W:
        C = C + W
        D = D + 1

print(D)

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

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

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

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
arr = sorted([h,w])


if n%arr[1] == 0:
  print(n//arr[1])
else:
  print(n//arr[1] + 1)

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

k = max([H,W])
ans = math.ceil(N/k)

print(ans)

Solution (Python):
x = [int(input()) for i in range(3)]

if x[0] >= x[1]:
  print(x[2]//x[0]+1 if x[2]%x[0]!=0 else x[2]//x[0])
else:
  print(x[2]//x[1]+1 if x[2]%x[1]!=0 else x[2]//x[1])

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

eff = max([H,W])
mod = 1 if N%eff >=1 else 0
print(N//eff + mod)

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



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

else:
    a0=math.ceil(N/W)

print(a0)

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

c=int(max(h,w))
p=math.ceil(n/c)

print(p)

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

num=max([H,W])
ans=int(math.ceil(N/float(num)))

print(ans)

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

painted = 0
cnt = 0
while(True):
    painted += max(H,W)
    cnt += 1
    if painted >= N:
        break
    
    if painted + min(H,W) -1 >= N:
        cnt += 1
        break

print(cnt)

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

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

c =0
if h > w:
    ma = h
    mi = w
else :
    ma = w
    mi = h

for i in range(mi):

    n = n-ma
    c += 1
    if(n<=0):
        break

print(c)

Solution (Python):
H, W, N = map(int, open(0).read().split())

if( N % max(H, W) == 0):
  print(int(N/max(H, W)))
elif ( N < max(H, W)*int( round(int(N/max(H, W) +0.50)) ) ):
  print(round(N/max(H, W)))
else:
  print(round(N/max(H, W)) + 1)

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
d = [h,w]
num = 0
for i in range(min(d)):
    if max(d) * (i+1) >= n :
        num = i + 1
        break
print(num)

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

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())
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())
cnt = 0
s = 0
a = max([h,w])

while(s < n):
  s += a
  cnt += 1

print(cnt)

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

import math
a = 0

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

Solution (Python):
import math

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

blacks = 0
if H > W:
    n_columns = min(math.ceil(N / H), W)
    blacks += H * n_columns
    if blacks < N:
        n_rows = math.ceil((N - blacks) / (W - n_columns))
    else:
        n_rows = 0
    print(n_columns + n_rows)
else:
    n_rows = min(math.ceil(N / W), H)
    blacks += W * n_rows
    if blacks < N:
        n_columns = math.ceil((N - blacks) / (H - n_rows))
    else:
        n_columns = 0
    print(n_columns + n_rows)

Solution (Python):

import math


def main():
    input_list = [input() for i in range(3)]
    H = int(input_list[0])
    W = int(input_list[1])
    N = int(input_list[2])

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

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

max_n = max(h, w)

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

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())
x = max(W,H)
N = int(input())
if N%x == 0:
    print(N//x)
else:
    print(N//x+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 h <= w:
        high = w
    else:
        high = h
    for i in range(1, n+1):
        if high * i >= n:
            print(i)
            return


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
h = int(input())
w = int(input())
n = int(input())
a = max(h, w)

for i in range(n+1):
    if a*i >= n:
        print(i)
        sys.exit()

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

    count = 0
    painted = 0

    while painted < n:
        if h > w:
            painted += h
            w -= 1
            count += 1
        else:
            painted += w
            h -= 1
            count += 1
    print(count)


if __name__ == '__main__':
    main()

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

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 = int(input())
w = int(input())
n = int(input())
import math
print (math.ceil(n/max(h,w)))

Solution (Python):

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

max_a = max(h,w)

ans = 1
for i in range(min(h,w)):
    n = n - max_a
    if n <=0:
        print(ans)
        exit()
    ans += 1
print(ans)

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
large = max(H, W)
black = 0
count = 0
while black < N:
    count += 1
    black += large

print(count)

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

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

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

c = 1

if h > w:
    x = h
    y = h
else:
    x = w
    y = w

while x < n:
    c += 1
    x += y
print(c)

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

if H < W:
  count = N // W
  rate = N / W
  if count < rate:
     count += 1
  print(count)
else:
  count = N // H
  rate = N / H
  if count < rate:
     count += 1
  print(count)

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

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

ans = 0

if h > w:
    x = h
else:
    x = w
    
while n > 0:
    n = n - x
    ans += 1

print(ans)

Solution (Python):
import math

a=input()
b=input()
c=input()
m=max(int(a),int(b))
print(math.ceil(int(c)/int(m)))

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
import queue


Mod = 1000000007
import sys

sys.setrecursionlimit(100000) 
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

def factorial(i):
    if i == 1:
        return 1
    else:
        return i*factorial(i-1)
 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)




def main(): 
   h = int(input())
   w = int(input())
   n = int(input())
   p = max(h,w)
   if n % p == 0:
       print(n//p)
   else:
       print(n//p+1)

if __name__ == "__main__":
    main()

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

Solution (Python):
h, w, n = [int(input()) for _ in range(3)]

l = max(h, w)
p = 0
c = 0
while p < n:
    c += 1
    p += l
print(c)

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

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

Solution (Python):
a = int(input())
b = int(input())
c = int(input())
count= 1
aa = a
bb = b
if a<b :
  while c> bb:
    bb += b
    count +=1

else:
  while c> aa:
    aa += a
    count +=1
print(count)

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