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

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

if H > W:
    for i in range(1, W+1):
        if H * i >= N:
            print(i)
            break
else:
    for i in range(1, H+1):
        if W * i >= N:
            print(i)
            break

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

black = 0
result = 0
while black < N:
    if W < 0 or H < 0:
        print('error. W and H should be more tham 0')
        break

    if H > W:
        black += H
        W -= 1
    else:
        black += W
        H -= 1
    result += 1

print(result)

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

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
ans = 0
painted_mas = 0


def min_raw():
    if H > W:
        return W
    elif W >= H:
        return H


def max_raw():
    if H > W:
        return H
    elif W >= H:
        return W


for i in range(min_raw()):
    ans += 1
    painted_mas += max_raw()
    if N <= painted_mas:
        print(ans)
        break

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

ans=0
count=0
i=0
while i<min(w,h):
	count+=max(w,h)
	ans+=1
	i+=1
	if count>=n:
		break

if count<n:
	j=0
	while j<max(w,h):
		ans+=1
		count+=min(w,h)
		j+=1
		if count>=n:
			break
print(ans)

Solution (Python):
H,W,N = int(input()),int(input()),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 = b= ans = 0

if h >= w:
  a = h
else:
  a = w

x = True

while x:
  if b < n:
    b += a
    ans += 1
  else:
    x = False

print(ans)

Solution (Python):


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

num = 0
count = 0
w1 = w
w2 = w
h1 = h
h2 = h

while n > num:
    if w2 >= h2:
        num += w2
        w1 -= 1
        h2 -=1
    else:
        num += h2
        h1 -= 1
        w2 -=1
    
    count += 1

print(count)

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

while True:
  if max(H,W)*i>=N:
    print(i)
    break
  i=i+1

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

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

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

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

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

if m > w:
    p = m
else:
    p = w

result = math.ceil(n / p)
print(result)

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

M = 0
L = 0
if H >= W:
    M = W
    L = H
else:
    M = H
    L = W

P = 0
ans = 0
for i in range(1, M+1):
    P += L
    ans += 1
    if P >= N:
        break

print(ans)

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

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

a=max(h,w)

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

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

if a > b :
    d = a
else:
    d = b

anser = c/d
if c%d > 0 :
    anser = anser +1

print(int(anser))

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

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

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

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


import math

row = int(input())
col = int(input())
objective = int(input())

bigger = row if row >= col else col
output = math.ceil(objective / bigger)

print(output)

Solution (Python):


from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

def main():
    h = ii()
    w = ii()
    n = ii()
    print(ceil(n/max(h,w)))




main()

Solution (Python):
h,w,n = [int(input()) for i in range(3)]
p = 0
for i in range(1,min(h,w)+1):
    p += max(h,w)
    if n<=p:
        print(i)
        exit()

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

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

Solution (Python):
import math

def int_input():
    return int(input())

H = int_input()
W = int_input()
N = int_input()

max_len = max(H, W)

print(math.ceil(N/max_len))

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

big = 0
temp = 0

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

c = 1

for i in range(1000000):
  if big >= n:
    break
  big += temp
  c += 1

print(c)

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

min_ = 9999999

for x in range(w+1):
  for y in range(h+1):
    if h*w - (h-y)*(w-x) >= n:
      min_ = min(x+y, min_)

print(min_)

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

M = max(h, w)
m = min(h, w)

from math import ceil
print(ceil(n / M))

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

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

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

N = int(input())

ans1 = 0
ans2 = 0

tmp = 0
for i in range(H):
    tmp += W
    if tmp >= N:
        ans1 = i+1
        break        

tmp = 0
for i in range(W):
    tmp += H
    if tmp >= N:
        ans2 = i+1
        break        
        
print(min(ans1,ans2))

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
print(n//w if n%w == 0 else n//w+1)

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):
s = [int(input()) for i in range(3)]
H = s[0]
W = s[1]
N = s[2]
a = max(H,W)
b = (N + a -1)//a
print(b)

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

if h>=w:
    l=h
else:
    l=w
if n%l==0:
    print(n//l)
else:
    print(n//l+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())
cnt1 = N // H
cnt2 = N // W
min_cnt = min(cnt1, cnt2)
if min_cnt * H < N and min_cnt * W < N:
  min_cnt = min_cnt + 1
print(min_cnt)

Solution (Python):
import math

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

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

Solution (Python):
H=int(input())
W=int(input())
N=int(input())
sumation=0
count=1
while True:
    index=max(H,W)
    if(index==H):
        sumation+=index
        W-=1
    elif(index==W):
        sumation+=index
        H-=1
    

    if(sumation>=N):
        break
    else:
        count+=1

print(count)

Solution (Python):

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

if H >= W:
    MAX=H
    Times=W
else:
    MAX=W
    Times=H

for i in range(1,Times+1):
    if MAX*i >= N:
        ans=i
        break

print(ans)

Solution (Python):
import math

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

if H < W:
    tmp = W
else:
    tmp = H

i = 1
while tmp * i < N:
    i += 1
print(i)

Solution (Python):



def main():
    h = int(input())
    w = int(input())
    n = int(input())
    max_value = max(h, w)

    for i in range(10000 + 1):
        if max_value * i >= n:
            print(i)
            exit()


if __name__ == '__main__':
    main()

Solution (Python):
h, w, n = list(int(input()) for a in range(3))
if h>=w:
    key=h

elif h<w:
    key=w

cnt = 0
while n>0:
    n=n-key
    cnt+=1

print(cnt)

Solution (Python):
import sys


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

    n_black = 0

    larger = max([H, W])
    smaller = min([H, W])

    n_l = 0
    n_s = 0

    for i in range(H+W):
        paint_l = larger - n_s
        paint_s = smaller - n_l

        if paint_l >= paint_s:
            n_black += paint_l
            n_l += 1
        else:
            n_black += paint_s
            n_s += 1

        if n_black >= N:
            break

    print(n_l + n_s)


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
S=int(input())
T=int(input())

if N>S:
    if T%N==0:
        ans=T//N
    else:
        ans=int(T/N)+1
else:
    if T%S==0:
        ans=T//S
    else:
        ans=int(T/S)+1

print(ans)

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

HW = max(H, W)
a = N // HW
if a * HW < N:
    a += 1
print(a)

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

large=max(H,W)

if (N/large).is_integer():
    print(int(N/large))
else:
    print(int(N/large)+1)

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

s = 0
c = 0

while s < N:
    if H < W:
        s += W
        H -=1
    else:
        s += H
        W -=1
    c += 1

print(c)

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

Solution (Python):
H=int(input())
W=int(input())
N=int(input())
p=0
cnt=0

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

print(cnt)

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

Solution (Python):

si = lambda: input()
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
h=ni()
w=ni()
n=ni()
ans=0
for i in range(10000):
    if n>0:
        t=max(h,w)
        n-=t
        ans+=1
    elif n<=0:
        break
print(ans)

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

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

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 = [list(map(int, s.split()))[0] for s in open(0)]
print(min(int((n-1)//h+1), int((n-1)//w+1)))

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

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

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

print(count)

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

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

Solution (Python):
import math

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

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

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

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

Solution (Python):




import sys
input = sys.stdin.readline



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

    res = 0
    black = 0

    if H >= W:
        D = W
        E = H
    else:
        D = H
        E = W

    for i in range(D):
        if black >= N:
            break
        black += E
        res += 1

    print(res)



main()

Solution (Python):
from sys import stdin
import math

h = int(stdin.readline().rstrip())
w = int(stdin.readline().rstrip())
n = int(stdin.readline().rstrip())

i = n / max(h,w)

print(math.ceil(i))

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
cur = 0
cnt = 0
bigger = max(h, w)

while True:
    if cur >= n:
        break

    cur += bigger
    cnt += 1

print(cnt)

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

num = 0
many = 0

while(1):
    if n <= many:
        break

    if h > w:
        many += h
        num+=1
    else:
        many += w
        num+=1

print (num)

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


def f(x):
    if x % 1 == 0:
        return int(x)
    else:
        return int(x) + 1


y = f(n / max(h, w))
print(y)

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

ans = 0
border = n

for i in range(1000):

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

    if n <= 0:
        print(ans)
        sys.exit()

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


ans = n // max(w, h)
if ans * max(w,h) < n:
    ans += 1
print(ans)

Solution (Python):
import numpy as np

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

count = 0

if H <= W:
    count = np.ceil(N/W)
else:
    count = np.ceil(N/H)

print(int(count))

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):
import sys


def main():
    h = int(input())
    w = int(input())
    n = int(input())
    if h < w:
        res = n // w
        if n % w > 0:
            res += 1
    else:
        res = n // h
        if n % h > 0:
            res += 1
    print(res)


if __name__ == '__main__':
    input = sys.stdin.readline
    main()

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

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

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

Solution (Python):
import math


def main():
    h = int(input())
    w = int(input())
    n = int(input())
    ans = math.ceil(n / max(w, h))

    print(ans)


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

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

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



x = max(H, W)
print int(math.ceil(1.0*N/x))

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

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

Solution (Python):
H = int(input())
W = int(input())
N = int(input())
if W<H:
    small=W
    large=H
else:
    small=H
    large=W
mod=N%large
if mod==0:
    print(int(N/large))
else:
    print(int(N/large)+1)

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

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

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

x = max([h, w])

num = n % x
if num:
  print(n // x + 1)
else:
  print(n // x)

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

a = max(H, W)
kuro = 0

times = 0

while kuro < N:
    kuro += a
    times +=1
    
print(times)

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

Solution (Python):
from math import ceil

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

m = max(H, W)

print(ceil(N / m))

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())
ans = 0
idx = 0
if H > W:
    pass
elif W > H:
    H,W = W,H

for i in range(1,W+1):
    ans += H
    idx += 1
    if ans >= N:
        print(idx)
        break

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 = []
black = 0
if h >= w:
    for i in range(h * w):
        black = h * i
        if black >= n:
            ans.append(i)
    print(min(ans))
else:
    for i in range(h * w):
        black = w * i
        if black >= n:
            ans.append(i)
    print(min(ans))

Solution (Python):
'''
条件に合うものを絞り込む
data = [1, 2, 3]
s = [x for x in data if x % 3 == 0]
'''
'''
文字配列を数値に
l_si = ['-10', '0', '100']

l_si_i = [int(s) for s in l_si]
'''
'''
a = [2, 4, 6, 8]
b = [3, 6, 9]

print(list(set(a) | set(b)))  
print(list(set(a) & set(b)))  
'''
'''
N = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
while len([x for x in A if x % 2 == 0]) == N:
    A = list(map(lambda y: y / 2, A))
    count += 1
print(count)
'''
'''
.append(要素)
.extend(要素)
.insert(場所,要素)
del 配列名[場所]
-1で末尾で末尾から一つ前
'''
'''
間に空白追加
' '.join(lis)
'''
'''
copy.copy(配列名)
'''
'''
sort()
sorted(reverse=true)
'''
'''
2分探索
bisect.bisect_left(リスト, 要素)
'''
'''
リスト同士の演算
list(map(lambda x, y: x+y, el2, el3))
'''
'''
配列の初期化
配列名=[a]*n+[b]*m
'''
'''
重複
list(set())
２次元配列
list(map(list, set(map(tuple, addition))))
'''
'''
順列
for el in itertools.permutations(配列のパターン):
'''
'''
Decimal()
'''






from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
import itertools
from functools import reduce
from operator import mul
def gcd(*numbers):
    return reduce(math.gcd, numbers)


def gcd_list(numbers):
    return reduce(math.gcd, numbers)


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


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


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


H = int(stdin.readline().rstrip())
W = int(stdin.readline().rstrip())
N = int(stdin.readline().rstrip())
use = 0
if H >= W:
    use = H
else:
    use = W
res = N / use
if N % use != 0:
    res += 1
print(int(res))

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

print(int(n/max(h,w) +0.99999))

Solution (Python):
import sys

h, w, n = map(int, sys.stdin.read().split())
if h < w:
        h, w = w, h

def main():
    return (n + h - 1) // h

if __name__ == '__main__':
    ans = main()
    print(ans)

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


if H < W:
    H, W = W, H

n = 0
cnt = 0
while n < N:
    n += H
    cnt += 1

print(cnt)

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

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

Solution (Python):
h, w, n = map(int, open(0).read().split())
print( (n+(max(h,w)-1))//max(h,w) )

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

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

a = 0
b = 0
while a<n:
  a += max(h, w)
  b += 1

print(b)

Solution (Python):
import sys
import math

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

    if H >= W:
        nuri = H
    else:
        nuri = W

    print(math.ceil(N / nuri))

main()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def main():
    h=II()
    w=II()
    n=II()
    if h<w:h,w=w,h
    ans=(n+h-1)//h
    print(ans)
main()

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())
mod = 10**9+7

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

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

if h > w:
    div = h
else:
    div = w

if n % div > 0:
    ans = int(n / div) + 1
else:
    ans = int(n / div)

print(ans)

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

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

print(ans)

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

Solution (Python):
H=int(input())
W=int(input())
N=int(input())
a=0
i=0
if H>=W:
  a=H
else:
  a=W

while a*i<N:
  i+=1
print(i)

Solution (Python):
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)

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

nn = max(h,w)

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

Solution (Python):
def main():
    H = int(input())
    W = int(input())
    N = int(input())
    cnt = 0
    while N > 0:
        if H > W:
            N -= H
            W -= 1
        else:
            N -= W
            H -= 1
        cnt += 1
    print(cnt)


if __name__ == '__main__':
    main()

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

if h < w:
  temp = h
  h = w
  w = temp

for i in range(w):
  if (i+1)*h >= n:
    res = i + 1
    break

print(res)

Solution (Python):

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

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

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

Big = max(H,W)

i = 0

while Big * i < N:
    i += 1
print(i)

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
from itertools import count, permutations
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok


def main():
    H,W,N=ii(),ii(),ii()
    if H>W:
        H,W=W,H
    s = 0
    for i in count(1):
        s += W
        if s>=N:
            print(i)
            break


main()

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):
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())
st=0

if(W>H):
  st=W
  W=H
  H=st
  
count=0
sum=0

while not(sum>=N):
  count+=1
  sum+=H

print(count)

Solution (Python):
h= int(raw_input())
w= int(raw_input())
n= int(raw_input())
m=max([h,w])


for i in range(1,100000):
    n -= m
    if n <= 0:
        break
print(i)

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

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

use = 0
if H > W:
    use = H
else:
    use = W
ans = math.ceil( N / use)
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())

nuru = max(h,w)

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

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

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

Solution (Python):
h = int(input())
w = int(input())
n = int(input())
if w>=h:
  print( -(-n//w) )
else:
  print( -(-n//h) )

Solution (Python):
import math

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

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

Solution (Python):
from math import ceil

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

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

Solution (Python):
import math
a,b,c = (int(input()) for _ in range(3))
print(math.ceil(c/max(a,b)))

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):
import math
 
def main():
    H = int(input())
    W = int(input())
    N = int(input())
 
    if H >= W:
        h = H
        w = W
    else:
        h = W
        w = H
    
    ans = math.ceil(N / h)
    print(ans)



if __name__ == '__main__':
    main()

Solution (Python):



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

a = 0
c = 0

if h > w:
    m = h
else:
    m = w
    
while a < n:
    a += m
    c += 1
    
print(c)

Solution (Python):
import math

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

v = max(h,w)

print(math.ceil(n/v))

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())

sys.setrecursionlimit(10 ** 9)


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

    num = max(H, W)

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


if __name__ == '__main__':
    main()

Solution (Python):



import pdb
import sys
F = sys.stdin

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

many = max(H, W)
ans = 0

ans = N // many + 1
if N % many == 0:
    ans = N // many

print(ans)

Solution (Python):
def main():
    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)
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):
H=int(input())
W=int(input())

N=int(input())

X=0
if H>W:
    X=H

else:

    X=W
flag=True
counter=0
while flag:
    N=N-X
    counter+=1
    if N<=0:
        flag=False
print(counter)

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

maxi = max(h, w)
mini = min(h, w)

if (n/maxi == int(n/maxi)):
    print(n//maxi)
else:
    print(n//maxi + 1)

Solution (Python):
import math

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


if H > W :
    target = H
else: 
    target = W

print(math.ceil(N / target) )

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

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

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

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

cnt = 0
if H < W:
    c = 0
    while c < N:
        cnt += 1
        c += W
else:
    c = 0
    while c < N:
        cnt += 1
        c += H

print(cnt)

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())
import math
if H > W:
    a = math.ceil(N/H)
else:
    a = math.ceil(N/W)
print(a)

Solution (Python):
from sys import stdin,stdout
H = int(stdin.readline())
W = int(stdin.readline())
N = int(stdin.readline())
print(N//max(H,W)+1) if N % max(H,W) != 0 else print(N//max(H,W))

Solution (Python):
import math

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

main()